/* 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 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_set_arch_mach PARAMS ((bfd *, enum bfd_architecture,
carsym **syms));
static boolean som_slurp_armap PARAMS ((bfd *));
static boolean som_write_armap PARAMS ((bfd *));
-static boolean som_slurp_extended_name_table PARAMS ((bfd *));
static void som_bfd_derive_misc_symbol_info PARAMS ((bfd *, asymbol *,
struct som_misc_symbol_info *));
static boolean som_bfd_prep_for_ar_write PARAMS ((bfd *, unsigned int *,
static boolean som_bfd_ar_write_symbol_stuff PARAMS ((bfd *, unsigned int,
unsigned int,
struct lst_header));
+static CONST char *normalize PARAMS ((CONST char *file));
/* 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;
}
/* First, read in space names */
space_strings = malloc (file_hdr->space_strings_size);
- if (!space_strings)
+ if (!space_strings && file_hdr->space_strings_size != 0)
{
bfd_set_error (bfd_error_no_memory);
goto error_return;
if (!space_asect)
goto error_return;
+ if (space.is_loadable == 0)
+ 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);
+
/* Now, read in the first subspace for this space */
if (bfd_seek (abfd, file_hdr->subspace_location
+ space.subspace_index * sizeof subspace,
if (!subspace_asect)
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);
+
/* 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. */
subspace_asect->flags |= SEC_IS_COMMON;
else if (subspace.subspace_length > 0)
subspace_asect->flags |= SEC_HAS_CONTENTS;
+
if (subspace.is_loadable)
subspace_asect->flags |= SEC_ALLOC | SEC_LOAD;
+ else
+ subspace_asect->flags |= SEC_DEBUGGING;
+
if (subspace.code_only)
subspace_asect->flags |= SEC_CODE;
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
{
/* Handle a section symbol; these have no pointers back to the
SOM symbol info. So we just use the pointer field (udata)
- to hold the relocation count.
-
- FIXME. While we're here set the name of any section symbol
- to something which will not screw GDB. How do other formats
- deal with this?!? */
- if (som_symbol_data (syms[i]) == NULL)
+ to hold the relocation count. */
+ if (som_symbol_data (syms[i]) == NULL
+ || syms[i]->flags & BSF_SECTION_SYM)
{
syms[i]->flags |= BSF_SECTION_SYM;
- syms[i]->name = "L$0\002";
syms[i]->udata = (PTR) 0;
}
else
arelent *reloc = section->orelocation[i];
int scale;
- /* If no symbol, then there is no counter to increase. */
- if (reloc->sym_ptr_ptr == NULL)
+ /* A relocation against a symbol in the *ABS* section really
+ does not have a symbol. Likewise if the symbol isn't associated
+ with any section. */
+ if (reloc->sym_ptr_ptr == NULL
+ || (*reloc->sym_ptr_ptr)->section == &bfd_abs_section)
continue;
/* Scaling to encourage symbols involved in R_DP_RELATIVE
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
we support only the copyright and version headers. */
obj_som_file_hdr (abfd)->aux_header_location = current_offset;
obj_som_file_hdr (abfd)->aux_header_size = 0;
+ if (abfd->flags & EXEC_P)
+ {
+ /* Parts of the exec header will be filled in later, so
+ 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;
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;
/* Find a space. */
while (som_section_data (section)->is_space == 0)
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
|| (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. */
+ if (abfd->flags & D_PAGED
+ || ((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;
+ }
+
+ /* Only do this for the first subspace within each space. */
+ first_subspace = 0;
+ }
+
+ subsection->target_index = total_subspaces++;
/* This is real data to be loaded from the file. */
if (subsection->flags & SEC_LOAD)
{
+ /* 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;
/* Looks like uninitialized data. */
else
{
+ /* 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.
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;
while (som_section_data (section)->is_space == 0)
section = section->next;
+ current_offset = SOM_ALIGN (current_offset, PA_PAGESIZE);
+
/* Now look for all its subspaces. */
for (subsection = abfd->sections;
subsection != NULL;
|| (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)
{
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, SEEK_SET) < 0)
+ {
+ bfd_set_error (bfd_error_system_call);
+ return false;
+ }
+ if (bfd_write ((PTR) "", 1, 1, abfd) != 1)
+ {
+ bfd_set_error (bfd_error_system_call);
+ 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);
+ exec_header.exec_dsize = tmp;
+
+ bfd_seek (abfd, obj_som_file_hdr (abfd)->aux_header_location, SEEK_SET);
+
+ if (bfd_write ((PTR) &exec_header, AUX_HDR_SIZE, 1, abfd)
+ != AUX_HDR_SIZE)
+ {
+ bfd_set_error (bfd_error_system_call);
+ 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;
to hold the symbol table as we build it. */
symtab_size = num_syms * sizeof (struct symbol_dictionary_record);
som_symtab = (struct symbol_dictionary_record *) malloc (symtab_size);
- if (som_symtab == NULL)
+ if (som_symtab == NULL && symtab_size != 0)
{
bfd_set_error (bfd_error_no_memory);
goto error_return;
asection *section;
for (section = abfd->sections; section != NULL; section = section->next)
- if (som_section_data (section)->subspace_index == index)
+ if (section->target_index == index)
return section;
/* Should never happen. */
/* Read in the external SOM representation. */
buf = malloc (symbol_count * symsize);
- if (buf == NULL)
+ if (buf == NULL && symbol_count * symsize != 0)
{
bfd_set_error (bfd_error_no_memory);
goto error_return;
/* 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:
if (bufp->symbol_type != ST_STORAGE)
sym->symbol.section = &bfd_und_section;
else
sym->symbol.flags |= (BSF_EXPORT | BSF_GLOBAL);
break;
+ case SS_UNSAT:
+ if (bufp->symbol_type != ST_STORAGE)
+ sym->symbol.section = &bfd_und_section;
+ else
+ sym->symbol.section = &bfd_com_section;
+ break;
+
case SS_UNIVERSAL:
sym->symbol.flags |= (BSF_EXPORT | BSF_GLOBAL);
sym->symbol.section
break;
}
- /* Mark symbols left around by the debugger. */
- if (strlen (sym->symbol.name) >= 2
- && sym->symbol.name[0] == 'L'
- && (sym->symbol.name[1] == '$' || sym->symbol.name[2] == '$'
- || sym->symbol.name[3] == '$'))
+ /* Mark section symbols and symbols used by the debugger. */
+ if (sym->symbol.name[0] == '$'
+ && sym->symbol.name[strlen (sym->symbol.name) - 1] == '$')
+ sym->symbol.flags |= BSF_SECTION_SYM;
+ else if (!strncmp (sym->symbol.name, "L$0\002", 4))
+ {
+ sym->symbol.flags |= BSF_SECTION_SYM;
+ sym->symbol.name = sym->symbol.section->name;
+ }
+ else if (!strncmp (sym->symbol.name, "L$0\001", 4))
sym->symbol.flags |= BSF_DEBUGGING;
/* Note increment at bottom of loop, since we skip some symbols
}
}
+static boolean
+som_bfd_is_local_label (abfd, sym)
+ bfd *abfd;
+ asymbol *sym;
+{
+ return (sym->name[0] == 'L' && sym->name[1] == '$');
+}
+
/* Count or process variable-length SOM fixup records.
To avoid code duplication we use this code both to compute the number
}
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;
}
+/* Copy any private info we understand from the input section
+ to the output section. */
+static boolean
+som_bfd_copy_private_section_data (ibfd, isection, obfd, osection)
+ bfd *ibfd;
+ asection *isection;
+ bfd *obfd;
+ asection *osection;
+{
+ /* 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;
+
+ memcpy (som_section_data (osection), som_section_data (isection),
+ sizeof (struct som_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;
+
+ 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. */
symindex *count;
{
unsigned int i;
- unsigned int *hash_table = NULL
+ unsigned int *hash_table = NULL;
file_ptr lst_filepos = bfd_tell (abfd) - sizeof (struct lst_header);
hash_table =
(unsigned int *) malloc (lst_header->hash_size * sizeof (unsigned int));
- if (hash_table == NULL)
+ if (hash_table == NULL && lst_header->hash_size != 0)
{
bfd_set_error (bfd_error_no_memory);
goto error_return;
hash_table =
(unsigned int *) malloc (lst_header->hash_size * sizeof (unsigned int));
- if (hash_table == NULL)
+ if (hash_table == NULL && lst_header->hash_size != 0)
{
bfd_set_error (bfd_error_no_memory);
goto error_return;
som_dict =
(struct som_entry *) malloc (lst_header->module_count
* sizeof (struct som_entry));
- if (som_dict == NULL)
+ if (som_dict == NULL && lst_header->module_count != 0)
{
bfd_set_error (bfd_error_no_memory);
goto error_return;
== false)
return false;
+ /* 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;
+ }
+
/* Notify the generic archive code that we have a symbol map. */
bfd_has_map (abfd) = true;
return true;
| (symbol->name[len-2] << 8) | symbol->name[len-1];
}
+static CONST char *
+normalize (file)
+ CONST char *file;
+{
+ CONST char *filename = strrchr (file, '/');
+
+ if (filename != NULL)
+ filename++;
+ else
+ filename = file;
+ return filename;
+}
+
/* Do the bulk of the work required to write the SOM library
symbol table. */
file_ptr lst_filepos;
char *strings = NULL, *p;
struct lst_symbol_record *lst_syms = NULL, *curr_lst_sym;
- bfd *curr_bfd = abfd->archive_head;
+ bfd *curr_bfd;
unsigned int *hash_table = NULL;
struct som_entry *som_dict = NULL;
struct lst_symbol_record **last_hash_entry = NULL;
- unsigned int curr_som_offset, som_index;
+ unsigned int curr_som_offset, som_index, extended_name_length = 0;
+ unsigned int maxname = abfd->xvec->ar_max_namelen;
hash_table =
(unsigned int *) malloc (lst.hash_size * sizeof (unsigned int));
- if (hash_table == NULL)
+ if (hash_table == NULL && lst.hash_size != 0)
{
bfd_set_error (bfd_error_no_memory);
goto error_return;
som_dict =
(struct som_entry *) malloc (lst.module_count
* sizeof (struct som_entry));
- if (som_dict == NULL)
+ if (som_dict == NULL && lst.module_count != 0)
{
bfd_set_error (bfd_error_no_memory);
goto error_return;
last_hash_entry =
((struct lst_symbol_record **)
malloc (lst.hash_size * sizeof (struct lst_symbol_record *)));
- if (last_hash_entry == NULL)
+ if (last_hash_entry == NULL && lst.hash_size != 0)
{
bfd_set_error (bfd_error_no_memory);
goto error_return;
som_index = 0;
curr_som_offset = 8 + 2 * sizeof (struct ar_hdr) + lst.file_end;
+ /* Yow! We have to know the size of the extended name table
+ too. */
+ for (curr_bfd = abfd->archive_head;
+ curr_bfd != NULL;
+ curr_bfd = curr_bfd->next)
+ {
+ CONST char *normal = normalize (curr_bfd->filename);
+ unsigned int thislen;
+
+ if (!normal)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ return false;
+ }
+ thislen = strlen (normal);
+ if (thislen > maxname)
+ extended_name_length += thislen + 1;
+ }
+
+ /* Make room for the archive header and the contents of the
+ extended string table. */
+ if (extended_name_length)
+ curr_som_offset += extended_name_length + sizeof (struct ar_hdr);
+
+ /* Make sure we're properly aligned. */
+ curr_som_offset = (curr_som_offset + 0x1) & ~0x1;
+
/* FIXME should be done with buffers just like everything else... */
lst_syms = malloc (nsyms * sizeof (struct lst_symbol_record));
- if (lst_syms == NULL)
+ if (lst_syms == NULL && nsyms != 0)
{
bfd_set_error (bfd_error_no_memory);
goto error_return;
}
strings = malloc (string_size);
- if (strings == NULL)
+ if (strings == NULL && string_size != 0)
{
bfd_set_error (bfd_error_no_memory);
goto error_return;
p = strings;
curr_lst_sym = lst_syms;
-
+ curr_bfd = abfd->archive_head;
while (curr_bfd != NULL)
{
unsigned int curr_count, i;
/* SOM ABI says this must be zero. */
lst.free_list = 0;
-
lst.file_end = lst_size;
/* Compute the checksum. Must happen after the entire lst header
has filled in. */
p = (int *)&lst;
+ lst.checksum = 0;
for (i = 0; i < sizeof (struct lst_header)/sizeof (int) - 1; i++)
lst.checksum ^= *p++;
return true;
}
-/* Apparently the extened names are never used, even though they appear
- in the SOM ABI. Hmmm. */
-static boolean
-som_slurp_extended_name_table (abfd)
- bfd *abfd;
-{
- bfd_ardata (abfd)->extended_names = NULL;
- return true;
-}
-
/* End of miscellaneous support functions. */
#define som_bfd_debug_info_start bfd_void
#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_truncate_arname bfd_bsd_truncate_arname
+#define som_slurp_extended_name_table _bfd_slurp_extended_name_table
#define som_get_lineno (struct lineno_cache_entry *(*)())bfd_nullvoidptr
#define som_close_and_cleanup bfd_generic_close_and_cleanup
predictable, and if so what is it */
0,
'/', /* ar_pad_char */
- 16, /* ar_max_namelen */
+ 14, /* ar_max_namelen */
3, /* minimum alignment */
bfd_getb64, bfd_getb_signed_64, bfd_putb64,
bfd_getb32, bfd_getb_signed_32, bfd_putb32,
projects / binutils.git / blobdiff