/* Max number of SOMs to be found in an archive. */
#define SOM_LST_MODULE_LIMIT 1024
+/* Generic alignment macro. */
+#define SOM_ALIGN(val, alignment) \
+ (((val) + (alignment) - 1) & ~((alignment) - 1))
+
/* SOM allows any one of the four previous relocations to be reused
with a "R_PREV_FIXUP" relocation entry. Since R_PREV_FIXUP
relocations are always a single byte, using a R_PREV_FIXUP instead
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 long som_get_symtab_upper_bound PARAMS ((bfd *));
+static long som_canonicalize_reloc PARAMS ((bfd *, sec_ptr,
+ arelent **, asymbol **));
+static long som_get_reloc_upper_bound PARAMS ((bfd *, sec_ptr));
static unsigned int som_set_reloc_info PARAMS ((unsigned char *, unsigned int,
arelent *, asection *,
asymbol **, boolean));
static boolean som_slurp_reloc_table PARAMS ((bfd *, asection *,
asymbol **, boolean));
-static unsigned int som_get_symtab PARAMS ((bfd *, asymbol **));
+static long 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_bfd_copy_private_section_data PARAMS ((bfd *, asection *,
bfd *, asection *));
+static boolean som_bfd_copy_private_bfd_data PARAMS ((bfd *, bfd *));
static boolean som_bfd_is_local_label PARAMS ((bfd *, asymbol *));
static boolean som_set_section_contents PARAMS ((bfd *, sec_ptr, PTR,
file_ptr, bfd_size_type));
+static boolean som_get_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 *,
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 asection * bfd_section_from_som_symbol PARAMS ((bfd *,
+ struct symbol_dictionary_record *));
static int log2 PARAMS ((unsigned int));
static bfd_reloc_status_type hppa_som_reloc PARAMS ((bfd *, arelent *,
asymbol *, PTR,
unsigned int,
struct lst_header));
static CONST char *normalize PARAMS ((CONST char *file));
+static boolean som_is_space PARAMS ((asection *));
+static boolean som_is_subspace PARAMS ((asection *));
+static boolean som_is_container PARAMS ((asection *, asection *));
/* Map SOM section names to POSIX/BSD single-character symbol types.
{R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"},
{R_RESERVED, 0, 0, 32, false, 0, 0, hppa_som_reloc, "R_RESERVED"}};
-
/* Initialize the SOM relocation queue. By definition the queue holds
the last four multibyte fixups. */
obj_som_str_filepos (abfd) = file_hdrp->symbol_strings_location;
obj_som_reloc_filepos (abfd) = file_hdrp->fixup_request_location;
+ obj_som_exec_data (abfd) = (struct som_exec_data *)
+ bfd_zalloc (abfd, sizeof (struct som_exec_data ));
+ if (obj_som_exec_data (abfd) == NULL)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ return NULL;
+ }
+
+ obj_som_exec_data (abfd)->system_id = file_hdrp->system_id;
+ obj_som_exec_data (abfd)->exec_flags = aux_hdrp->exec_flags;
return abfd->xvec;
}
space_asect->flags |= SEC_DEBUGGING;
/* Set up all the attributes for the space. */
- bfd_som_set_section_attributes (space_asect, space.is_defined,
- space.is_private, space.sort_key,
- space.space_number);
+ if (bfd_som_set_section_attributes (space_asect, space.is_defined,
+ space.is_private, space.sort_key,
+ space.space_number) == false)
+ goto error_return;
/* Now, read in the first subspace for this space */
if (bfd_seek (abfd, file_hdr->subspace_location
goto error_return;
/* Store private information about the section. */
- bfd_som_set_subsection_attributes (subspace_asect, space_asect,
- subspace.access_control_bits,
- subspace.sort_key,
- subspace.quadrant);
+ if (bfd_som_set_subsection_attributes (subspace_asect, space_asect,
+ subspace.access_control_bits,
+ subspace.sort_key,
+ subspace.quadrant) == false)
+ goto error_return;
/* Keep an easy mapping between subspaces and sections. */
- som_section_data (subspace_asect)->subspace_index
- = total_subspaces++;
+ subspace_asect->target_index = total_subspaces++;
/* Set SEC_READONLY and SEC_CODE/SEC_DATA as specified
by the access_control_bits in the subspace header. */
if (bfd_read ((PTR) & file_hdr, 1, FILE_HDR_SIZE, abfd) != FILE_HDR_SIZE)
{
- bfd_set_error (bfd_error_system_call);
+ if (bfd_get_error () != bfd_error_system_call)
+ bfd_set_error (bfd_error_wrong_format);
return 0;
}
{
if (bfd_read ((PTR) & aux_hdr, 1, AUX_HDR_SIZE, abfd) != AUX_HDR_SIZE)
{
- bfd_set_error (bfd_error_wrong_format);
+ if (bfd_get_error () != bfd_error_system_call)
+ bfd_set_error (bfd_error_wrong_format);
return 0;
}
}
abfd->tdata.som_data = (struct som_data_struct *)
bfd_zalloc (abfd, sizeof (struct som_data_struct));
if (abfd->tdata.som_data == NULL)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
- obj_som_file_hdr (abfd)
- = (struct header *) bfd_zalloc (abfd, sizeof (struct header));
- if (obj_som_file_hdr (abfd) == NULL)
-
{
bfd_set_error (bfd_error_no_memory);
return false;
som_prep_headers (abfd)
bfd *abfd;
{
- struct header *file_hdr = obj_som_file_hdr (abfd);
+ struct header *file_hdr;
asection *section;
+ /* Make and attach a file header to the BFD. */
+ file_hdr = (struct header *) bfd_zalloc (abfd, sizeof (struct header));
+ if (file_hdr == NULL)
+
+ {
+ bfd_set_error (bfd_error_no_memory);
+ return false;
+ }
+ obj_som_file_hdr (abfd) = file_hdr;
+
/* FIXME. This should really be conditional based on whether or not
PA1.1 instructions/registers have been used. */
- file_hdr->system_id = CPU_PA_RISC1_0;
+ if (abfd->flags & EXEC_P)
+ file_hdr->system_id = obj_som_exec_data (abfd)->system_id;
+ else
+ file_hdr->system_id = CPU_PA_RISC1_0;
if (abfd->flags & EXEC_P)
{
file_hdr->file_time.secs = 0;
file_hdr->file_time.nanosecs = 0;
- if (abfd->flags & EXEC_P)
- abort ();
- else
- {
- file_hdr->entry_space = 0;
- file_hdr->entry_subspace = 0;
- file_hdr->entry_offset = 0;
- }
-
+ file_hdr->entry_space = 0;
+ file_hdr->entry_subspace = 0;
+ file_hdr->entry_offset = 0;
file_hdr->presumed_dp = 0;
/* Now iterate over the sections translating information from
{
/* Ignore anything which has not been marked as a space or
subspace. */
- if (som_section_data (section)->is_space == 0
-
- && som_section_data (section)->is_subspace == 0)
+ if (!som_is_space (section) && !som_is_subspace (section))
continue;
-
- if (som_section_data (section)->is_space)
+
+ if (som_is_space (section))
{
+ /* Allocate space for the space dictionary. */
+ som_section_data (section)->space_dict
+ = (struct space_dictionary_record *)
+ bfd_zalloc (abfd, sizeof (struct space_dictionary_record));
+ if (som_section_data (section)->space_dict == NULL)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ return false;
+ }
/* Set space attributes. Note most attributes of SOM spaces
are set based on the subspaces it contains. */
- som_section_data (section)->space_dict.loader_fix_index = -1;
- som_section_data (section)->space_dict.init_pointer_index = -1;
+ som_section_data (section)->space_dict->loader_fix_index = -1;
+ som_section_data (section)->space_dict->init_pointer_index = -1;
+
+ /* Set more attributes that were stuffed away in private data. */
+ som_section_data (section)->space_dict->sort_key =
+ som_section_data (section)->copy_data->sort_key;
+ som_section_data (section)->space_dict->is_defined =
+ som_section_data (section)->copy_data->is_defined;
+ som_section_data (section)->space_dict->is_private =
+ som_section_data (section)->copy_data->is_private;
+ som_section_data (section)->space_dict->space_number =
+ section->target_index;
}
else
{
+ /* Allocate space for the subspace dictionary. */
+ som_section_data (section)->subspace_dict
+ = (struct subspace_dictionary_record *)
+ bfd_zalloc (abfd, sizeof (struct subspace_dictionary_record));
+ if (som_section_data (section)->subspace_dict == NULL)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ return false;
+ }
+
/* Set subspace attributes. Basic stuff is done here, additional
attributes are filled in later as more information becomes
available. */
if (section->flags & SEC_IS_COMMON)
{
- som_section_data (section)->subspace_dict.dup_common = 1;
- som_section_data (section)->subspace_dict.is_common = 1;
+ som_section_data (section)->subspace_dict->dup_common = 1;
+ som_section_data (section)->subspace_dict->is_common = 1;
}
if (section->flags & SEC_ALLOC)
- som_section_data (section)->subspace_dict.is_loadable = 1;
+ som_section_data (section)->subspace_dict->is_loadable = 1;
if (section->flags & SEC_CODE)
- som_section_data (section)->subspace_dict.code_only = 1;
+ som_section_data (section)->subspace_dict->code_only = 1;
- som_section_data (section)->subspace_dict.subspace_start =
+ som_section_data (section)->subspace_dict->subspace_start =
section->vma;
- som_section_data (section)->subspace_dict.subspace_length =
+ som_section_data (section)->subspace_dict->subspace_length =
bfd_section_size (abfd, section);
- som_section_data (section)->subspace_dict.initialization_length =
+ som_section_data (section)->subspace_dict->initialization_length =
bfd_section_size (abfd, section);
- som_section_data (section)->subspace_dict.alignment =
+ som_section_data (section)->subspace_dict->alignment =
1 << section->alignment_power;
+
+ /* Set more attributes that were stuffed away in private data. */
+ som_section_data (section)->subspace_dict->sort_key =
+ som_section_data (section)->copy_data->sort_key;
+ som_section_data (section)->subspace_dict->access_control_bits =
+ som_section_data (section)->copy_data->access_control_bits;
+ som_section_data (section)->subspace_dict->quadrant =
+ som_section_data (section)->copy_data->quadrant;
}
}
return true;
}
+/* Return true if the given section is a SOM space, false otherwise. */
+
+static boolean
+som_is_space (section)
+ asection *section;
+{
+ /* If no copy data is available, then it's neither a space nor a
+ subspace. */
+ if (som_section_data (section)->copy_data == NULL)
+ return false;
+
+ /* If the containing space isn't the same as the given section,
+ then this isn't a space. */
+ if (som_section_data (section)->copy_data->container != section)
+ return false;
+
+ /* OK. Must be a space. */
+ return true;
+}
+
+/* Return true if the given section is a SOM subspace, false otherwise. */
+
+static boolean
+som_is_subspace (section)
+ asection *section;
+{
+ /* If no copy data is available, then it's neither a space nor a
+ subspace. */
+ if (som_section_data (section)->copy_data == NULL)
+ return false;
+
+ /* If the containing space is the same as the given section,
+ then this isn't a subspace. */
+ if (som_section_data (section)->copy_data->container == section)
+ return false;
+
+ /* OK. Must be a subspace. */
+ return true;
+}
+
+/* Return true if the given space containins the given subspace. It
+ is safe to assume space really is a space, and subspace really
+ is a subspace. */
+
+static boolean
+som_is_container (space, subspace)
+ asection *space, *subspace;
+{
+ return som_section_data (subspace)->copy_data->container == space;
+}
+
/* Count and return the number of spaces attached to the given BFD. */
static unsigned long
asection *section;
for (section = abfd->sections; section != NULL; section = section->next)
- count += som_section_data (section)->is_space;
+ count += som_is_space (section);
return count;
}
asection *section;
for (section = abfd->sections; section != NULL; section = section->next)
- count += som_section_data (section)->is_subspace;
+ count += som_is_subspace (section);
return count;
}
asection *subsection;
/* Find a space. */
- while (som_section_data (section)->is_space == 0)
+ while (!som_is_space (section))
section = section->next;
/* Now iterate through each of its subspaces. */
int reloc_offset, current_rounding_mode;
/* Find a subspace of this space. */
- if (som_section_data (subsection)->is_subspace == 0
- || som_section_data (subsection)->containing_space != section)
+ if (!som_is_subspace (subsection)
+ || !som_is_container (section, subsection))
continue;
/* If this subspace had no relocations, then we're finished
with it. */
if (subsection->reloc_count <= 0)
{
- som_section_data (subsection)->subspace_dict.fixup_request_index
+ som_section_data (subsection)->subspace_dict->fixup_request_index
= -1;
continue;
}
/* This subspace has some relocations. Put the relocation stream
index into the subspace record. */
- som_section_data (subsection)->subspace_dict.fixup_request_index
+ som_section_data (subsection)->subspace_dict->fixup_request_index
= total_reloc_size;
/* To make life easier start over with a clean slate for
each subspace. Seek to the start of the relocation stream
for this subspace in preparation for writing out its fixup
stream. */
- if (bfd_seek (abfd, current_offset + total_reloc_size, SEEK_SET) != 0)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ if (bfd_seek (abfd, current_offset + total_reloc_size, SEEK_SET) < 0)
+ return false;
/* Buffer space has already been allocated. Just perform some
initialization here. */
{
if (bfd_write ((PTR) tmp_space, p - tmp_space, 1, abfd)
!= p - tmp_space)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
+
p = tmp_space;
som_initialize_reloc_queue (reloc_queue);
}
/* Scribble out the relocations. */
if (bfd_write ((PTR) tmp_space, p - tmp_space, 1, abfd)
!= p - tmp_space)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
p = tmp_space;
total_reloc_size += subspace_reloc_size;
- som_section_data (subsection)->subspace_dict.fixup_request_quantity
+ som_section_data (subsection)->subspace_dict->fixup_request_quantity
= subspace_reloc_size;
}
section = section->next;
/* Seek to the start of the space strings in preparation for writing
them out. */
- if (bfd_seek (abfd, current_offset, SEEK_SET) != 0)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ if (bfd_seek (abfd, current_offset, SEEK_SET) < 0)
+ return false;
/* Walk through all the spaces and subspaces (order is not important)
building up and writing string table entries for their names. */
/* Only work with space/subspaces; avoid any other sections
which might have been made (.text for example). */
- if (som_section_data (section)->is_space == 0
- && som_section_data (section)->is_subspace == 0)
+ if (!som_is_space (section) && !som_is_subspace (section))
continue;
/* Get the length of the space/subspace name. */
{
if (bfd_write ((PTR) &tmp_space[0], p - tmp_space, 1, abfd)
!= p - tmp_space)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
/* Reset to beginning of the buffer space. */
p = tmp_space;
}
strings_size += 4;
/* Record the index in the space/subspace records. */
- if (som_section_data (section)->is_space)
- som_section_data (section)->space_dict.name.n_strx = strings_size;
+ if (som_is_space (section))
+ som_section_data (section)->space_dict->name.n_strx = strings_size;
else
- som_section_data (section)->subspace_dict.name.n_strx = strings_size;
+ som_section_data (section)->subspace_dict->name.n_strx = strings_size;
/* Next comes the string itself + a null terminator. */
strcpy (p, section->name);
/* Done with the space/subspace strings. Write out any information
contained in a partial block. */
if (bfd_write ((PTR) &tmp_space[0], p - tmp_space, 1, abfd) != p - tmp_space)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
*string_sizep = strings_size;
return true;
}
/* Seek to the start of the space strings in preparation for writing
them out. */
- if (bfd_seek (abfd, current_offset, SEEK_SET) != 0)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ if (bfd_seek (abfd, current_offset, SEEK_SET) < 0)
+ return false;
for (i = 0; i < num_syms; i++)
{
{
if (bfd_write ((PTR) &tmp_space[0], p - tmp_space, 1, abfd)
!= p - tmp_space)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
/* Reset to beginning of the buffer space. */
p = tmp_space;
}
/* Scribble out any partial block. */
if (bfd_write ((PTR) &tmp_space[0], p - tmp_space, 1, abfd) != p - tmp_space)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
*string_sizep = strings_size;
return true;
asection *section;
asymbol **syms = bfd_get_outsymbols (abfd);
unsigned int total_subspaces = 0;
+ struct som_exec_auxhdr exec_header;
/* The file header will always be first in an object file,
everything else can be in random locations. To keep things
if (abfd->flags & EXEC_P)
{
/* Parts of the exec header will be filled in later, so
- delay writing the header itself. Just leave space for
- it. */
- current_offset += sizeof (struct som_exec_auxhdr);
- obj_som_file_hdr (abfd)->aux_header_size += sizeof (struct som_exec_auxhdr);
+ delay writing the header itself. Fill in the defaults,
+ and write it later. */
+ current_offset += sizeof (exec_header);
+ obj_som_file_hdr (abfd)->aux_header_size += sizeof (exec_header);
+ memset (&exec_header, 0, sizeof (exec_header));
+ exec_header.som_auxhdr.type = HPUX_AUX_ID;
+ exec_header.som_auxhdr.length = 40;
}
if (obj_som_version_hdr (abfd) != NULL)
{
unsigned int len;
- bfd_seek (abfd, current_offset, SEEK_SET);
+ if (bfd_seek (abfd, current_offset, SEEK_SET) < 0)
+ return false;
/* Write the aux_id structure and the string length. */
len = sizeof (struct aux_id) + sizeof (unsigned int);
obj_som_file_hdr (abfd)->aux_header_size += len;
current_offset += len;
if (bfd_write ((PTR) obj_som_version_hdr (abfd), len, 1, abfd) != len)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
/* Write the version string. */
len = obj_som_version_hdr (abfd)->header_id.length - sizeof (int);
current_offset += len;
if (bfd_write ((PTR) obj_som_version_hdr (abfd)->user_string,
len, 1, abfd) != len)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
}
if (obj_som_copyright_hdr (abfd) != NULL)
{
unsigned int len;
- bfd_seek (abfd, current_offset, SEEK_SET);
+ if (bfd_seek (abfd, current_offset, SEEK_SET) < 0)
+ return false;
/* Write the aux_id structure and the string length. */
len = sizeof (struct aux_id) + sizeof (unsigned int);
obj_som_file_hdr (abfd)->aux_header_size += len;
current_offset += len;
if (bfd_write ((PTR) obj_som_copyright_hdr (abfd), len, 1, abfd) != len)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
/* Write the copyright string. */
len = obj_som_copyright_hdr (abfd)->header_id.length - sizeof (int);
current_offset += len;
if (bfd_write ((PTR) obj_som_copyright_hdr (abfd)->copyright,
len, 1, abfd) != len)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
}
/* Next comes the initialization pointers; we have no initialization
obj_som_file_hdr (abfd)->compiler_location = current_offset;
obj_som_file_hdr (abfd)->compiler_total = 0;
- /* Now compute the file positions for the loadable subspaces. */
+ /* Now compute the file positions for the loadable subspaces, taking
+ care to make sure everything stays properly aligned. */
section = abfd->sections;
for (i = 0; i < num_spaces; i++)
{
asection *subsection;
+ int first_subspace;
+ unsigned int subspace_offset = 0;
/* Find a space. */
- while (som_section_data (section)->is_space == 0)
+ while (!som_is_space (section))
section = section->next;
+ first_subspace = 1;
/* Now look for all its subspaces. */
for (subsection = abfd->sections;
subsection != NULL;
subsection = subsection->next)
{
-
- if (som_section_data (subsection)->is_subspace == 0
- || som_section_data (subsection)->containing_space != section
+
+ if (!som_is_subspace (subsection)
+ || !som_is_container (section, subsection)
|| (subsection->flags & SEC_ALLOC) == 0)
continue;
- som_section_data (subsection)->subspace_index = total_subspaces++;
+ /* If this is the first subspace in the space, and we are
+ building an executable, then take care to make sure all
+ the alignments are correct and update the exec header. */
+ if (first_subspace
+ && (abfd->flags & EXEC_P))
+ {
+ /* Demand paged executables have each space aligned to a
+ page boundary. Sharable executables (write-protected
+ text) have just the private (aka data & bss) space aligned
+ to a page boundary. Ugh. Not true for HPUX.
+
+ The HPUX kernel requires the text to always be page aligned
+ within the file regardless of the executable's type. */
+ if (abfd->flags & D_PAGED
+ || (subsection->flags & SEC_CODE)
+ || ((abfd->flags & WP_TEXT)
+ && (subsection->flags & SEC_DATA)))
+ current_offset = SOM_ALIGN (current_offset, PA_PAGESIZE);
+
+ /* Update the exec header. */
+ if (subsection->flags & SEC_CODE && exec_header.exec_tfile == 0)
+ {
+ exec_header.exec_tmem = section->vma;
+ exec_header.exec_tfile = current_offset;
+ }
+ if (subsection->flags & SEC_DATA && exec_header.exec_dfile == 0)
+ {
+ exec_header.exec_dmem = section->vma;
+ exec_header.exec_dfile = current_offset;
+ }
+
+ /* Keep track of exactly where we are within a particular
+ space. This is necessary as the braindamaged HPUX
+ loader will create holes between subspaces *and*
+ subspace alignments are *NOT* preserved. What a crock. */
+ subspace_offset = subsection->vma;
+
+ /* Only do this for the first subspace within each space. */
+ first_subspace = 0;
+ }
+ else if (abfd->flags & EXEC_P)
+ {
+ /* The braindamaged HPUX loader may have created a hole
+ between two subspaces. It is *not* sufficient to use
+ the alignment specifications within the subspaces to
+ account for these holes -- I've run into at least one
+ case where the loader left one code subspace unaligned
+ in a final executable.
+
+ To combat this we keep a current offset within each space,
+ and use the subspace vma fields to detect and preserve
+ holes. What a crock!
+
+ ps. This is not necessary for unloadable space/subspaces. */
+ current_offset += subsection->vma - subspace_offset;
+ if (subsection->flags & SEC_CODE)
+ exec_header.exec_tsize += subsection->vma - subspace_offset;
+ else
+ exec_header.exec_dsize += subsection->vma - subspace_offset;
+ subspace_offset += subsection->vma - subspace_offset;
+ }
+
+
+ subsection->target_index = total_subspaces++;
/* This is real data to be loaded from the file. */
if (subsection->flags & SEC_LOAD)
{
- som_section_data (subsection)->subspace_dict.file_loc_init_value
+ /* Update the size of the code & data. */
+ if (abfd->flags & EXEC_P
+ && subsection->flags & SEC_CODE)
+ exec_header.exec_tsize += subsection->_cooked_size;
+ else if (abfd->flags & EXEC_P
+ && subsection->flags & SEC_DATA)
+ exec_header.exec_dsize += subsection->_cooked_size;
+ som_section_data (subsection)->subspace_dict->file_loc_init_value
= current_offset;
- section->filepos = current_offset;
+ subsection->filepos = current_offset;
current_offset += bfd_section_size (abfd, subsection);
+ subspace_offset += bfd_section_size (abfd, subsection);
}
/* Looks like uninitialized data. */
else
{
- som_section_data (subsection)->subspace_dict.file_loc_init_value
+ /* Update the size of the bss section. */
+ if (abfd->flags & EXEC_P)
+ exec_header.exec_bsize += subsection->_cooked_size;
+
+ som_section_data (subsection)->subspace_dict->file_loc_init_value
= 0;
- som_section_data (subsection)->subspace_dict.
+ som_section_data (subsection)->subspace_dict->
initialization_length = 0;
}
}
section = section->next;
}
- /* Finally compute the file positions for unloadable subspaces. */
+ /* Finally compute the file positions for unloadable subspaces.
+ If building an executable, start the unloadable stuff on its
+ own page. */
+
+ if (abfd->flags & EXEC_P)
+ current_offset = SOM_ALIGN (current_offset, PA_PAGESIZE);
obj_som_file_hdr (abfd)->unloadable_sp_location = current_offset;
section = abfd->sections;
asection *subsection;
/* Find a space. */
- while (som_section_data (section)->is_space == 0)
+ while (!som_is_space (section))
section = section->next;
+ if (abfd->flags & EXEC_P)
+ current_offset = SOM_ALIGN (current_offset, PA_PAGESIZE);
+
/* Now look for all its subspaces. */
for (subsection = abfd->sections;
subsection != NULL;
subsection = subsection->next)
{
- if (som_section_data (subsection)->is_subspace == 0
- || som_section_data (subsection)->containing_space != section
+ if (!som_is_subspace (subsection)
+ || !som_is_container (section, subsection)
|| (subsection->flags & SEC_ALLOC) != 0)
continue;
- som_section_data (subsection)->subspace_index = total_subspaces++;
+ subsection->target_index = total_subspaces;
/* This is real data to be loaded from the file. */
if ((subsection->flags & SEC_LOAD) == 0)
{
- som_section_data (subsection)->subspace_dict.file_loc_init_value
+ som_section_data (subsection)->subspace_dict->file_loc_init_value
= current_offset;
- section->filepos = current_offset;
+ subsection->filepos = current_offset;
current_offset += bfd_section_size (abfd, subsection);
}
/* Looks like uninitialized data. */
else
{
- som_section_data (subsection)->subspace_dict.file_loc_init_value
+ som_section_data (subsection)->subspace_dict->file_loc_init_value
= 0;
- som_section_data (subsection)->subspace_dict.
+ som_section_data (subsection)->subspace_dict->
initialization_length = bfd_section_size (abfd, subsection);
}
}
section = section->next;
}
+ /* If building an executable, then make sure to seek to and write
+ one byte at the end of the file to make sure any necessary
+ zeros are filled in. Ugh. */
+ if (abfd->flags & EXEC_P)
+ current_offset = SOM_ALIGN (current_offset, PA_PAGESIZE);
+ if (bfd_seek (abfd, current_offset - 1, SEEK_SET) < 0)
+ return false;
+ if (bfd_write ((PTR) "", 1, 1, abfd) != 1)
+ return false;
+
obj_som_file_hdr (abfd)->unloadable_sp_size
= current_offset - obj_som_file_hdr (abfd)->unloadable_sp_location;
/* Done. Store the total size of the SOM. */
obj_som_file_hdr (abfd)->som_length = current_offset;
+
+ /* Now write the exec header. */
+ if (abfd->flags & EXEC_P)
+ {
+ long tmp;
+
+ exec_header.exec_entry = bfd_get_start_address (abfd);
+ exec_header.exec_flags = obj_som_exec_data (abfd)->exec_flags;
+
+ /* Oh joys. Ram some of the BSS data into the DATA section
+ to be compatable with how the hp linker makes objects
+ (saves memory space). */
+ tmp = exec_header.exec_dsize;
+ tmp = SOM_ALIGN (tmp, PA_PAGESIZE);
+ exec_header.exec_bsize -= (tmp - exec_header.exec_dsize);
+ if (exec_header.exec_bsize < 0)
+ exec_header.exec_bsize = 0;
+ exec_header.exec_dsize = tmp;
+
+ if (bfd_seek (abfd, obj_som_file_hdr (abfd)->aux_header_location,
+ SEEK_SET) < 0)
+ return false;
+
+ if (bfd_write ((PTR) &exec_header, AUX_HDR_SIZE, 1, abfd)
+ != AUX_HDR_SIZE)
+ return false;
+ }
return true;
}
/* Seek to the start of the subspace dictionary records. */
location = obj_som_file_hdr (abfd)->subspace_location;
- bfd_seek (abfd, location, SEEK_SET);
+ if (bfd_seek (abfd, location, SEEK_SET) < 0)
+ return false;
+
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)
+ while (!som_is_space (section))
section = section->next;
/* Now look for all its subspaces. */
/* 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
+ if (!som_is_subspace (subsection)
+ || !som_is_container (section, subsection)
|| (subsection->flags & SEC_ALLOC) == 0)
continue;
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)
+ 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
+ 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++;
+ 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;
+ som_section_data (subsection)->subspace_dict->space_index = i;
/* Dump the current subspace header. */
- if (bfd_write ((PTR) &som_section_data (subsection)->subspace_dict,
+ if (bfd_write ((PTR) som_section_data (subsection)->subspace_dict,
sizeof (struct subspace_dictionary_record), 1, abfd)
!= sizeof (struct subspace_dictionary_record))
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
}
/* Goto the next section. */
section = section->next;
asection *subsection;
/* Find a space. */
- while (som_section_data (section)->is_space == 0)
+ while (!som_is_space (section))
section = section->next;
/* Now look for all its subspaces. */
/* 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. */
+ in the loadable spaces/subspaces code above). */
- if (som_section_data (subsection)->is_subspace == 0
- || som_section_data (subsection)->containing_space != section
+ if (!som_is_subspace (subsection)
+ || !som_is_container (section, subsection)
|| (subsection->flags & SEC_ALLOC) != 0)
continue;
the index of the subspace in its containing space. Clear
"is_loadable". */
- if (som_section_data (section)->space_dict.subspace_quantity == 0)
+ 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
+ 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++;
+ 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;
+ som_section_data (subsection)->subspace_dict->space_index = i;
/* Dump this subspace header. */
- if (bfd_write ((PTR) &som_section_data (subsection)->subspace_dict,
+ if (bfd_write ((PTR) som_section_data (subsection)->subspace_dict,
sizeof (struct subspace_dictionary_record), 1, abfd)
!= sizeof (struct subspace_dictionary_record))
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
}
/* Goto the next section. */
section = section->next;
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);
+ if (bfd_seek (abfd, location, SEEK_SET) < 0)
+ return false;
section = abfd->sections;
for (i = 0; i < num_spaces; i++)
{
/* Find a space. */
- while (som_section_data (section)->is_space == 0)
+ while (!som_is_space (section))
section = section->next;
/* Dump its header */
- if (bfd_write ((PTR) &som_section_data (section)->space_dict,
+ if (bfd_write ((PTR) som_section_data (section)->space_dict,
sizeof (struct space_dictionary_record), 1, abfd)
!= sizeof (struct space_dictionary_record))
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ 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_seek (abfd, (file_ptr) 0, SEEK_SET) < 0)
+ return false;
if (bfd_write ((PTR) obj_som_file_hdr (abfd),
sizeof (struct header), 1, abfd)
!= sizeof (struct header))
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
return true;
}
/* For all other symbols, the symbol_info field contains the
subspace index of the space this symbol is contained in. */
else
- info->symbol_info = som_section_data (sym->section)->subspace_index;
+ info->symbol_info = sym->section->target_index;
/* Set the symbol's value. */
info->symbol_value = sym->value + sym->section->vma;
/* Everything is ready, seek to the right location and
scribble out the symbol table. */
if (bfd_seek (abfd, symtab_location, SEEK_SET) != 0)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ return false;
if (bfd_write ((PTR) som_symtab, symtab_size, 1, abfd) != symtab_size)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
if (som_symtab != NULL)
free (som_symtab);
if (obj_som_stringtab (abfd) != NULL)
return true;
+ /* I don't think this can currently happen, and I'm not sure it should
+ really be an error, but it's better than getting unpredictable results
+ from the host's malloc when passed a size of zero. */
+ if (obj_som_stringtab_size (abfd) == 0)
+ {
+ bfd_set_error (bfd_error_no_symbols);
+ return false;
+ }
+
/* Allocate and read in the string table. */
- stringtab = bfd_zalloc (abfd, obj_som_stringtab_size (abfd));
+ stringtab = malloc (obj_som_stringtab_size (abfd));
if (stringtab == NULL)
{
bfd_set_error (bfd_error_no_memory);
}
if (bfd_seek (abfd, obj_som_str_filepos (abfd), SEEK_SET) < 0)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
if (bfd_read (stringtab, obj_som_stringtab_size (abfd), 1, abfd)
!= obj_som_stringtab_size (abfd))
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
/* Save our results and return success. */
obj_som_stringtab (abfd) = stringtab;
/* Return the amount of data (in bytes) required to hold the symbol
table for this object. */
-static unsigned int
+static long
som_get_symtab_upper_bound (abfd)
bfd *abfd;
{
if (!som_slurp_symbol_table (abfd))
- return 0;
+ return -1;
return (bfd_get_symcount (abfd) + 1) * (sizeof (asymbol *));
}
/* Convert from a SOM subspace index to a BFD section. */
static asection *
-som_section_from_subspace_index (abfd, index)
+bfd_section_from_som_symbol (abfd, symbol)
bfd *abfd;
- unsigned int index;
+ struct symbol_dictionary_record *symbol;
{
asection *section;
- for (section = abfd->sections; section != NULL; section = section->next)
- if (som_section_data (section)->subspace_index == index)
- return section;
+ /* The meaning of the symbol_info field changes for functions
+ within executables. So only use the quick symbol_info mapping for
+ incomplete objects and non-function symbols in executables. */
+ if ((abfd->flags & EXEC_P) == 0
+ || (symbol->symbol_type != ST_ENTRY
+ && symbol->symbol_type != ST_PRI_PROG
+ && symbol->symbol_type != ST_SEC_PROG
+ && symbol->symbol_type != ST_MILLICODE))
+ {
+ unsigned int index = symbol->symbol_info;
+ for (section = abfd->sections; section != NULL; section = section->next)
+ if (section->target_index == index)
+ return section;
- /* Should never happen. */
- abort();
+ /* Should never happen. */
+ abort();
+ }
+ else
+ {
+ unsigned int value = symbol->symbol_value;
+ unsigned int found = 0;
+
+ /* For executables we will have to use the symbol's address and
+ find out what section would contain that address. Yuk. */
+ for (section = abfd->sections; section; section = section->next)
+ {
+ if (value >= section->vma
+ && value <= section->vma + section->_cooked_size)
+ return section;
+ }
+
+ /* Should never happen. */
+ abort ();
+ }
}
/* Read and save the symbol table associated with the given BFD. */
stringtab = obj_som_stringtab (abfd);
symbase = (som_symbol_type *)
- bfd_zalloc (abfd, symbol_count * sizeof (som_symbol_type));
+ malloc (symbol_count * sizeof (som_symbol_type));
if (symbase == NULL)
{
bfd_set_error (bfd_error_no_memory);
goto error_return;
}
if (bfd_seek (abfd, obj_som_sym_filepos (abfd), SEEK_SET) < 0)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
if (bfd_read (buf, symbol_count * symsize, 1, abfd)
!= symbol_count * symsize)
- {
- bfd_set_error (bfd_error_no_symbols);
- goto error_return;
- }
+ goto error_return;
/* Iterate over all the symbols and internalize them. */
endbufp = buf + symbol_count;
case SS_UNIVERSAL:
sym->symbol.flags |= (BSF_EXPORT | BSF_GLOBAL);
- sym->symbol.section
- = som_section_from_subspace_index (abfd, bufp->symbol_info);
+ sym->symbol.section = bfd_section_from_som_symbol (abfd, bufp);
sym->symbol.value -= sym->symbol.section->vma;
break;
#endif
case SS_LOCAL:
sym->symbol.flags |= BSF_LOCAL;
- sym->symbol.section
- = som_section_from_subspace_index (abfd, bufp->symbol_info);
+ sym->symbol.section = bfd_section_from_som_symbol (abfd, bufp);
sym->symbol.value -= sym->symbol.section->vma;
break;
}
/* Canonicalize a SOM symbol table. Return the number of entries
in the symbol table. */
-static unsigned int
+static long
som_get_symtab (abfd, location)
bfd *abfd;
asymbol **location;
som_symbol_type *symbase;
if (!som_slurp_symbol_table (abfd))
- return 0;
+ return -1;
i = bfd_get_symcount (abfd);
symbase = obj_som_symtab (abfd);
parsed. We must do so now to know how many relocations exist. */
if (section->reloc_count == -1)
{
- external_relocs = (char *) bfd_zalloc (abfd, fixup_stream_size);
+ external_relocs = (char *) malloc (fixup_stream_size);
if (external_relocs == (char *) NULL)
{
bfd_set_error (bfd_error_no_memory);
obj_som_reloc_filepos (abfd) + section->rel_filepos,
SEEK_SET)
!= 0)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
if (bfd_read (external_relocs, 1, fixup_stream_size, abfd)
!= fixup_stream_size)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
+
/* Let callers know how many relocations found.
also save the relocation stream as we will
need it again. */
if (section->relocation != (arelent *) NULL)
return true;
- internal_relocs = (arelent *) bfd_zalloc (abfd,
- num_relocs * sizeof (arelent));
+ internal_relocs = (arelent *) malloc (num_relocs * sizeof (arelent));
if (internal_relocs == (arelent *) NULL)
{
bfd_set_error (bfd_error_no_memory);
/* Return the number of bytes required to store the relocation
information associated with the given section. */
-static unsigned int
+static long
som_get_reloc_upper_bound (abfd, asect)
bfd *abfd;
sec_ptr asect;
and parse it to determine how many relocations exist. */
if (asect->flags & SEC_RELOC)
{
- if (som_slurp_reloc_table (abfd, asect, NULL, true))
- return (asect->reloc_count + 1) * sizeof (arelent);
+ if (! som_slurp_reloc_table (abfd, asect, NULL, true))
+ return false;
+ return (asect->reloc_count + 1) * sizeof (arelent);
}
- /* Either there are no relocations or an error occurred while
- reading and parsing the relocation stream. */
+ /* There are no relocations. */
return 0;
}
/* Convert relocations from SOM (external) form into BFD internal
form. Return the number of relocations. */
-static unsigned int
+static long
som_canonicalize_reloc (abfd, section, relptr, symbols)
bfd *abfd;
sec_ptr section;
int count;
if (som_slurp_reloc_table (abfd, section, symbols, false) == false)
- return 0;
+ return -1;
count = section->reloc_count;
tblptr = section->relocation;
- if (tblptr == (arelent *) NULL)
- return 0;
while (count--)
*relptr++ = tblptr++;
}
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;
}
{
/* One day we may try to grok other private data. */
if (ibfd->xvec->flavour != bfd_target_som_flavour
- || obfd->xvec->flavour != bfd_target_som_flavour)
+ || obfd->xvec->flavour != bfd_target_som_flavour
+ || (!som_is_space (isection) && !som_is_subspace (isection)))
return false;
- memcpy (som_section_data (osection), som_section_data (isection),
- sizeof (struct som_section_data_struct));
+ som_section_data (osection)->copy_data
+ = (struct som_copyable_section_data_struct *)
+ bfd_zalloc (obfd, sizeof (struct som_copyable_section_data_struct));
+ if (som_section_data (osection)->copy_data == NULL)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ return false;
+ }
+
+ memcpy (som_section_data (osection)->copy_data,
+ som_section_data (isection)->copy_data,
+ sizeof (struct som_copyable_section_data_struct));
/* Reparent if necessary. */
- if (som_section_data (osection)->containing_space)
- som_section_data (osection)->containing_space =
- som_section_data (osection)->containing_space->output_section;
+ if (som_section_data (osection)->copy_data->container)
+ som_section_data (osection)->copy_data->container =
+ som_section_data (osection)->copy_data->container->output_section;
+
+ return true;
+}
+
+/* Copy any private info we understand from the input bfd
+ to the output bfd. */
+
+static boolean
+som_bfd_copy_private_bfd_data (ibfd, obfd)
+ bfd *ibfd, *obfd;
+{
+ /* One day we may try to grok other private data. */
+ if (ibfd->xvec->flavour != bfd_target_som_flavour
+ || obfd->xvec->flavour != bfd_target_som_flavour)
+ return false;
+
+ /* Allocate some memory to hold the data we need. */
+ obj_som_exec_data (obfd) = (struct som_exec_data *)
+ bfd_zalloc (obfd, sizeof (struct som_exec_data));
+ if (obj_som_exec_data (obfd) == NULL)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ return false;
+ }
+
+ /* Now copy the data. */
+ memcpy (obj_som_exec_data (obfd), obj_som_exec_data (ibfd),
+ sizeof (struct som_exec_data));
+
+ return true;
}
-
+
/* Set backend info for sections which can not be described
in the BFD data structures. */
-void
+boolean
bfd_som_set_section_attributes (section, defined, private, sort_key, spnum)
asection *section;
int defined;
unsigned int sort_key;
int spnum;
{
- struct space_dictionary_record *space_dict;
-
- som_section_data (section)->is_space = 1;
- space_dict = &som_section_data (section)->space_dict;
- space_dict->is_defined = defined;
- space_dict->is_private = private;
- space_dict->sort_key = sort_key;
- space_dict->space_number = spnum;
+ /* Allocate memory to hold the magic information. */
+ if (som_section_data (section)->copy_data == NULL)
+ {
+ som_section_data (section)->copy_data
+ = (struct som_copyable_section_data_struct *)
+ bfd_zalloc (section->owner,
+ sizeof (struct som_copyable_section_data_struct));
+ if (som_section_data (section)->copy_data == NULL)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ return false;
+ }
+ }
+ som_section_data (section)->copy_data->sort_key = sort_key;
+ som_section_data (section)->copy_data->is_defined = defined;
+ som_section_data (section)->copy_data->is_private = private;
+ som_section_data (section)->copy_data->container = section;
+ section->target_index = spnum;
+ return true;
}
/* Set backend info for subsections which can not be described
in the BFD data structures. */
-void
+boolean
bfd_som_set_subsection_attributes (section, container, access,
sort_key, quadrant)
asection *section;
unsigned int sort_key;
int quadrant;
{
- struct subspace_dictionary_record *subspace_dict;
- som_section_data (section)->is_subspace = 1;
- subspace_dict = &som_section_data (section)->subspace_dict;
- subspace_dict->access_control_bits = access;
- subspace_dict->sort_key = sort_key;
- subspace_dict->quadrant = quadrant;
- som_section_data (section)->containing_space = container;
+ /* Allocate memory to hold the magic information. */
+ if (som_section_data (section)->copy_data == NULL)
+ {
+ som_section_data (section)->copy_data
+ = (struct som_copyable_section_data_struct *)
+ bfd_zalloc (section->owner,
+ sizeof (struct som_copyable_section_data_struct));
+ if (som_section_data (section)->copy_data == NULL)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ return false;
+ }
+ }
+ som_section_data (section)->copy_data->sort_key = sort_key;
+ som_section_data (section)->copy_data->access_control_bits = access;
+ som_section_data (section)->copy_data->quadrant = quadrant;
+ som_section_data (section)->copy_data->container = container;
+ return true;
}
/* Set the full SOM symbol type. SOM needs far more symbol information
+ sizeof (unsigned int) + len + pad);
if (!obj_som_copyright_hdr (abfd))
{
- bfd_set_error (bfd_error_no_error);
+ bfd_set_error (bfd_error_no_memory);
return false;
}
obj_som_copyright_hdr (abfd)->header_id.type = COPYRIGHT_AUX_ID;
return true;
}
+static boolean
+som_get_section_contents (abfd, section, location, offset, count)
+ bfd *abfd;
+ sec_ptr section;
+ PTR location;
+ file_ptr offset;
+ bfd_size_type count;
+{
+ if (count == 0 || ((section->flags & (SEC_LOAD | SEC_DEBUGGING)) == 0))
+ return true;
+ if ((bfd_size_type)(offset+count) > section->_raw_size
+ || bfd_seek (abfd, (file_ptr)(section->filepos + offset), SEEK_SET) == -1
+ || bfd_read (location, (bfd_size_type)1, count, abfd) != count)
+ return (false); /* on error */
+ return (true);
+}
+
static boolean
som_set_section_contents (abfd, section, location, offset, count)
bfd *abfd;
/* Only write subspaces which have "real" contents (eg. the contents
are not generated at run time by the OS). */
- if (som_section_data (section)->is_subspace != 1
+ if (!som_is_subspace (section)
|| ((section->flags & (SEC_LOAD | SEC_DEBUGGING)) == 0))
return true;
/* Seek to the proper offset within the object file and write the
data. */
- offset += som_section_data (section)->subspace_dict.file_loc_init_value;
+ offset += som_section_data (section)->subspace_dict->file_loc_init_value;
if (bfd_seek (abfd, offset, SEEK_SET) == -1)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
if (bfd_write ((PTR) location, 1, count, abfd) != count)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
return true;
}
which point to the hash chains. */
if (bfd_read ((PTR) hash_table, lst_header->hash_size, 4, abfd)
!= lst_header->hash_size * 4)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
/* Walk each chain counting the number of symbols found on that particular
chain. */
/* Seek to the first symbol in this hash chain. */
if (bfd_seek (abfd, lst_filepos + hash_table[i], SEEK_SET) < 0)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
/* Read in this symbol and update the counter. */
if (bfd_read ((PTR) & lst_symbol, 1, sizeof (lst_symbol), abfd)
!= sizeof (lst_symbol))
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
+
(*count)++;
/* Now iterate through the rest of the symbols on this chain. */
/* Seek to the next symbol. */
if (bfd_seek (abfd, lst_filepos + lst_symbol.next_entry, SEEK_SET)
< 0)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
/* Read the symbol in and update the counter. */
if (bfd_read ((PTR) & lst_symbol, 1, sizeof (lst_symbol), abfd)
!= sizeof (lst_symbol))
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
+
(*count)++;
}
}
which point to the hash chains. */
if (bfd_read ((PTR) hash_table, lst_header->hash_size, 4, abfd)
!= lst_header->hash_size * 4)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
/* Seek to and read in the SOM dictionary. We will need this to fill
in the carsym's filepos field. */
if (bfd_seek (abfd, lst_filepos + lst_header->dir_loc, SEEK_SET) < 0)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
if (bfd_read ((PTR) som_dict, lst_header->module_count,
sizeof (struct som_entry), abfd)
!= lst_header->module_count * sizeof (struct som_entry))
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
/* Walk each chain filling in the carsyms as we go along. */
for (i = 0; i < lst_header->hash_size; i++)
/* Seek to and read the first symbol on the chain. */
if (bfd_seek (abfd, lst_filepos + hash_table[i], SEEK_SET) < 0)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
if (bfd_read ((PTR) & lst_symbol, 1, sizeof (lst_symbol), abfd)
!= sizeof (lst_symbol))
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
/* Get the name of the symbol, first get the length which is stored
as a 32bit integer just before the symbol.
using the string table would not be safe. */
if (bfd_seek (abfd, lst_filepos + lst_header->string_loc
+ lst_symbol.name.n_strx - 4, SEEK_SET) < 0)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
if (bfd_read (&len, 1, 4, abfd) != 4)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
/* Allocate space for the name and null terminate it too. */
set->name = bfd_zalloc (abfd, len + 1);
goto error_return;
}
if (bfd_read (set->name, 1, len, abfd) != len)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
+
set->name[len] = 0;
/* Fill in the file offset. Note that the "location" field points
while (lst_symbol.next_entry)
{
/* Seek to the next symbol and read it in. */
- if (bfd_seek (abfd, lst_filepos + lst_symbol.next_entry, SEEK_SET)
- < 0)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ if (bfd_seek (abfd, lst_filepos + lst_symbol.next_entry, SEEK_SET) <0)
+ goto error_return;
if (bfd_read ((PTR) & lst_symbol, 1, sizeof (lst_symbol), abfd)
!= sizeof (lst_symbol))
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
/* Seek to the name length & string and read them in. */
if (bfd_seek (abfd, lst_filepos + lst_header->string_loc
+ lst_symbol.name.n_strx - 4, SEEK_SET) < 0)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
if (bfd_read (&len, 1, 4, abfd) != 4)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
/* Allocate space for the name and null terminate it too. */
set->name = bfd_zalloc (abfd, len + 1);
bfd_set_error (bfd_error_no_memory);
goto error_return;
}
+
if (bfd_read (set->name, 1, len, abfd) != len)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
set->name[len] = 0;
/* Fill in the file offset. Note that the "location" field points
return false;
if (bfd_seek (abfd, (file_ptr) - 16, SEEK_CUR) < 0)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
/* For archives without .o files there is no symbol table. */
if (strncmp (nextname, "/ ", 16))
/* Read in and sanity check the archive header. */
if (bfd_read ((PTR) &ar_header, 1, sizeof (struct ar_hdr), abfd)
!= sizeof (struct ar_hdr))
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
if (strncmp (ar_header.ar_fmag, ARFMAG, 2))
{
in just a minute. */
if (bfd_read ((PTR) & lst_header, 1, sizeof (struct lst_header), abfd)
!= sizeof (struct lst_header))
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
/* Sanity check. */
if (lst_header.a_magic != LIBMAGIC)
/* Get back to the start of the library symbol table. */
if (bfd_seek (abfd, ardata->first_file_filepos - parsed_size
+ sizeof (struct lst_header), SEEK_SET) < 0)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
/* Initializae the cache and allocate space for the library symbols. */
ardata->cache = 0;
/* Seek back to the "first" file in the archive. Note the "first"
file may be the extended name table. */
if (bfd_seek (abfd, ardata->first_file_filepos, SEEK_SET) < 0)
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
/* Notify the generic archive code that we have a symbol map. */
bfd_has_map (abfd) = true;
unsigned int curr_count, i;
som_symbol_type *sym;
+ /* Don't bother for non-SOM objects. */
+ if (curr_bfd->format != bfd_object
+ || curr_bfd->xvec->flavour != bfd_target_som_flavour)
+ {
+ curr_bfd = curr_bfd->next;
+ continue;
+ }
+
/* Make sure the symbol table has been read, then snag a pointer
to it. It's a little slimey to grab the symbols via obj_som_symtab,
but doing so avoids allocating lots of extra memory. */
unsigned int curr_count, i;
som_symbol_type *sym;
+ /* Don't bother for non-SOM objects. */
+ if (curr_bfd->format != bfd_object
+ || curr_bfd->xvec->flavour != bfd_target_som_flavour)
+ {
+ curr_bfd = curr_bfd->next;
+ continue;
+ }
+
/* Make sure the symbol table has been read, then snag a pointer
to it. It's a little slimey to grab the symbols via obj_som_symtab,
but doing so avoids allocating lots of extra memory. */
/* Now scribble out the hash table. */
if (bfd_write ((PTR) hash_table, lst.hash_size, 4, abfd)
!= lst.hash_size * 4)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
/* Then the SOM dictionary. */
if (bfd_write ((PTR) som_dict, lst.module_count,
sizeof (struct som_entry), abfd)
!= lst.module_count * sizeof (struct som_entry))
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
/* The library symbols. */
if (bfd_write ((PTR) lst_syms, nsyms, sizeof (struct lst_symbol_record), abfd)
!= nsyms * sizeof (struct lst_symbol_record))
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
/* And finally the strings. */
if (bfd_write ((PTR) strings, string_size, 1, abfd) != string_size)
- {
- bfd_set_error (bfd_error_system_call);
- goto error_return;
- }
+ goto error_return;
if (hash_table != NULL)
free (hash_table);
lst.module_count = 0;
while (curr_bfd != NULL)
{
- lst.module_count++;
+ /* Only true SOM objects count. */
+ if (curr_bfd->format == bfd_object
+ && curr_bfd->xvec->flavour == bfd_target_som_flavour)
+ lst.module_count++;
curr_bfd = curr_bfd->next;
}
lst.module_limit = lst.module_count;
/* Scribble out the ar header. */
if (bfd_write ((PTR) &hdr, 1, sizeof (struct ar_hdr), abfd)
!= sizeof (struct ar_hdr))
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
/* Now scribble out the lst header. */
if (bfd_write ((PTR) &lst, 1, sizeof (struct lst_header), abfd)
!= sizeof (struct lst_header))
- {
- bfd_set_error (bfd_error_system_call);
- return false;
- }
+ return false;
/* Build and write the armap. */
if (som_bfd_ar_write_symbol_stuff (abfd, nsyms, stringsize, lst) == false)
return true;
}
+/* Free all information we have cached for this BFD. We can always
+ read it again later if we need it. */
+
+static boolean
+som_bfd_free_cached_info (abfd)
+ bfd *abfd;
+{
+ asection *o;
+
+#define FREE(x) if (x != NULL) { free (x); x = NULL; }
+ /* Free the native string and symbol tables. */
+ FREE (obj_som_symtab (abfd));
+ FREE (obj_som_stringtab (abfd));
+ for (o = abfd->sections; o != (asection *) NULL; o = o->next)
+ {
+ /* Free the native relocations. */
+ o->reloc_count = -1;
+ FREE (som_section_data (o)->reloc_stream);
+ /* Free the generic relocations. */
+ FREE (o->relocation);
+ }
+#undef FREE
+
+ return true;
+}
+
/* End of miscellaneous support functions. */
#define som_bfd_debug_info_start bfd_void
#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 som_bfd_get_relocated_section_contents \
bfd_generic_get_relocated_section_contents
#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
-#define som_bfd_copy_private_bfd_data \
- ((boolean (*) PARAMS ((bfd *, bfd *))) bfd_true)
-
bfd_target som_vec =
{
"som", /* name */
projects / deliverable / binutils-gdb.git / blobdiff