#include "libbfd.h"
#include "som.h"
-#include "libhppa.h"
#include <stdio.h>
#include <sys/types.h>
/* 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 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_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.
/* Return the logarithm of X, base 2, considering X unsigned.
- Abort if X is not a power of two -- this should never happen (FIXME:
- It will happen on corrupt executables. GDB should give an error, not
- a coredump, in that case). */
+ Abort -1 if X is not a power or two or is zero. */
static int
log2 (x)
/* Test for 0 or a power of 2. */
if (x == 0 || x != (x & -x))
- abort();
+ return -1;
while ((x >>= 1) != 0)
log++;
bfd *abfd;
int base_type;
int format;
- enum hppa_reloc_field_selector_type field;
+ enum hppa_reloc_field_selector_type_alt field;
{
int *final_type, **final_types;
/* 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;
+ switch (file_hdrp->a_magic)
+ {
+ case DEMAND_MAGIC:
+ abfd->flags |= (D_PAGED | WP_TEXT | EXEC_P);
+ break;
+ case SHARE_MAGIC:
+ abfd->flags |= (WP_TEXT | EXEC_P);
+ break;
+ case EXEC_MAGIC:
+ abfd->flags |= (EXEC_P);
+ break;
+ case RELOC_MAGIC:
+ abfd->flags |= HAS_RELOC;
+ break;
+ default:
+ break;
+ }
+
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;
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
- may have more than one $CODE$ subspace. */
-
-static asection *
-make_unique_section (abfd, name, num)
- bfd *abfd;
- CONST char *name;
- int num;
-{
- asection *sect;
- char *newname;
- char altname[100];
-
- sect = bfd_make_section (abfd, name);
- while (!sect)
- {
- sprintf (altname, "%s-%d", name, num++);
- sect = bfd_make_section (abfd, altname);
- }
-
- newname = bfd_alloc (abfd, strlen (sect->name) + 1);
- if (!newname)
- {
- bfd_set_error (bfd_error_no_memory);
- return NULL;
- }
- strcpy (newname, sect->name);
-
- sect->name = newname;
- return sect;
-}
-
/* Convert all of the space and subspace info into BFD sections. Each space
contains a number of subspaces, which in turn describe the mapping between
regions of the exec file, and the address space that the program runs in.
/* First, read in space names */
- space_strings = alloca (file_hdr->space_strings_size);
- if (!space_strings)
- return false;
+ space_strings = malloc (file_hdr->space_strings_size);
+ if (!space_strings && file_hdr->space_strings_size != 0)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ goto error_return;
+ }
if (bfd_seek (abfd, file_hdr->space_strings_location, SEEK_SET) < 0)
- return false;
+ goto error_return;
if (bfd_read (space_strings, 1, file_hdr->space_strings_size, abfd)
!= file_hdr->space_strings_size)
- return false;
+ goto error_return;
/* Loop over all of the space dictionaries, building up sections */
for (space_index = 0; space_index < file_hdr->space_total; space_index++)
struct subspace_dictionary_record subspace, save_subspace;
int subspace_index;
asection *space_asect;
+ char *newname;
/* Read the space dictionary element */
if (bfd_seek (abfd, file_hdr->space_location
+ space_index * sizeof space, SEEK_SET) < 0)
- return false;
+ goto error_return;
if (bfd_read (&space, 1, sizeof space, abfd) != sizeof space)
- return false;
+ goto error_return;
/* Setup the space name string */
space.name.n_name = space.name.n_strx + space_strings;
/* Make a section out of it */
- space_asect = make_unique_section (abfd, space.name.n_name, space_index);
+ newname = bfd_alloc (abfd, strlen (space.name.n_name) + 1);
+ if (!newname)
+ goto error_return;
+ strcpy (newname, space.name.n_name);
+
+ space_asect = bfd_make_section_anyway (abfd, newname);
if (!space_asect)
- return false;
+ 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,
SEEK_SET) < 0)
- return false;
+ goto error_return;
if (bfd_read (&subspace, 1, sizeof subspace, abfd) != sizeof subspace)
- return false;
+ goto error_return;
/* 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 false;
+ goto error_return;
/* 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 = log2 (subspace.alignment);
+ if (space_asect->alignment_power == -1)
+ goto error_return;
/* Initialize save_subspace so we can reliably determine if this
loop placed any useful values into it. */
/* Read in the next subspace */
if (bfd_read (&subspace, 1, sizeof subspace, abfd)
!= sizeof subspace)
- return false;
+ goto error_return;
/* Setup the subspace name string */
subspace.name.n_name = subspace.name.n_strx + space_strings;
- /* Make a section out of this subspace */
- subspace_asect = make_unique_section (abfd, subspace.name.n_name,
- space.subspace_index + subspace_index);
+ newname = bfd_alloc (abfd, strlen (subspace.name.n_name) + 1);
+ if (!newname)
+ goto error_return;
+ strcpy (newname, subspace.name.n_name);
+ /* Make a section out of this subspace */
+ subspace_asect = bfd_make_section_anyway (abfd, newname);
if (!subspace_asect)
- return false;
+ 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
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;
subspace_asect->vma = subspace.subspace_start;
subspace_asect->_cooked_size = subspace.subspace_length;
subspace_asect->_raw_size = subspace.subspace_length;
- subspace_asect->alignment_power = log2 (subspace.alignment);
subspace_asect->filepos = subspace.file_loc_init_value;
+ subspace_asect->alignment_power = log2 (subspace.alignment);
+ if (subspace_asect->alignment_power == -1)
+ goto error_return;
}
/* 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 ();
+ goto error_return;
/* Setup the sizes for the space section based upon the info in the
last subspace of the space. */
space_asect->_raw_size = save_subspace.file_loc_init_value
- space_asect->filepos + save_subspace.initialization_length;
}
+ if (space_strings != NULL)
+ free (space_strings);
return true;
+
+ error_return:
+ if (space_strings != NULL)
+ free (space_strings);
+ return false;
}
/* Read in a SOM object and make it into a BFD. */
PA1.1 instructions/registers have been used. */
file_hdr->system_id = CPU_PA_RISC1_0;
- /* FIXME. Only correct for building relocatable objects. */
if (abfd->flags & EXEC_P)
- abort ();
+ {
+ if (abfd->flags & D_PAGED)
+ file_hdr->a_magic = DEMAND_MAGIC;
+ else if (abfd->flags & WP_TEXT)
+ file_hdr->a_magic = SHARE_MAGIC;
+ else
+ file_hdr->a_magic = EXEC_MAGIC;
+ }
else
file_hdr->a_magic = RELOC_MAGIC;
{
/* 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
unsigned int *total_reloc_sizep;
{
unsigned int i, j;
- unsigned char *tmp_space, *p;
+ /* Chunk of memory that we can use as buffer space, then throw
+ away. */
+ unsigned char tmp_space[SOM_TMP_BUFSIZE];
+ unsigned char *p;
unsigned int total_reloc_size = 0;
unsigned int subspace_reloc_size = 0;
unsigned int num_spaces = obj_som_file_hdr (abfd)->space_total;
asection *section = abfd->sections;
- /* Get a chunk of memory that we can use as buffer space, then throw
- away. */
- tmp_space = alloca (SOM_TMP_BUFSIZE);
memset (tmp_space, 0, SOM_TMP_BUFSIZE);
p = tmp_space;
unsigned long current_offset;
unsigned int *string_sizep;
{
- unsigned char *tmp_space, *p;
+ /* Chunk of memory that we can use as buffer space, then throw
+ away. */
+ unsigned char tmp_space[SOM_TMP_BUFSIZE];
+ unsigned char *p;
unsigned int strings_size = 0;
asection *section;
- /* Get a chunk of memory that we can use as buffer space, then throw
- away. */
- tmp_space = alloca (SOM_TMP_BUFSIZE);
memset (tmp_space, 0, SOM_TMP_BUFSIZE);
p = tmp_space;
hold the string length + the string itself + null terminator. */
if (p - tmp_space + 5 + length > SOM_TMP_BUFSIZE)
{
- if (bfd_write ((PTR) tmp_space, p - tmp_space, 1, abfd)
+ if (bfd_write ((PTR) &tmp_space[0], p - tmp_space, 1, abfd)
!= p - tmp_space)
{
bfd_set_error (bfd_error_system_call);
/* Done with the space/subspace strings. Write out any information
contained in a partial block. */
- if (bfd_write ((PTR) tmp_space, p - tmp_space, 1, abfd) != p - tmp_space)
+ if (bfd_write ((PTR) &tmp_space[0], p - tmp_space, 1, abfd) != p - tmp_space)
{
bfd_set_error (bfd_error_system_call);
return false;
unsigned int *string_sizep;
{
unsigned int i;
- unsigned char *tmp_space, *p;
+
+ /* Chunk of memory that we can use as buffer space, then throw
+ away. */
+ unsigned char tmp_space[SOM_TMP_BUFSIZE];
+ unsigned char *p;
unsigned int strings_size = 0;
- /* Get a chunk of memory that we can use as buffer space, then throw
- away. */
- tmp_space = alloca (SOM_TMP_BUFSIZE);
memset (tmp_space, 0, SOM_TMP_BUFSIZE);
p = tmp_space;
current buffer contents now. */
if (p - tmp_space + 5 + length > SOM_TMP_BUFSIZE)
{
- if (bfd_write ((PTR) tmp_space, p - tmp_space, 1, abfd)
+ if (bfd_write ((PTR) &tmp_space[0], p - tmp_space, 1, abfd)
!= p - tmp_space)
{
bfd_set_error (bfd_error_system_call);
}
/* Scribble out any partial block. */
- if (bfd_write ((PTR) tmp_space, p - tmp_space, 1, abfd) != p - tmp_space)
+ if (bfd_write ((PTR) &tmp_space[0], p - tmp_space, 1, abfd) != p - tmp_space)
{
bfd_set_error (bfd_error_system_call);
return false;
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;
+ /* 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;
+ }
+
som_section_data (subsection)->subspace_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;
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;
+
+ /* 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 undefined or common symbols, but the HP linker will
choke if it's not set to some "reasonable" value. We
use zero as a reasonable value. */
- if (sym->section == &bfd_com_section || sym->section == &bfd_und_section)
+ if (sym->section == &bfd_com_section || sym->section == &bfd_und_section
+ || sym->section == &bfd_abs_section)
info->symbol_info = 0;
/* For all other symbols, the symbol_info field contains the
subspace index of the space this symbol is contained in. */
unsigned int num_syms = bfd_get_symcount (abfd);
file_ptr symtab_location = obj_som_file_hdr (abfd)->symbol_location;
asymbol **bfd_syms = bfd_get_outsymbols (abfd);
- struct symbol_dictionary_record *som_symtab;
+ struct symbol_dictionary_record *som_symtab = NULL;
int i, symtab_size;
/* Compute total symbol table size and allocate a chunk of memory
to hold the symbol table as we build it. */
symtab_size = num_syms * sizeof (struct symbol_dictionary_record);
- som_symtab = (struct symbol_dictionary_record *) alloca (symtab_size);
+ som_symtab = (struct symbol_dictionary_record *) malloc (symtab_size);
+ if (som_symtab == NULL && symtab_size != 0)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ goto error_return;
+ }
memset (som_symtab, 0, symtab_size);
/* Walk over each symbol. */
if (bfd_seek (abfd, symtab_location, SEEK_SET) != 0)
{
bfd_set_error (bfd_error_system_call);
- return false;
+ goto error_return;
}
if (bfd_write ((PTR) som_symtab, symtab_size, 1, abfd) != symtab_size)
{
bfd_set_error (bfd_error_system_call);
- return false;
+ goto error_return;
}
- return true;
+
+ if (som_symtab != NULL)
+ free (som_symtab);
+ return true;
+ error_return:
+ if (som_symtab != NULL)
+ free (som_symtab);
+ return false;
}
/* Write an object in SOM format. */
if (!som_slurp_symbol_table (abfd))
return 0;
- return (bfd_get_symcount (abfd) + 1) * (sizeof (som_symbol_type *));
+ return (bfd_get_symcount (abfd) + 1) * (sizeof (asymbol *));
}
/* Convert from a SOM subspace index to a BFD section. */
int symbol_count = bfd_get_symcount (abfd);
int symsize = sizeof (struct symbol_dictionary_record);
char *stringtab;
- struct symbol_dictionary_record *buf, *bufp, *endbufp;
+ struct symbol_dictionary_record *buf = NULL, *bufp, *endbufp;
som_symbol_type *sym, *symbase;
/* Return saved value if it exists. */
if (obj_som_symtab (abfd) != NULL)
- return true;
+ goto successful_return;
/* Special case. This is *not* an error. */
if (symbol_count == 0)
- return true;
+ goto successful_return;
if (!som_slurp_string_table (abfd))
- return false;
+ goto error_return;
stringtab = obj_som_stringtab (abfd);
if (symbase == NULL)
{
bfd_set_error (bfd_error_no_memory);
- return false;
+ goto error_return;
}
/* Read in the external SOM representation. */
- buf = alloca (symbol_count * symsize);
- if (buf == NULL)
+ buf = malloc (symbol_count * symsize);
+ if (buf == NULL && symbol_count * symsize != 0)
{
bfd_set_error (bfd_error_no_memory);
- return false;
+ goto error_return;
}
if (bfd_seek (abfd, obj_som_sym_filepos (abfd), SEEK_SET) < 0)
{
bfd_set_error (bfd_error_system_call);
- return false;
+ goto error_return;
}
if (bfd_read (buf, symbol_count * symsize, 1, abfd)
!= symbol_count * symsize)
{
bfd_set_error (bfd_error_no_symbols);
- return (false);
+ goto error_return;
}
/* Iterate over all the symbols and internalize them. */
/* 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
/* Save our results and return success. */
obj_som_symtab (abfd) = symbase;
+ successful_return:
+ if (buf != NULL)
+ free (buf);
return (true);
+
+ error_return:
+ if (buf != NULL)
+ free (buf);
+ return false;
}
/* Canonicalize a SOM symbol table. Return the number of entries
}
}
+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
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;
+}
+
/* Set backend info for sections which can not be described
in the BFD data structures. */
asection *section;
int defined;
int private;
- unsigned char sort_key;
+ unsigned int sort_key;
int spnum;
{
struct space_dictionary_record *space_dict;
/* Attach an auxiliary header to the BFD backend so that it may be
written into the object file. */
-void
+boolean
bfd_som_attach_aux_hdr (abfd, type, string)
bfd *abfd;
int type;
if (!obj_som_version_hdr (abfd))
{
bfd_set_error (bfd_error_no_memory);
- abort(); /* FIXME */
+ return false;
}
obj_som_version_hdr (abfd)->header_id.type = VERSION_AUX_ID;
obj_som_version_hdr (abfd)->header_id.length = len + pad;
if (!obj_som_copyright_hdr (abfd))
{
bfd_set_error (bfd_error_no_error);
- abort(); /* FIXME */
+ return false;
}
obj_som_copyright_hdr (abfd)->header_id.type = COPYRIGHT_AUX_ID;
obj_som_copyright_hdr (abfd)->header_id.length = len + pad;
obj_som_copyright_hdr (abfd)->string_length = len;
strcpy (obj_som_copyright_hdr (abfd)->copyright, string);
}
- else
- abort ();
+ return true;
}
static boolean
symindex *count;
{
unsigned int i;
- unsigned int *hash_table =
- (unsigned int *) alloca (lst_header->hash_size * sizeof (unsigned int));
+ 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 && lst_header->hash_size != 0)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ goto error_return;
+ }
+
/* Don't forget to initialize the counter! */
*count = 0;
!= lst_header->hash_size * 4)
{
bfd_set_error (bfd_error_system_call);
- return false;
+ goto error_return;
}
/* Walk each chain counting the number of symbols found on that particular
if (bfd_seek (abfd, lst_filepos + hash_table[i], SEEK_SET) < 0)
{
bfd_set_error (bfd_error_system_call);
- return false;
+ goto error_return;
}
/* Read in this symbol and update the counter. */
!= sizeof (lst_symbol))
{
bfd_set_error (bfd_error_system_call);
- return false;
+ goto error_return;
}
(*count)++;
< 0)
{
bfd_set_error (bfd_error_system_call);
- return false;
+ goto error_return;
}
/* Read the symbol in and update the counter. */
!= sizeof (lst_symbol))
{
bfd_set_error (bfd_error_system_call);
- return false;
+ goto error_return;
}
(*count)++;
}
}
+ if (hash_table != NULL)
+ free (hash_table);
return true;
+
+ error_return:
+ if (hash_table != NULL)
+ free (hash_table);
+ return false;
}
/* Fill in the canonical archive symbols (SYMS) from the archive described
{
unsigned int i, len;
carsym *set = syms[0];
- unsigned int *hash_table =
- (unsigned int *) alloca (lst_header->hash_size * sizeof (unsigned int));
- struct som_entry *som_dict =
- (struct som_entry *) alloca (lst_header->module_count
- * sizeof (struct som_entry));
+ unsigned int *hash_table = NULL;
+ struct som_entry *som_dict = 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 && 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 && lst_header->module_count != 0)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ goto error_return;
+ }
+
/* Read in the hash table. The has table is an array of 32bit file offsets
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);
- return false;
+ goto error_return;
}
/* Seek to and read in the SOM dictionary. We will need this to fill
if (bfd_seek (abfd, lst_filepos + lst_header->dir_loc, SEEK_SET) < 0)
{
bfd_set_error (bfd_error_system_call);
- return false;
+ goto error_return;
}
if (bfd_read ((PTR) som_dict, lst_header->module_count,
!= lst_header->module_count * sizeof (struct som_entry))
{
bfd_set_error (bfd_error_system_call);
- return false;
+ goto error_return;
}
/* Walk each chain filling in the carsyms as we go along. */
if (bfd_seek (abfd, lst_filepos + hash_table[i], SEEK_SET) < 0)
{
bfd_set_error (bfd_error_system_call);
- return false;
+ goto error_return;
}
if (bfd_read ((PTR) & lst_symbol, 1, sizeof (lst_symbol), abfd)
!= sizeof (lst_symbol))
{
bfd_set_error (bfd_error_system_call);
- return false;
+ goto error_return;
}
/* Get the name of the symbol, first get the length which is stored
+ lst_symbol.name.n_strx - 4, SEEK_SET) < 0)
{
bfd_set_error (bfd_error_system_call);
- return false;
+ goto error_return;
}
if (bfd_read (&len, 1, 4, abfd) != 4)
{
bfd_set_error (bfd_error_system_call);
- return false;
+ goto error_return;
}
/* Allocate space for the name and null terminate it too. */
if (!set->name)
{
bfd_set_error (bfd_error_no_memory);
- return false;
+ goto error_return;
}
if (bfd_read (set->name, 1, len, abfd) != len)
{
bfd_set_error (bfd_error_system_call);
- return false;
+ goto error_return;
}
set->name[len] = 0;
< 0)
{
bfd_set_error (bfd_error_system_call);
- return false;
+ goto error_return;
}
if (bfd_read ((PTR) & lst_symbol, 1, sizeof (lst_symbol), abfd)
!= sizeof (lst_symbol))
{
bfd_set_error (bfd_error_system_call);
- return false;
+ goto error_return;
}
/* Seek to the name length & string and read them in. */
+ lst_symbol.name.n_strx - 4, SEEK_SET) < 0)
{
bfd_set_error (bfd_error_system_call);
- return false;
+ goto error_return;
}
if (bfd_read (&len, 1, 4, abfd) != 4)
{
bfd_set_error (bfd_error_system_call);
- return false;
+ goto error_return;
}
/* Allocate space for the name and null terminate it too. */
if (!set->name)
{
bfd_set_error (bfd_error_no_memory);
- return false;
+ goto error_return;
}
if (bfd_read (set->name, 1, len, abfd) != len)
{
bfd_set_error (bfd_error_system_call);
- return false;
+ goto error_return;
}
set->name[len] = 0;
}
/* If we haven't died by now, then we successfully read the entire
archive symbol table. */
+ if (hash_table != NULL)
+ free (hash_table);
+ if (som_dict != NULL)
+ free (som_dict);
return true;
+
+ error_return:
+ if (hash_table != NULL)
+ free (hash_table);
+ if (som_dict != NULL)
+ free (som_dict);
+ return false;
}
/* Read in the LST from the archive. */
if (strncmp (ar_header.ar_fmag, ARFMAG, 2))
{
bfd_set_error (bfd_error_malformed_archive);
- return NULL;
+ return false;
}
/* How big is the archive symbol table entry? */
if (errno != 0)
{
bfd_set_error (bfd_error_malformed_archive);
- return NULL;
+ return false;
}
/* Save off the file offset of the first real user data. */
if (lst_header.a_magic != LIBMAGIC)
{
bfd_set_error (bfd_error_malformed_archive);
- return NULL;
+ return false;
}
/* Count the number of symbols in the library symbol table. */
== 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. */
struct lst_header lst;
{
file_ptr lst_filepos;
- char *strings, *p;
- struct lst_symbol_record *lst_syms, *curr_lst_sym;
- bfd *curr_bfd = abfd->archive_head;
- unsigned int *hash_table =
- (unsigned int *) alloca (lst.hash_size * sizeof (unsigned int));
- struct som_entry *som_dict =
- (struct som_entry *) alloca (lst.module_count
+ char *strings = NULL, *p;
+ struct lst_symbol_record *lst_syms = NULL, *curr_lst_sym;
+ 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, 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 && 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));
- struct lst_symbol_record **last_hash_entry =
+ 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 **)
- alloca (lst.hash_size * sizeof (struct lst_symbol_record *)));
- unsigned int curr_som_offset, som_index;
+ malloc (lst.hash_size * sizeof (struct lst_symbol_record *)));
+ if (last_hash_entry == NULL && lst.hash_size != 0)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ goto error_return;
+ }
/* Lots of fields are file positions relative to the start
of the lst record. So save its location. */
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 = alloca (nsyms * sizeof (struct lst_symbol_record));
- strings = alloca (string_size);
+ lst_syms = malloc (nsyms * sizeof (struct lst_symbol_record));
+ if (lst_syms == NULL && nsyms != 0)
+ {
+ bfd_set_error (bfd_error_no_memory);
+ goto error_return;
+ }
+ strings = malloc (string_size);
+ 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;
to it. It's a little slimey to grab the symbols via obj_som_symtab,
but doing so avoids allocating lots of extra memory. */
if (som_slurp_symbol_table (curr_bfd) == false)
- return false;
+ goto error_return;
sym = obj_som_symtab (curr_bfd);
curr_count = bfd_get_symcount (curr_bfd);
!= lst.hash_size * 4)
{
bfd_set_error (bfd_error_system_call);
- return false;
+ goto error_return;
}
/* Then the SOM dictionary. */
!= lst.module_count * sizeof (struct som_entry))
{
bfd_set_error (bfd_error_system_call);
- return false;
+ goto error_return;
}
/* The library symbols. */
!= nsyms * sizeof (struct lst_symbol_record))
{
bfd_set_error (bfd_error_system_call);
- return false;
+ 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);
- return false;
+ goto error_return;
}
+ if (hash_table != NULL)
+ free (hash_table);
+ if (som_dict != NULL)
+ free (som_dict);
+ if (last_hash_entry != NULL)
+ free (last_hash_entry);
+ if (lst_syms != NULL)
+ free (lst_syms);
+ if (strings != NULL)
+ free (strings);
return true;
+
+ error_return:
+ if (hash_table != NULL)
+ free (hash_table);
+ if (som_dict != NULL)
+ free (som_dict);
+ if (last_hash_entry != NULL)
+ free (last_hash_entry);
+ if (lst_syms != NULL)
+ free (lst_syms);
+ if (strings != NULL)
+ free (strings);
+
+ return false;
}
/* Write out the LST for the archive.
/* 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
#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 */
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,