* som.c (hppa_object_setup): Set SEC_CODE for .text section so

	that GDB can figure out text_start and text_end.

2 files changed, 568 insertions, 191 deletions

diff --git a/bfd/ChangeLog b/bfd/ChangeLog
index 92ea13b..1f60d3e 100644
--- a/bfd/ChangeLog
+++ b/bfd/ChangeLog
@@ -1,3 +1,8 @@
+Tue Oct 26 02:40:46 1993  Stu Grossman  (grossman at cygnus.com)
+
+	* som.c (hppa_object_setup):  Set SEC_CODE for .text section so
+	that GDB can figure out text_start and text_end.
+
 Mon Oct 25 16:05:23 1993  Ian Lance Taylor  (ian@tweedledumb.cygnus.com)
 
 	Fix up warnings from gcc -Wall:
diff --git a/bfd/som.c b/bfd/som.c
index 8fd1324..8d6d14d 100644
--- a/bfd/som.c
+++ b/bfd/som.c
@@ -4,29 +4,25 @@
    Contributed by the Center for Software Science at the
    University of Utah (pa-gdb-bugs@cs.utah.edu).
 
-This file is part of BFD, the Binary File Descriptor library.
+   This file is part of BFD, the Binary File Descriptor library.
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
 
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
 #include "bfd.h"
 #include "sysdep.h"
 
-/* @@FIXME This is not a reasonable set of conditions to permit
-   cross-compilation, obviously.  It also isn't enough to support hppa-elf
-   targets either.  Can we eliminate the HPUX or BSD dependencies, or
-   at least get the conditionals more localized?  */
 #if defined (HOST_HPPAHPUX) || defined (HOST_HPPABSD)
 
 #include "libbfd.h"
@@ -70,59 +66,81 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
      ((__m_num) >= _PA_RISC1_1_ID && (__m_num) <= _PA_RISC_MAXID))
 #endif /* _PA_RISC_ID */
 
-struct container
-  {
-    struct header f;
-    struct som_exec_auxhdr e;
-  };
+/* Forward declarations */
+
+static boolean som_mkobject PARAMS ((bfd *));
+static bfd_target * som_object_setup PARAMS ((bfd *,
+					      struct header *,
+					      struct som_exec_auxhdr *));
+static asection * make_unique_section PARAMS ((bfd *, CONST char *, int));
+static boolean setup_sections PARAMS ((bfd *, struct header *));
+static bfd_target * som_object_p PARAMS ((bfd *));
+static boolean som_write_object_contents PARAMS ((bfd *));
+static boolean som_slurp_string_table PARAMS ((bfd *));
+static unsigned int som_slurp_symbol_table PARAMS ((bfd *));
+static unsigned int som_get_symtab_upper_bound PARAMS ((bfd *));
+static unsigned int som_canonicalize_reloc PARAMS ((bfd *, sec_ptr,
+						    arelent **, asymbol **));
+static unsigned int som_get_reloc_upper_bound PARAMS ((bfd *, sec_ptr));
+static unsigned int som_get_symtab PARAMS ((bfd *, asymbol **));
+static asymbol * som_make_empty_symbol PARAMS ((bfd *));
+static void som_print_symbol PARAMS ((bfd *, PTR,
+				      asymbol *, bfd_print_symbol_type));
+static boolean som_new_section_hook PARAMS ((bfd *, asection *));
+static boolean som_set_section_contents PARAMS ((bfd *, sec_ptr, PTR,
+						 file_ptr, bfd_size_type));
+static boolean som_set_arch_mach PARAMS ((bfd *, enum bfd_architecture,
+					  unsigned long));
+static boolean som_find_nearest_line PARAMS ((bfd *, asection *,
+					      asymbol **, bfd_vma,
+					      CONST char **,
+					      CONST char **,
+					      unsigned int *));
+static void som_get_symbol_info PARAMS ((bfd *, asymbol *, symbol_info *));
+static asection * som_section_from_subspace_index PARAMS ((bfd *, 
+							   unsigned int));
+static int log2 PARAMS ((unsigned int));
+
+
+/* Return the logarithm of X, base 2, considering X unsigned. 
+   Abort if X is not a power of two -- this should never happen.  */
+
+static int
+log2 (x)
+     unsigned int x;
+{
+  int log = 0;
+
+  /* Test for 0 or a power of 2.  */
+  if (x == 0 || x != (x & -x))
+    abort();
+
+  while ((x >>= 1) != 0)
+    log++;
+  return log;
+}
+
+/* Perform some initialization for an object.  Save results of this
+   initialization in the BFD.  */
 
 static bfd_target *
-hppa_object_setup (abfd, file_hdrp, aux_hdrp)
+som_object_setup (abfd, file_hdrp, aux_hdrp)
      bfd *abfd;
      struct header *file_hdrp;
      struct som_exec_auxhdr *aux_hdrp;
 {
-  struct container *rawptr;
-  struct header *f;
-  struct hppa_data_struct *rawptr1;
   asection *text, *data, *bss;
 
-  rawptr = (struct container *) bfd_zalloc (abfd, sizeof (struct container));
-  if (rawptr == NULL)
-    {
-      bfd_error = no_memory;
-      return 0;
-    }
-
-  rawptr1 = (struct hppa_data_struct *) bfd_zalloc (abfd, sizeof (struct hppa_data_struct));
-  if (rawptr1 == NULL)
-    {
-      bfd_error = no_memory;
-      return 0;
-    }
-
-  abfd->tdata.hppa_data = rawptr1;
-  obj_file_hdr (abfd) = &rawptr->f;
-  obj_aux_hdr (abfd) = &rawptr->e;
-  *obj_file_hdr (abfd) = *file_hdrp;
-  *obj_aux_hdr (abfd) = *aux_hdrp;
-
-  /* Set the file flags */
-  abfd->flags = NO_FLAGS;
-  if (file_hdrp->entry_offset)
-    abfd->flags |= HAS_RELOC;
-  if (file_hdrp->symbol_total)
-    abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
-
-  bfd_get_start_address (abfd) = aux_hdrp->exec_entry;
-
-  obj_pa_symbols (abfd) = (hppa_symbol_type *) NULL;
-  bfd_get_symcount (abfd) = file_hdrp->symbol_total;
+  /* som_mkobject will set bfd_error if som_mkobject fails.  */
+  if (som_mkobject (abfd) != true)
+    return 0;
 
-  bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 0);
+  /* Make the standard .text, .data, and .bss sections so that tools
+     which assume those names work (size for example).  They will have
+     no contents, but the sizes and such will reflect those of the
+     $CODE$, $DATA$, and $BSS$ subspaces respectively.
 
-  /* create the sections.  This is raunchy, but bfd_close wants to reclaim
-     them */
+     FIXME:  Should check return status from bfd_make_section calls below.  */
 
   text = bfd_make_section (abfd, ".text");
   data = bfd_make_section (abfd, ".data");
@@ -132,7 +150,7 @@ hppa_object_setup (abfd, file_hdrp, aux_hdrp)
   data->_raw_size = aux_hdrp->exec_dsize;
   bss->_raw_size = aux_hdrp->exec_bsize;
 
-  text->flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS);
+  text->flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_CODE);
   data->flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS);
   bss->flags = (SEC_ALLOC | SEC_IS_COMMON);
 
@@ -149,20 +167,35 @@ hppa_object_setup (abfd, file_hdrp, aux_hdrp)
   text->rel_filepos = 0;
   data->rel_filepos = 0;
 
-  /* The file offsets of the string table and symbol table.  */
-  obj_sym_filepos (abfd) = file_hdrp->symbol_location;
+  /* Set BFD flags based on what information is available in the SOM.  */
+  abfd->flags = NO_FLAGS;
+  if (! file_hdrp->entry_offset)
+    abfd->flags |= HAS_RELOC;
+  else
+    abfd->flags |= EXEC_P;
+  if (file_hdrp->symbol_total)
+    abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
+
+  bfd_get_start_address (abfd) = aux_hdrp->exec_entry;
+  bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 0);
   bfd_get_symcount (abfd) = file_hdrp->symbol_total;
-  obj_str_filepos (abfd) = file_hdrp->symbol_strings_location;
-  obj_stringtab_size (abfd) = file_hdrp->symbol_strings_size;
+
+  /* Initialize the saved symbol table and string table to NULL.  
+     Save important offsets and sizes from the SOM header into
+     the BFD.  */
+  obj_som_stringtab (abfd) = (char  *) NULL;
+  obj_som_symtab (abfd) = (som_symbol_type *) NULL;
+  obj_som_stringtab_size (abfd) = file_hdrp->symbol_strings_size;
+  obj_som_sym_filepos (abfd) = file_hdrp->symbol_location;
+  obj_som_str_filepos (abfd) = file_hdrp->symbol_strings_location;
+  obj_som_reloc_filepos (abfd) = file_hdrp->fixup_request_location;
 
   return abfd->xvec;
 }
 
 /* Create a new BFD section for NAME.  If NAME already exists, then create a
    new unique name, with NAME as the prefix.  This exists because SOM .o files
-   created by the native compiler can have a $CODE$ section for each
-   subroutine.
- */
+   may have more than one $CODE$ subspace.  */
 
 static asection *
 make_unique_section (abfd, name, num)
@@ -194,41 +227,41 @@ make_unique_section (abfd, name, num)
    BFD sections which correspond to spaces will overlap the sections for the
    associated subspaces.  */
 
-static int
+static boolean
 setup_sections (abfd, file_hdr)
      bfd *abfd;
      struct header *file_hdr;
 {
   char *space_strings;
   int space_index;
+  unsigned int total_subspaces = 0;
 
   /* First, read in space names */
 
   space_strings = alloca (file_hdr->space_strings_size);
   if (!space_strings)
-    return 0;
+    return false;
 
   if (bfd_seek (abfd, file_hdr->space_strings_location, SEEK_SET) < 0)
-    return 0;
+    return false;
   if (bfd_read (space_strings, 1, file_hdr->space_strings_size, abfd)
       != file_hdr->space_strings_size)
-    return 0;
+    return false;
 
   /* Loop over all of the space dictionaries, building up sections */
-
   for (space_index = 0; space_index < file_hdr->space_total; space_index++)
     {
       struct space_dictionary_record space;
-      struct subspace_dictionary_record subspace;
-      int subspace_index, tmp;
+      struct subspace_dictionary_record subspace, save_subspace;
+      int subspace_index;
       asection *space_asect;
 
       /* Read the space dictionary element */
       if (bfd_seek (abfd, file_hdr->space_location
 		    + space_index * sizeof space, SEEK_SET) < 0)
-	return 0;
+	return false;
       if (bfd_read (&space, 1, sizeof space, abfd) != sizeof space)
-	return 0;
+	return false;
 
       /* Setup the space name string */
       space.name.n_name = space.name.n_strx + space_strings;
@@ -236,33 +269,29 @@ setup_sections (abfd, file_hdr)
       /* Make a section out of it */
       space_asect = make_unique_section (abfd, space.name.n_name, space_index);
       if (!space_asect)
-	return 0;
+	return false;
 
       /* Now, read in the first subspace for this space */
       if (bfd_seek (abfd, file_hdr->subspace_location
 		    + space.subspace_index * sizeof subspace,
 		    SEEK_SET) < 0)
-	return 0;
+	return false;
       if (bfd_read (&subspace, 1, sizeof subspace, abfd) != sizeof subspace)
-	return 0;
+	return false;
       /* Seek back to the start of the subspaces for loop below */
       if (bfd_seek (abfd, file_hdr->subspace_location
 		    + space.subspace_index * sizeof subspace,
 		    SEEK_SET) < 0)
-	return 0;
-
-      /* Setup the section flags as appropriate (this is somewhat bogus, as
-	 there isn't a clear mapping between what's in the space record, and
-	 what BFD can describe here). */
-      if (space.is_loadable)
-	space_asect->flags |= SEC_ALLOC;
-      if (space.is_defined)
-	space_asect->flags |= SEC_LOAD;
+	return false;
 
       /* Setup the start address and file loc from the first subspace record */
       space_asect->vma = subspace.subspace_start;
       space_asect->filepos = subspace.file_loc_init_value;
-      space_asect->alignment_power = subspace.alignment;
+      space_asect->alignment_power = log2 (subspace.alignment);
+
+      /* Initialize save_subspace so we can reliably determine if this
+	 loop placed any useful values into it.  */
+      bzero (&save_subspace, sizeof (struct subspace_dictionary_record));
 
       /* Loop over the rest of the subspaces, building up more sections */
       for (subspace_index = 0; subspace_index < space.subspace_quantity;
@@ -273,7 +302,7 @@ setup_sections (abfd, file_hdr)
 	  /* Read in the next subspace */
 	  if (bfd_read (&subspace, 1, sizeof subspace, abfd)
 	      != sizeof subspace)
-	    return 0;
+	    return false;
 
 	  /* Setup the subspace name string */
 	  subspace.name.n_name = subspace.name.n_strx + space_strings;
@@ -283,39 +312,108 @@ setup_sections (abfd, file_hdr)
 				     space.subspace_index + subspace_index);
 
 	  if (!subspace_asect)
-	    return 0;
-
+	    return false;
+
+	  /* Keep an easy mapping between subspaces and sections.  */
+	  som_section_data (subspace_asect)->subspace_index 
+	    = total_subspaces++;
+
+	  /* Set SEC_READONLY and SEC_CODE/SEC_DATA as specified
+	     by the access_control_bits in the subspace header.  */
+	  switch (subspace.access_control_bits >> 4)
+	    {
+	    /* Readonly data.  */  
+	    case 0x0:
+	      subspace_asect->flags |= SEC_DATA | SEC_READONLY;
+	      break;
+
+	    /* Normal data.  */  
+	    case 0x1:
+	      subspace_asect->flags |= SEC_DATA;
+	      break;
+
+	    /* Readonly code and the gateways.
+	       Gateways have other attributes which do not map
+	       into anything BFD knows about.  */
+	    case 0x2:
+	    case 0x4:
+	    case 0x5:
+	    case 0x6:
+	    case 0x7:
+	      subspace_asect->flags |= SEC_CODE | SEC_READONLY;
+	      break;
+
+	    /* dynamic (writable) code.  */
+	    case 0x3:
+	      subspace_asect->flags |= SEC_CODE;
+	      break;
+	    }
+	  
+	  if (subspace.dup_common || subspace.is_common) 
+	    subspace_asect->flags |= SEC_IS_COMMON;
+	  else
+	    subspace_asect->flags |= SEC_HAS_CONTENTS;
 	  if (subspace.is_loadable)
 	    subspace_asect->flags |= SEC_ALLOC | SEC_LOAD;
 	  if (subspace.code_only)
 	    subspace_asect->flags |= SEC_CODE;
 
+	  /* This subspace has relocations.
+	     The fixup_request_quantity is a byte count for the number of
+	     entries in the relocation stream; it is not the actual number
+	     of relocations in the subspace.  */
+	  if (subspace.fixup_request_quantity != 0)
+	    {
+	      subspace_asect->flags |= SEC_RELOC;
+	      subspace_asect->rel_filepos = subspace.fixup_request_index;
+	      som_section_data (subspace_asect)->reloc_size
+		= subspace.fixup_request_quantity;
+	      /* We can not determine this yet.  When we read in the 
+		 relocation table the correct value will be filled in.  */
+	      subspace_asect->reloc_count = -1;
+	    }
+
+	  /* Update save_subspace if appropriate.  */
+	  if (subspace.file_loc_init_value > save_subspace.file_loc_init_value)
+	    save_subspace = subspace;
+
 	  subspace_asect->vma = subspace.subspace_start;
 	  subspace_asect->_cooked_size = subspace.subspace_length;
 	  subspace_asect->_raw_size = subspace.initialization_length;
-	  subspace_asect->alignment_power = subspace.alignment;
+	  subspace_asect->alignment_power = log2 (subspace.alignment);
 	  subspace_asect->filepos = subspace.file_loc_init_value;
-
 	}
+
+      /* Yow! there is no subspace within the space which actually 
+         has initialized information in it; this should never happen
+         as far as I know.  */
+      if (!save_subspace.file_loc_init_value)
+	abort ();
+
       /* Setup the sizes for the space section based upon the info in the
-	 last subspace of the space. */
-      space_asect->_cooked_size = (subspace.subspace_start - space_asect->vma)
-	+ subspace.subspace_length;
-      space_asect->_raw_size = (subspace.file_loc_init_value
-				- space_asect->filepos)
-	+ subspace.initialization_length;
+         last subspace of the space.  */
+      space_asect->_cooked_size = save_subspace.subspace_start
+	- space_asect->vma + save_subspace.subspace_length;
+      space_asect->_raw_size = save_subspace.file_loc_init_value
+	- space_asect->filepos + save_subspace.initialization_length;
     }
+  return true;
 }
 
+/* Read in a SOM object and make it into a BFD.  */
+
 static bfd_target *
-hppa_object_p (abfd)
+som_object_p (abfd)
      bfd *abfd;
 {
   struct header file_hdr;
   struct som_exec_auxhdr aux_hdr;
 
   if (bfd_read ((PTR) & file_hdr, 1, FILE_HDR_SIZE, abfd) != FILE_HDR_SIZE)
-    return 0;
+    {
+      bfd_error = system_call_error;
+      return 0;
+    }
 
   if (!_PA_RISC_ID (file_hdr.system_id))
     {
@@ -325,7 +423,7 @@ hppa_object_p (abfd)
 
   switch (file_hdr.a_magic)
     {
-    case RELOC_MAGIC:		/* I'm not really sure about all of these types... */
+    case RELOC_MAGIC:
     case EXEC_MAGIC:
     case SHARE_MAGIC:
     case DEMAND_MAGIC:
@@ -335,6 +433,9 @@ hppa_object_p (abfd)
 #ifdef SHL_MAGIC
     case SHL_MAGIC:
 #endif
+#ifdef EXECLIBMAGIC
+    case EXECLIBMAGIC:
+#endif
       break;
     default:
       bfd_error = wrong_format;
@@ -348,143 +449,414 @@ hppa_object_p (abfd)
       return 0;
     }
 
-  if (bfd_read ((PTR) & aux_hdr, 1, AUX_HDR_SIZE, abfd) != AUX_HDR_SIZE)
-    bfd_error = wrong_format;
+  /* If the aux_header_size field in the file header is zero, then this
+     object is an incomplete executable (a .o file).  Do not try to read
+     a non-existant auxiliary header.  */
+  bzero (&aux_hdr, sizeof (struct som_exec_auxhdr));
+  if (file_hdr.aux_header_size != 0)
+    {
+      if (bfd_read ((PTR) & aux_hdr, 1, AUX_HDR_SIZE, abfd) != AUX_HDR_SIZE)
+	{
+	  bfd_error = wrong_format;
+	  return 0;
+	}
+    }
 
   if (!setup_sections (abfd, &file_hdr))
-    return 0;
+    {
+      /* setup_sections does not bubble up a bfd error code.  */
+      bfd_error = bad_value;
+      return 0;
+    }
 
-  return hppa_object_setup (abfd, &file_hdr, &aux_hdr);
+  /* This appears to be a valid SOM object.  Do some initialization.  */
+  return som_object_setup (abfd, &file_hdr, &aux_hdr);
 }
 
+/* Create a SOM object.  */
+
 static boolean
-hppa_mkobject (abfd)
+som_mkobject (abfd)
      bfd *abfd;
 {
-  fprintf (stderr, "hppa_mkobject unimplemented\n");
-  fflush (stderr);
-  abort ();
-  return (false);
+  /* Allocate memory to hold backend information.  */
+  abfd->tdata.som_data = (struct som_data_struct *)
+    bfd_zalloc (abfd, sizeof (struct som_data_struct));
+  if (abfd->tdata.som_data == NULL)
+    {
+      bfd_error = no_memory;
+      return false;
+    }
+  obj_som_file_hdr (abfd) = bfd_zalloc (abfd, sizeof (struct header));
+  if (obj_som_file_hdr (abfd) == NULL)
+
+    {
+      bfd_error = no_memory;
+      return false;
+    }
+  return true;
 }
 
 boolean
-hppa_write_object_contents(abfd)
+som_write_object_contents (abfd)
      bfd *abfd;
 {
-  fprintf (stderr, "hppa_write_object_contents unimplemented\n");
+  fprintf (stderr, "som_write_object_contents unimplemented\n");
   fflush (stderr);
   abort ();
   return (false);
 }
+/* Read and save the string table associated with the given BFD.  */
 
-static unsigned int
-hppa_get_symtab_upper_bound (abfd)
+static boolean
+som_slurp_string_table (abfd)
      bfd *abfd;
 {
-  fprintf (stderr, "hppa_get_symtab_upper_bound unimplemented\n");
-  fflush (stderr);
-  abort ();
-  return (0);
+  char *stringtab;
+
+  /* Use the saved version if its available.  */
+  if (obj_som_stringtab (abfd) != NULL)
+    return true;
+
+  /* Allocate and read in the string table.  */
+  stringtab = bfd_zalloc (abfd, obj_som_stringtab_size (abfd));
+  if (stringtab == NULL)
+    {
+      bfd_error = no_memory;
+      return false;
+    }
+
+  if (bfd_seek (abfd, obj_som_str_filepos (abfd), SEEK_SET) < 0)
+    {
+      bfd_error = system_call_error;
+      return false;
+    }
+  
+  if (bfd_read (stringtab, obj_som_stringtab_size (abfd), 1, abfd)
+      != obj_som_stringtab_size (abfd))
+    {
+      bfd_error = system_call_error;
+      return false;
+    }
+
+  /* Save our results and return success. */
+  obj_som_stringtab (abfd) = stringtab;
+  return true;
 }
 
+/* Return the amount of data (in bytes) required to hold the symbol
+   table for this object.  */
+
 static unsigned int
-hppa_get_reloc_upper_bound (abfd, asect)
+som_get_symtab_upper_bound (abfd)
      bfd *abfd;
-     sec_ptr asect;
 {
-  fprintf (stderr, "hppa_get_reloc_upper_bound unimplemented\n");
-  fflush (stderr);
-  abort ();
-  return (0);
+  if (!som_slurp_symbol_table (abfd))
+    return 0;
+
+  return (bfd_get_symcount (abfd) + 1) * (sizeof (som_symbol_type *));
 }
 
+/* Convert from a SOM subspace index to a BFD section.  */
+
+static asection *
+som_section_from_subspace_index (abfd, index)
+     bfd *abfd;
+     unsigned int index;
+{
+  asection *section;
+
+  for (section = abfd->sections; section != NULL; section = section->next)
+    if (som_section_data (section)->subspace_index == index)
+      return section;
+
+  /* Should never happen.  */
+  abort();
+}
+
+/* Read and save the symbol table associated with the given BFD.  */
+
 static unsigned int
-hppa_canonicalize_reloc (abfd, section, relptr, symbols)
+som_slurp_symbol_table (abfd)
      bfd *abfd;
-     sec_ptr section;
-     arelent **relptr;
-     asymbol **symbols;
 {
-  fprintf (stderr, "hppa_canonicalize_reloc unimplemented\n");
-  fflush (stderr);
-  abort ();
+  int symbol_count = bfd_get_symcount (abfd);
+  int symsize = sizeof (struct symbol_dictionary_record);
+  char *stringtab;
+  struct symbol_dictionary_record *buf, *bufp, *endbufp;
+  som_symbol_type *sym, *symbase;
+
+  /* Return saved value if it exists.  */
+  if (obj_som_symtab (abfd) != NULL)
+    return true;
+
+  /* Sanity checking.  Make sure there are some symbols and that 
+     we can read the string table too.  */
+  if (symbol_count == 0)
+    {
+      bfd_error = no_symbols;
+      return false;
+    }
+
+  if (!som_slurp_string_table (abfd))
+    return false;
+
+  stringtab = obj_som_stringtab (abfd);
+
+  symbase = (som_symbol_type *)
+    bfd_zalloc (abfd, symbol_count * sizeof (som_symbol_type));
+  if (symbase == NULL)
+    {
+      bfd_error = no_memory;
+      return false;
+    }
+
+  /* Read in the external SOM representation.  */
+  buf = alloca (symbol_count * symsize);
+  if (buf == NULL)
+    {
+      bfd_error = no_memory;
+      return false;
+    }
+  if (bfd_seek (abfd, obj_som_sym_filepos (abfd), SEEK_SET) < 0)
+    {
+      bfd_error = system_call_error;
+      return false;
+    }
+  if (bfd_read (buf, symbol_count * symsize, 1, abfd) 
+      != symbol_count * symsize)
+    {
+      bfd_error = no_symbols;
+      return (false);
+    }
+
+  /* Iterate over all the symbols and internalize them.  */
+  endbufp = buf + symbol_count;
+  for (bufp = buf, sym = symbase; bufp < endbufp; ++bufp)
+    {
+
+      /* I don't think we care about these.  */
+      if (bufp->symbol_type == ST_SYM_EXT
+	  || bufp->symbol_type == ST_ARG_EXT)
+	continue;
+
+      /* Some reasonable defaults.  */
+      sym->symbol.the_bfd = abfd;
+      sym->symbol.name = bufp->name.n_strx + stringtab;
+      sym->symbol.value = bufp->symbol_value;
+      sym->symbol.section = 0;
+      sym->symbol.flags = 0;
+
+      switch (bufp->symbol_type)
+	{
+	case ST_ENTRY:
+	  sym->symbol.flags |= BSF_FUNCTION;
+	  sym->symbol.value &= ~0x3;
+	  break;
+
+	case ST_PRI_PROG:
+	case ST_SEC_PROG:
+	case ST_STUB:
+	case ST_MILLICODE:
+	case ST_CODE:
+	  sym->symbol.value &= ~0x3;
+
+	default:
+	  break;
+	}
+
+      /* Handle scoping and section information.  */
+      switch (bufp->symbol_scope)
+	{
+	/* symbol_info field is undefined for SS_EXTERNAL and SS_UNSAT symbols,
+	   so the section associated with this symbol can't be known.  */
+	case SS_EXTERNAL:
+	case SS_UNSAT:
+	  sym->symbol.flags |= (BSF_EXPORT | BSF_GLOBAL);
+	  break;
+
+	case SS_UNIVERSAL:
+	  sym->symbol.flags |= (BSF_EXPORT | BSF_GLOBAL);
+	  sym->symbol.section
+	    = som_section_from_subspace_index (abfd, bufp->symbol_info);
+	  sym->symbol.value -= sym->symbol.section->vma;
+	  break;
+
+#if 0
+	/* SS_GLOBAL and SS_LOCAL are two names for the same thing.
+	   Sound dumb?  It is.  */
+	case SS_GLOBAL:
+#endif
+	case SS_LOCAL:
+	  sym->symbol.flags |= BSF_LOCAL;
+	  sym->symbol.section
+	    = som_section_from_subspace_index (abfd, bufp->symbol_info);
+	  sym->symbol.value -= sym->symbol.section->vma;
+	  break;
+	}
+
+      /* Mark symbols left around by the debugger.  */
+      if (strlen (sym->symbol.name) >= 3
+	  && sym->symbol.name[0] == 'L'
+	  && (sym->symbol.name[2] == '$' || sym->symbol.name[3] == '$'))
+	sym->symbol.flags |= BSF_DEBUGGING;
+
+      /* Note increment at bottom of loop, since we skip some symbols
+         we can not include it as part of the for statement.  */
+      sym++;
+    }
+
+  /* Save our results and return success.  */
+  obj_som_symtab (abfd) = symbase;
+  return (true);
 }
 
-extern bfd_target hppa_vec;
+/* Canonicalize a SOM symbol table.  Return the number of entries
+   in the symbol table.  */
 
 static unsigned int
-hppa_get_symtab (abfd, location)
+som_get_symtab (abfd, location)
      bfd *abfd;
      asymbol **location;
 {
-  fprintf (stderr, "hppa_get_symtab unimplemented\n");
-  fflush (stderr);
-  abort ();
-  return (0);
+  int i;
+  som_symbol_type *symbase;
+
+  if (!som_slurp_symbol_table (abfd))
+    return 0;
+
+  i = bfd_get_symcount (abfd);
+  symbase = obj_som_symtab (abfd);
+
+  for (; i > 0; i--, location++, symbase++)
+    *location = &symbase->symbol;
+
+  /* Final null pointer.  */
+  *location = 0;
+  return (bfd_get_symcount (abfd));
 }
 
+/* Make a SOM symbol.  There is nothing special to do here.  */
+
 static asymbol *
-hppa_make_empty_symbol (abfd)
+som_make_empty_symbol (abfd)
      bfd *abfd;
 {
-  hppa_symbol_type *new =
-  (hppa_symbol_type *) bfd_zalloc (abfd, sizeof (hppa_symbol_type));
+  som_symbol_type *new =
+  (som_symbol_type *) bfd_zalloc (abfd, sizeof (som_symbol_type));
+  if (new == NULL)
+    {
+      bfd_error = no_memory;
+      return 0;
+    }
   new->symbol.the_bfd = abfd;
 
   return &new->symbol;
 }
 
+/* Print symbol information.  */
+
 static void
-hppa_print_symbol (ignore_abfd, afile, symbol, how)
+som_print_symbol (ignore_abfd, afile, symbol, how)
      bfd *ignore_abfd;
      PTR afile;
      asymbol *symbol;
      bfd_print_symbol_type how;
 {
-  fprintf (stderr, "hppa_print_symbol unimplemented\n");
+  FILE *file = (FILE *) afile;
+  switch (how)
+    {
+    case bfd_print_symbol_name:
+      fprintf (file, "%s", symbol->name);
+      break;
+    case bfd_print_symbol_more:
+      fprintf (file, "som ");
+      fprintf_vma (file, symbol->value);
+      fprintf (file, " %lx", (long) symbol->flags);
+      break;
+    case bfd_print_symbol_all:
+      {
+	CONST char *section_name;
+	section_name = symbol->section ? symbol->section->name : "(*none*)";
+	bfd_print_symbol_vandf ((PTR) file, symbol);
+	fprintf (file, " %s\t%s", section_name, symbol->name);
+	break;
+      }
+    }
+}
+
+static unsigned int
+som_get_reloc_upper_bound (abfd, asect)
+     bfd *abfd;
+     sec_ptr asect;
+{
+  fprintf (stderr, "som_get_reloc_upper_bound unimplemented\n");
   fflush (stderr);
   abort ();
+  return (0);
 }
 
+static unsigned int
+som_canonicalize_reloc (abfd, section, relptr, symbols)
+     bfd *abfd;
+     sec_ptr section;
+     arelent **relptr;
+     asymbol **symbols;
+{
+  fprintf (stderr, "som_canonicalize_reloc unimplemented\n");
+  fflush (stderr);
+  abort ();
+}
+
+extern bfd_target som_vec;
+
+/* A hook to set up object file dependent section information.  */
+
 static boolean
-hppa_new_section_hook (abfd, newsect)
+som_new_section_hook (abfd, newsect)
      bfd *abfd;
      asection *newsect;
 {
+  newsect->used_by_bfd = (struct som_section_data_struct *)
+    bfd_zalloc (abfd, sizeof (struct som_section_data_struct));
   newsect->alignment_power = 3;
 
+  /* Initialize the subspace_index field to -1 so that it does
+     not match a subspace with an index of 0.  */
+  som_section_data (newsect)->subspace_index = -1;
+
   /* We allow more than three sections internally */
   return true;
 }
 
 static boolean
-hppa_set_section_contents (abfd, section, location, offset, count)
+som_set_section_contents (abfd, section, location, offset, count)
      bfd *abfd;
      sec_ptr section;
      PTR location;
      file_ptr offset;
      bfd_size_type count;
 {
-  fprintf (stderr, "hppa_set_section_contents unimplimented\n");
+  fprintf (stderr, "som_set_section_contents unimplimented\n");
   fflush (stderr);
   abort ();
   return false;
 }
 
 static boolean
-hppa_set_arch_mach (abfd, arch, machine)
+som_set_arch_mach (abfd, arch, machine)
      bfd *abfd;
      enum bfd_architecture arch;
      unsigned long machine;
 {
-  fprintf (stderr, "hppa_set_arch_mach unimplemented\n");
+  fprintf (stderr, "som_set_arch_mach unimplemented\n");
   fflush (stderr);
-  /* Allow any architecture to be supported by the hppa backend */
+  /* Allow any architecture to be supported by the som backend */
   return bfd_default_set_arch_mach (abfd, arch, machine);
 }
 
 static boolean
-hppa_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
+som_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
 			functionname_ptr, line_ptr)
      bfd *abfd;
      asection *section;
@@ -494,18 +866,18 @@ hppa_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
      CONST char **functionname_ptr;
      unsigned int *line_ptr;
 {
-  fprintf (stderr, "hppa_find_nearest_line unimplemented\n");
+  fprintf (stderr, "som_find_nearest_line unimplemented\n");
   fflush (stderr);
   abort ();
   return (false);
 }
 
 static int
-hppa_sizeof_headers (abfd, reloc)
+som_sizeof_headers (abfd, reloc)
      bfd *abfd;
      boolean reloc;
 {
-  fprintf (stderr, "hppa_sizeof_headers unimplemented\n");
+  fprintf (stderr, "som_sizeof_headers unimplemented\n");
   fflush (stderr);
   abort ();
   return (0);
@@ -514,7 +886,7 @@ hppa_sizeof_headers (abfd, reloc)
 /* Return information about SOM symbol SYMBOL in RET.  */
 
 static void
-hppa_get_symbol_info (ignore_abfd, symbol, ret)
+som_get_symbol_info (ignore_abfd, symbol, ret)
      bfd *ignore_abfd;		/* Ignored.  */
      asymbol *symbol;
      symbol_info *ret;
@@ -524,78 +896,78 @@ hppa_get_symbol_info (ignore_abfd, symbol, ret)
 
 /* End of miscellaneous support functions. */
 
-#define hppa_bfd_debug_info_start        bfd_void
-#define hppa_bfd_debug_info_end          bfd_void
-#define hppa_bfd_debug_info_accumulate   (PROTO(void,(*),(bfd*, struct sec *))) bfd_void
+#define som_bfd_debug_info_start        bfd_void
+#define som_bfd_debug_info_end          bfd_void
+#define som_bfd_debug_info_accumulate   (PROTO(void,(*),(bfd*, struct sec *))) bfd_void
 
-#define hppa_openr_next_archived_file    bfd_generic_openr_next_archived_file
-#define hppa_generic_stat_arch_elt       bfd_generic_stat_arch_elt
-#define hppa_slurp_armap                  bfd_false
-#define hppa_slurp_extended_name_table    _bfd_slurp_extended_name_table
-#define hppa_truncate_arname              (void (*)())bfd_nullvoidptr
-#define hppa_write_armap                  0
+#define som_openr_next_archived_file    bfd_generic_openr_next_archived_file
+#define som_generic_stat_arch_elt       bfd_generic_stat_arch_elt
+#define som_slurp_armap                  bfd_false
+#define som_slurp_extended_name_table    _bfd_slurp_extended_name_table
+#define som_truncate_arname              (void (*)())bfd_nullvoidptr
+#define som_write_armap                  0
 
-#define hppa_get_lineno                   (struct lineno_cache_entry *(*)())bfd_nullvoidptr
-#define	hppa_close_and_cleanup	           bfd_generic_close_and_cleanup
-#define hppa_get_section_contents          bfd_generic_get_section_contents
+#define som_get_lineno                   (struct lineno_cache_entry *(*)())bfd_nullvoidptr
+#define	som_close_and_cleanup	           bfd_generic_close_and_cleanup
+#define som_get_section_contents          bfd_generic_get_section_contents
 
-#define hppa_bfd_get_relocated_section_contents \
+#define som_bfd_get_relocated_section_contents \
  bfd_generic_get_relocated_section_contents
-#define hppa_bfd_relax_section bfd_generic_relax_section
-#define hppa_bfd_seclet_link bfd_generic_seclet_link
-#define hppa_bfd_reloc_type_lookup \
+#define som_bfd_relax_section bfd_generic_relax_section
+#define som_bfd_seclet_link bfd_generic_seclet_link
+#define som_bfd_reloc_type_lookup \
   ((CONST struct reloc_howto_struct *(*) PARAMS ((bfd *, bfd_reloc_code_real_type))) bfd_nullvoidptr)
-#define hppa_bfd_make_debug_symbol \
+#define som_bfd_make_debug_symbol \
   ((asymbol *(*) PARAMS ((bfd *, void *, unsigned long))) bfd_nullvoidptr)
 
 /* Core file support is in the hpux-core backend.  */
-#define hppa_core_file_failing_command	_bfd_dummy_core_file_failing_command
-#define hppa_core_file_failing_signal	_bfd_dummy_core_file_failing_signal
-#define hppa_core_file_matches_executable_p _bfd_dummy_core_file_matches_executable_p
+#define som_core_file_failing_command	_bfd_dummy_core_file_failing_command
+#define som_core_file_failing_signal	_bfd_dummy_core_file_failing_signal
+#define som_core_file_matches_executable_p	_bfd_dummy_core_file_matches_executable_p
 
-bfd_target hppa_vec =
+bfd_target som_vec =
 {
-  "hppa",			/* name */
-  bfd_target_hppa_flavour,
+  "som",			/* name */
+  bfd_target_som_flavour,
   true,				/* target byte order */
   true,				/* target headers byte order */
   (HAS_RELOC | EXEC_P |		/* object flags */
    HAS_LINENO | HAS_DEBUG |
    HAS_SYMS | HAS_LOCALS | DYNAMIC | WP_TEXT | D_PAGED),
   (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
-   | SEC_ALLOC | SEC_LOAD | SEC_RELOC),	/* section flags */
+   | SEC_ALLOC | SEC_LOAD | SEC_RELOC),		/* section flags */
 
 /* leading_symbol_char: is the first char of a user symbol
-      predictable, and if so what is it */
+   predictable, and if so what is it */
   0,
   ' ',				/* ar_pad_char */
   16,				/* ar_max_namelen */
   3,				/* minimum alignment */
-  _do_getb64, _do_getb_signed_64, _do_putb64,
-  _do_getb32, _do_getb_signed_32, _do_putb32,
-  _do_getb16, _do_getb_signed_16, _do_putb16,	/* data */
-  _do_getb64, _do_getb_signed_64, _do_putb64,
-  _do_getb32, _do_getb_signed_32, _do_putb32,
-  _do_getb16, _do_getb_signed_16, _do_putb16,	/* hdrs */
+  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
+  bfd_getb32, bfd_getb_signed_32, bfd_putb32,
+  bfd_getb16, bfd_getb_signed_16, bfd_putb16,	/* data */
+  bfd_getb64, bfd_getb_signed_64, bfd_putb64,
+  bfd_getb32, bfd_getb_signed_32, bfd_putb32,
+  bfd_getb16, bfd_getb_signed_16, bfd_putb16,	/* hdrs */
   {_bfd_dummy_target,
-   hppa_object_p,		/* bfd_check_format */
+   som_object_p,		/* bfd_check_format */
    bfd_generic_archive_p,
    _bfd_dummy_target
   },
   {
     bfd_false,
-    hppa_mkobject,
+    som_mkobject,
     _bfd_generic_mkarchive,
     bfd_false
   },
   {
     bfd_false,
-    hppa_write_object_contents,
+    som_write_object_contents,
     _bfd_write_archive_contents,
     bfd_false,
   },
-#undef hppa
-  JUMP_TABLE (hppa),
+#undef som
+  JUMP_TABLE (som),
   (PTR) 0
 };