* som.c (som_write_headers): New function.

diff --git a/bfd/ChangeLog b/bfd/ChangeLog
index 8ceb227..7fec4e9 100644 (file)
--- a/bfd/ChangeLog
+++ b/bfd/ChangeLog
@@ -1,12 +1,11 @@
 Fri Nov 12 15:29:36 1993  Jeffrey A. Law  (law@snake.cs.utah.edu)
 
-       * som.c (som_reloc_call): New function.
+       * som.c (som_write_headers): New function.
+       (som_prep_headers): New function.
 
        * som.c (som_sizeof_headers): Add missing prototype.
        (som_set_arch_mach): Do not abort.
 
-       * som.c (som_prep_headers): New function.
-
        * som.c (som_count_spaces): New function.
        (som_count_subspaces): New function.
        (compare_syms): New function.
@@ -18,6 +17,7 @@ Fri Nov 12 15:29:36 1993  Jeffrey A. Law  (law@snake.cs.utah.edu)
        * som.c (try_prev_fixup): New function.
        (som_reloc_skip): New function.
        (som_reloc_addend): New function.
+       (som_reloc_call): New function.
 
        * som.c (som_initialize_reloc_queue): New function.
        (som_reloc_queue_insert): Likewise.

diff --git a/bfd/som.c b/bfd/som.c
index 5348558..03b7ae4 100644 (file)
--- a/bfd/som.c
+++ b/bfd/som.c
@@ -159,6 +159,7 @@ static int compare_syms PARAMS ((asymbol **, asymbol **));
 static unsigned long som_compute_checksum PARAMS ((bfd *));
 static boolean som_prep_headers PARAMS ((bfd *));
 static int som_sizeof_headers PARAMS ((bfd *, boolean));
+static boolean som_write_headers PARAMS ((bfd *));
 
 static reloc_howto_type som_hppa_howto_table[] =
 {
@@ -1440,6 +1441,182 @@ compare_syms (sym1, sym2)
   return 0;
 }
 
+/* Finally, scribble out the various headers to the disk.  */
+
+static boolean
+som_write_headers (abfd)
+     bfd *abfd;
+{
+  int num_spaces = som_count_spaces (abfd);
+  int i;
+  int subspace_index = 0;
+  file_ptr location;
+  asection *section;
+
+  /* Subspaces are written first so that we can set up information
+     about them in their containing spaces as the subspace is written.  */
+
+  /* Seek to the start of the subspace dictionary records.  */
+  location = obj_som_file_hdr (abfd)->subspace_location;
+  bfd_seek (abfd, location, SEEK_SET);
+  section = abfd->sections;
+  /* Now for each loadable space write out records for its subspaces.  */
+  for (i = 0; i < num_spaces; i++)
+    {
+      asection *subsection;
+
+      /* Find a space.  */
+      while (som_section_data (section)->is_space == 0)
+       section = section->next;
+
+      /* Now look for all its subspaces.  */
+      for (subsection = abfd->sections;
+          subsection != NULL;
+          subsection = subsection->next)
+       {
+         
+         /* Skip any section which does not correspond to a space
+            or subspace.  Or does not have SEC_ALLOC set (and therefore
+            has no real bits on the disk).  */
+         if (som_section_data (subsection)->is_subspace == 0
+             || som_section_data (subsection)->containing_space != section
+             || (subsection->flags & SEC_ALLOC) == 0)
+           continue;
+
+         /* If this is the first subspace for this space, then save
+            the index of the subspace in its containing space.  Also
+            set "is_loadable" in the containing space.  */
+
+         if (som_section_data (section)->space_dict.subspace_quantity == 0)
+           {
+             som_section_data (section)->space_dict.is_loadable = 1;
+             som_section_data (section)->space_dict.subspace_index
+               = subspace_index;
+           }
+
+         /* Increment the number of subspaces seen and the number of
+            subspaces contained within the current space.  */
+         subspace_index++;
+         som_section_data (section)->space_dict.subspace_quantity++;
+
+         /* Mark the index of the current space within the subspace's
+            dictionary record.  */
+         som_section_data (subsection)->subspace_dict.space_index = i;
+         
+         /* Dump the current subspace header.  */
+         if (bfd_write ((PTR) &som_section_data (subsection)->subspace_dict,
+                        sizeof (struct subspace_dictionary_record), 1, abfd)
+             != sizeof (struct subspace_dictionary_record))
+           {
+             bfd_error = system_call_error;
+             return false;
+           }
+       }
+      /* Goto the next section.  */
+      section = section->next; 
+    }
+
+  /* Now repeat the process for unloadable subspaces.  */
+  section = abfd->sections;
+  /* Now for each space write out records for its subspaces.  */
+  for (i = 0; i < num_spaces; i++)
+    {
+      asection *subsection;
+
+      /* Find a space.  */
+      while (som_section_data (section)->is_space == 0)
+       section = section->next;
+
+      /* Now look for all its subspaces.  */
+      for (subsection = abfd->sections;
+          subsection != NULL;
+          subsection = subsection->next)
+       {
+         
+         /* Skip any section which does not correspond to a space or
+            subspace, or which SEC_ALLOC set (and therefore handled
+            in the loadable spaces/subspaces code above.  */
+
+         if (som_section_data (subsection)->is_subspace == 0
+             || som_section_data (subsection)->containing_space != section
+             || (subsection->flags & SEC_ALLOC) != 0)
+           continue;
+
+         /* If this is the first subspace for this space, then save
+            the index of the subspace in its containing space.  Clear
+            "is_loadable".  */
+
+         if (som_section_data (section)->space_dict.subspace_quantity == 0)
+           {
+             som_section_data (section)->space_dict.is_loadable = 0;
+             som_section_data (section)->space_dict.subspace_index
+               = subspace_index;
+           }
+
+         /* Increment the number of subspaces seen and the number of
+            subspaces contained within the current space.  */
+         som_section_data (section)->space_dict.subspace_quantity++;
+         subspace_index++; 
+
+         /* Mark the index of the current space within the subspace's
+            dictionary record.  */
+         som_section_data (subsection)->subspace_dict.space_index = i;
+         
+         /* Dump this subspace header.  */
+         if (bfd_write ((PTR) &som_section_data (subsection)->subspace_dict,
+                        sizeof (struct subspace_dictionary_record), 1, abfd)
+             != sizeof (struct subspace_dictionary_record))
+           {
+             bfd_error = system_call_error;
+             return false;
+           }
+       }
+      /* Goto the next section.  */
+      section = section->next; 
+    }
+
+  /* All the subspace dictiondary records are written, and all the
+     fields are set up in the space dictionary records.
+
+     Seek to the right location and start writing the space
+     dictionary records.  */
+  location = obj_som_file_hdr (abfd)->space_location;
+  bfd_seek (abfd, location, SEEK_SET);
+
+  section = abfd->sections;
+  for (i = 0; i < num_spaces; i++)
+    {
+
+      /* Find a space.  */
+      while (som_section_data (section)->is_space == 0)
+       section = section->next;
+
+      /* Dump its header  */
+      if (bfd_write ((PTR) &som_section_data (section)->space_dict,
+                    sizeof (struct space_dictionary_record), 1, abfd)
+         != sizeof (struct space_dictionary_record))
+       {
+         bfd_error = system_call_error;
+         return false;
+       }
+
+      /* Goto the next section.  */
+      section = section->next;
+    }
+
+  /* Only thing left to do is write out the file header.  It is always
+     at location zero.  Seek there and write it.  */
+  bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
+  if (bfd_write ((PTR) obj_som_file_hdr (abfd),
+                sizeof (struct header), 1, abfd)
+      != sizeof (struct header))
+    {
+      bfd_error = system_call_error;
+      return false;
+    }
+  return true;
+}
+
 static unsigned long
 som_compute_checksum (abfd)
      bfd *abfd;