#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"
-#include "seclet.h"
+#include "bfdlink.h"
+#include "genlink.h"
#include "libelf.h"
#include "elf/mips.h"
+/* Get the ECOFF swapping routines. */
+#include "coff/sym.h"
+#include "coff/symconst.h"
+#include "coff/internal.h"
+#include "coff/ecoff.h"
+#include "coff/mips.h"
+#define ECOFF_32
+#include "ecoffswap.h"
+
static bfd_reloc_status_type mips_elf_hi16_reloc PARAMS ((bfd *abfd,
arelent *reloc,
asymbol *symbol,
PTR data,
asection *section,
- bfd *output_bfd));
+ bfd *output_bfd,
+ char **error));
+static bfd_reloc_status_type mips_elf_got16_reloc PARAMS ((bfd *abfd,
+ arelent *reloc,
+ asymbol *symbol,
+ PTR data,
+ asection *section,
+ bfd *output_bfd,
+ char **error));
static bfd_reloc_status_type mips_elf_lo16_reloc PARAMS ((bfd *abfd,
arelent *reloc,
asymbol *symbol,
PTR data,
asection *section,
- bfd *output_bfd));
+ bfd *output_bfd,
+ char **error));
static bfd_reloc_status_type mips_elf_gprel16_reloc PARAMS ((bfd *abfd,
arelent *reloc,
asymbol *symbol,
PTR data,
asection *section,
- bfd *output_bfd));
+ bfd *output_bfd,
+ char **error));
#define USE_REL 1 /* MIPS uses REL relocations instead of RELA */
26, /* bitsize */
false, /* pc_relative */
0, /* bitpos */
- complain_overflow_bitfield, /* complain_on_overflow */
+ complain_overflow_dont, /* complain_on_overflow */
+ /* This needs complex overflow
+ detection, because the upper four
+ bits must match the PC. */
bfd_elf_generic_reloc, /* special_function */
"R_MIPS_26", /* name */
true, /* partial_inplace */
false, /* pc_relative */
0, /* bitpos */
complain_overflow_signed, /* complain_on_overflow */
- bfd_elf_generic_reloc, /* special_function */
+ mips_elf_got16_reloc, /* special_function */
"R_MIPS_GOT16", /* name */
false, /* partial_inplace */
0, /* src_mask */
symbol,
data,
input_section,
- output_bfd)
+ output_bfd,
+ error_message)
bfd *abfd;
arelent *reloc_entry;
asymbol *symbol;
PTR data;
asection *input_section;
bfd *output_bfd;
+ char **error_message;
{
bfd_reloc_status_type ret;
bfd_vma relocation;
- /* FIXME: The symbol _gp_disp requires special handling, which we do
- not do. */
- if (strcmp (bfd_asymbol_name (symbol), "_gp_disp") == 0)
- abort ();
-
/* If we're relocating, and this an external symbol, we don't want
to change anything. */
if (output_bfd != (bfd *) NULL
return bfd_reloc_ok;
}
+ /* FIXME: The symbol _gp_disp requires special handling, which we do
+ not do. */
+ if (strcmp (bfd_asymbol_name (symbol), "_gp_disp") == 0)
+ abort ();
+
ret = bfd_reloc_ok;
if (symbol->section == &bfd_und_section
&& output_bfd == (bfd *) NULL)
symbol,
data,
input_section,
- output_bfd)
+ output_bfd,
+ error_message)
bfd *abfd;
arelent *reloc_entry;
asymbol *symbol;
PTR data;
asection *input_section;
bfd *output_bfd;
+ char **error_message;
{
/* FIXME: The symbol _gp_disp requires special handling, which we do
not do. */
- if (strcmp (bfd_asymbol_name (symbol), "_gp_disp") == 0)
+ if (output_bfd == (bfd *) NULL
+ && strcmp (bfd_asymbol_name (symbol), "_gp_disp") == 0)
abort ();
if (mips_hi16_addr != (bfd_byte *) NULL)
/* Now do the LO16 reloc in the usual way. */
return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
- input_section, output_bfd);
+ input_section, output_bfd, error_message);
+}
+
+/* Do a R_MIPS_GOT16 reloc. This is a reloc against the global offset
+ table used for PIC code. If the symbol is an external symbol, the
+ instruction is modified to contain the offset of the appropriate
+ entry in the global offset table. If the symbol is a section
+ symbol, the next reloc is a R_MIPS_LO16 reloc. The two 16 bit
+ addends are combined to form the real addend against the section
+ symbol; the GOT16 is modified to contain the offset of an entry in
+ the global offset table, and the LO16 is modified to offset it
+ appropriately. Thus an offset larger than 16 bits requires a
+ modified value in the global offset table.
+
+ This implementation suffices for the assembler, but the linker does
+ not yet know how to create global offset tables. */
+
+static bfd_reloc_status_type
+mips_elf_got16_reloc (abfd,
+ reloc_entry,
+ symbol,
+ data,
+ input_section,
+ output_bfd,
+ error_message)
+ bfd *abfd;
+ arelent *reloc_entry;
+ asymbol *symbol;
+ PTR data;
+ asection *input_section;
+ bfd *output_bfd;
+ char **error_message;
+{
+ /* If we're relocating, and this an external symbol, we don't want
+ to change anything. */
+ if (output_bfd != (bfd *) NULL
+ && (symbol->flags & BSF_SECTION_SYM) == 0
+ && reloc_entry->addend == 0)
+ {
+ reloc_entry->address += input_section->output_offset;
+ return bfd_reloc_ok;
+ }
+
+ /* If we're relocating, and this is a local symbol, we can handle it
+ just like HI16. */
+ if (output_bfd != (bfd *) NULL
+ && (symbol->flags & BSF_SECTION_SYM) != 0)
+ return mips_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
+ input_section, output_bfd, error_message);
+
+ abort ();
}
/* Do a R_MIPS_GPREL16 relocation. This is a 16 bit value which must
symbol,
data,
input_section,
- output_bfd)
+ output_bfd,
+ error_message)
bfd *abfd;
arelent *reloc_entry;
asymbol *symbol;
PTR data;
asection *input_section;
bfd *output_bfd;
+ char **error_message;
{
boolean relocateable;
bfd_vma relocation;
{
/* Only get the error once. */
elf_gp (output_bfd) = 4;
- /* FIXME: How can we get the program name here? */
- fprintf (stderr,
- "GP relative relocation when _gp not defined\n");
+ *error_message =
+ (char *) "GP relative relocation when _gp not defined";
return bfd_reloc_dangerous;
}
}
/* Make sure it fit in 16 bits. */
if (val >= 0x8000 && val < 0xffff8000)
- return bfd_reloc_outofrange;
+ return bfd_reloc_overflow;
return bfd_reloc_ok;
}
(bfd_byte *) ex->ri_gp_value);
}
\f
+/* Determine whether a symbol is global for the purposes of splitting
+ the symbol table into global symbols and local symbols. At least
+ on Irix 5, this split must be between section symbols and all other
+ symbols. On most ELF targets the split is between static symbols
+ and externally visible symbols. */
+
+/*ARGSUSED*/
+static boolean
+mips_elf_sym_is_global (abfd, sym)
+ bfd *abfd;
+ asymbol *sym;
+{
+ return (sym->flags & BSF_SECTION_SYM) == 0 ? true : false;
+}
+\f
+/* Set the right machine number for a MIPS ELF file. */
+
+static boolean
+mips_elf_object_p (abfd)
+ bfd *abfd;
+{
+ switch (elf_elfheader (abfd)->e_flags & EF_MIPS_ARCH)
+ {
+ default:
+ case E_MIPS_ARCH_1:
+ /* Just use the default, which was set in elfcode.h. */
+ break;
+
+ case E_MIPS_ARCH_2:
+ (void) bfd_default_set_arch_mach (abfd, bfd_arch_mips, 6000);
+ break;
+
+ case E_MIPS_ARCH_3:
+ (void) bfd_default_set_arch_mach (abfd, bfd_arch_mips, 4000);
+ break;
+ }
+
+ return true;
+}
+
+/* The final processing done just before writing out a MIPS ELF object
+ file. This gets the MIPS architecture right based on the machine
+ number. */
+
+static void
+mips_elf_final_write_processing (abfd)
+ bfd *abfd;
+{
+ unsigned long val;
+
+ switch (bfd_get_mach (abfd))
+ {
+ case 3000:
+ val = E_MIPS_ARCH_1;
+ break;
+
+ case 6000:
+ val = E_MIPS_ARCH_2;
+ break;
+
+ case 4000:
+ val = E_MIPS_ARCH_3;
+ break;
+
+ default:
+ return;
+ }
+
+ elf_elfheader (abfd)->e_flags &=~ EF_MIPS_ARCH;
+ elf_elfheader (abfd)->e_flags |= val;
+}
+\f
/* Handle a MIPS specific section when reading an object file. This
is called when elfcode.h finds a section with an unknown type.
FIXME: We need to handle the SHF_MIPS_GPREL flag, but I'm not sure
|| hdr->sh_size != sizeof (Elf32_External_RegInfo))
return false;
break;
+ case SHT_MIPS_OPTIONS:
+ if (strcmp (name, ".options") != 0)
+ return false;
+ break;
default:
return false;
}
else if (strcmp (name, ".ucode") == 0)
hdr->sh_type = SHT_MIPS_UCODE;
else if (strcmp (name, ".mdebug") == 0)
- hdr->sh_type = SHT_MIPS_DEBUG;
+ {
+ hdr->sh_type = SHT_MIPS_DEBUG;
+ hdr->sh_entsize = 1;
+ }
else if (strcmp (name, ".reginfo") == 0)
{
hdr->sh_type = SHT_MIPS_REGINFO;
+ hdr->sh_entsize = 1;
/* Force the section size to the correct value, even if the
linker thinks it is larger. The link routine below will only
write out this much data for .reginfo. */
hdr->sh_size = sec->_raw_size = sizeof (Elf32_External_RegInfo);
}
+ else if (strcmp (name, ".options") == 0)
+ {
+ hdr->sh_type = SHT_MIPS_OPTIONS;
+ hdr->sh_entsize = 1;
+ }
return true;
}
return true;
}
\f
-/* We need to use a special link routine to handle the .reginfo
- section. We need to merge all the .reginfo sections together, not
- write them all out sequentially. */
+/* Read ECOFF debugging information from a .mdebug section into a
+ ecoff_debug_info structure. */
static boolean
-mips_elf_seclet_link (abfd, data, relocateable)
+mips_elf_read_ecoff_info (abfd, section, debug)
bfd *abfd;
- PTR data;
- boolean relocateable;
+ asection *section;
+ struct ecoff_debug_info *debug;
{
- asection *sec;
+ HDRR *symhdr;
+ const struct ecoff_debug_swap *swap;
+ char *ext_hdr;
+
+ swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
+
+ ext_hdr = (char *) alloca (swap->external_hdr_size);
+
+ if (bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
+ swap->external_hdr_size)
+ == false)
+ return false;
+
+ symhdr = &debug->symbolic_header;
+ (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
+
+ /* The symbolic header contains absolute file offsets and sizes to
+ read. */
+#define READ(ptr, offset, count, size, type) \
+ if (symhdr->count == 0) \
+ debug->ptr = NULL; \
+ else \
+ { \
+ debug->ptr = (type) malloc (size * symhdr->count); \
+ if (debug->ptr == NULL) \
+ { \
+ bfd_error = no_memory; \
+ return false; \
+ } \
+ if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
+ || (bfd_read (debug->ptr, size, symhdr->count, \
+ abfd) != size * symhdr->count)) \
+ return false; \
+ }
+
+ READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
+ READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
+ READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
+ READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
+ READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
+ READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
+ union aux_ext *);
+ READ (ss, cbSsOffset, issMax, sizeof (char), char *);
+ READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
+ READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
+ READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
+ READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, PTR);
+
+ return true;
+}
+
+/* Get EXTR information for a symbol. */
+
+static boolean
+mips_elf_get_extr (sym, esym)
+ asymbol *sym;
+ EXTR *esym;
+{
+ if (sym->flags & BSF_SECTION_SYM)
+ return false;
+
+ if (bfd_asymbol_flavour (sym) != bfd_target_elf_flavour
+ || ((elf_symbol_type *) sym)->tc_data.mips_extr == NULL)
+ {
+ esym->jmptbl = 0;
+ esym->cobol_main = 0;
+ esym->weakext = 0;
+ esym->reserved = 0;
+ esym->ifd = ifdNil;
+ /* FIXME: we can do better than this for st and sc. */
+ esym->asym.st = stGlobal;
+ esym->asym.sc = scAbs;
+ esym->asym.reserved = 0;
+ esym->asym.index = indexNil;
+ return true;
+ }
+
+ *esym = *((elf_symbol_type *) sym)->tc_data.mips_extr;
+
+ return true;
+}
+
+/* Set the symbol index for an external symbol. This is actually not
+ needed for ELF. */
+
+/*ARGSUSED*/
+static void
+mips_elf_set_index (sym, indx)
+ asymbol *sym;
+ bfd_size_type indx;
+{
+}
+
+/* We need to use a special link routine to handle the .reginfo and
+ the .mdebug sections. We need to merge all instances of these
+ sections together, not write them all out sequentially. */
+
+static boolean
+mips_elf_final_link (abfd, info)
+ bfd *abfd;
+ struct bfd_link_info *info;
+{
+ bfd *sub;
+ size_t outsymalloc;
+ struct generic_write_global_symbol_info wginfo;
+ asection **secpp;
+ asection *o;
+ struct bfd_link_order *p;
+ asection *reginfo_sec, *mdebug_sec;
Elf32_RegInfo reginfo;
+ struct ecoff_debug_info debug;
+ const struct ecoff_debug_swap *swap
+ = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
+ HDRR *symhdr = &debug.symbolic_header;
+
+ abfd->outsymbols = (asymbol **) NULL;
+ abfd->symcount = 0;
+ outsymalloc = 0;
+
+ /* Build the output symbol table. This also reads in the symbols
+ for all the input BFDs, keeping them in the outsymbols field. */
+ for (sub = info->input_bfds; sub != (bfd *) NULL; sub = sub->link_next)
+ if (! _bfd_generic_link_output_symbols (abfd, sub, info, &outsymalloc))
+ return false;
- memset (®info, 0, sizeof reginfo);
+ /* Accumulate the global symbols. */
+ wginfo.output_bfd = abfd;
+ wginfo.psymalloc = &outsymalloc;
+ _bfd_generic_link_hash_traverse (_bfd_generic_hash_table (info),
+ _bfd_generic_link_write_global_symbol,
+ (PTR) &wginfo);
+
+ /* Remove empty sections. Also drop the .options section, since it
+ has special semantics which I haven't bothered to figure out.
+ Also drop the .gptab sections, which also require special
+ handling which is not currently done. Removing the .gptab
+ sections is required for Irix 5 compatibility; I don't know about
+ the other sections. */
+ secpp = &abfd->sections;
+ while (*secpp != NULL)
+ {
+ if ((*secpp)->_raw_size == 0
+ || strcmp ((*secpp)->name, ".options") == 0
+ || strncmp ((*secpp)->name, ".gptab", 6) == 0)
+ {
+ *secpp = (*secpp)->next;
+ --abfd->section_count;
+ }
+ else
+ secpp = &(*secpp)->next;
+ }
- for (sec = abfd->sections; sec != (asection *) NULL; sec = sec->next)
+ /* Go through the sections and collect the .reginfo and .mdebug
+ information. We don't write out the information until we have
+ set the section sizes, because the ELF backend only assigns space
+ in the file once. */
+ for (o = abfd->sections; o != (asection *) NULL; o = o->next)
{
- if (strcmp (sec->name, ".reginfo") == 0)
+ if (strcmp (o->name, ".reginfo") == 0)
{
- bfd_seclet_type *p;
- Elf32_External_RegInfo ext;
+ memset (®info, 0, sizeof reginfo);
/* We have found the .reginfo section in the output file.
- Look through all the seclets comprising it and merge the
- information together. */
- for (p = sec->seclets_head;
- p != (bfd_seclet_type *) NULL;
+ Look through all the link_orders comprising it and merge
+ the information together. */
+ for (p = o->link_order_head;
+ p != (struct bfd_link_order *) NULL;
p = p->next)
{
- switch (p->type)
+ asection *input_section;
+ bfd *input_bfd;
+ Elf32_External_RegInfo ext;
+ Elf32_RegInfo sub;
+
+ if (p->type != bfd_indirect_link_order)
+ continue;
+
+ input_section = p->u.indirect.section;
+ input_bfd = input_section->owner;
+ BFD_ASSERT (input_section->_raw_size
+ == sizeof (Elf32_External_RegInfo));
+ if (! bfd_get_section_contents (input_bfd, input_section,
+ (PTR) &ext,
+ (file_ptr) 0,
+ sizeof ext))
+ return false;
+
+ bfd_mips_elf32_swap_reginfo_in (input_bfd, &ext, &sub);
+
+ reginfo.ri_gprmask |= sub.ri_gprmask;
+ reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
+ reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
+ reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
+ reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
+
+ /* ri_gp_value is set by the function
+ mips_elf_section_processing when the section is
+ finally written out. */
+ }
+
+ /* Force the section size to the value we want. */
+ o->_raw_size = sizeof (Elf32_External_RegInfo);
+
+ /* Skip this section later on. */
+ o->link_order_head = (struct bfd_link_order *) NULL;
+
+ reginfo_sec = o;
+ }
+
+ if (strcmp (o->name, ".mdebug") == 0)
+ {
+ /* We have found the .mdebug section in the output file.
+ Look through all the link_orders comprising it and merge
+ the information together. */
+ symhdr->magic = swap->sym_magic;
+ /* FIXME: What should the version stamp be? */
+ symhdr->vstamp = 0;
+ symhdr->ilineMax = 0;
+ symhdr->cbLine = 0;
+ symhdr->idnMax = 0;
+ symhdr->ipdMax = 0;
+ symhdr->isymMax = 0;
+ symhdr->ioptMax = 0;
+ symhdr->iauxMax = 0;
+ symhdr->issMax = 0;
+ symhdr->issExtMax = 0;
+ symhdr->ifdMax = 0;
+ symhdr->crfd = 0;
+ symhdr->iextMax = 0;
+
+ /* We accumulate the debugging information itself in the
+ debug_info structure. */
+ debug.line = debug.line_end = NULL;
+ debug.external_dnr = debug.external_dnr_end = NULL;
+ debug.external_pdr = debug.external_pdr_end = NULL;
+ debug.external_sym = debug.external_sym_end = NULL;
+ debug.external_opt = debug.external_opt_end = NULL;
+ debug.external_aux = debug.external_aux_end = NULL;
+ debug.ss = debug.ss_end = NULL;
+ debug.ssext = debug.ssext_end = NULL;
+ debug.external_fdr = debug.external_fdr_end = NULL;
+ debug.external_rfd = debug.external_rfd_end = NULL;
+ debug.external_ext = debug.external_ext_end = NULL;
+
+ for (p = o->link_order_head;
+ p != (struct bfd_link_order *) NULL;
+ p = p->next)
+ {
+ asection *input_section;
+ bfd *input_bfd;
+ const struct ecoff_debug_swap *input_swap;
+ struct ecoff_debug_info input_debug;
+
+ if (p->type != bfd_indirect_link_order)
+ continue;
+
+ input_section = p->u.indirect.section;
+ input_bfd = input_section->owner;
+
+ if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
+ || (get_elf_backend_data (input_bfd)
+ ->elf_backend_ecoff_debug_swap) == NULL)
{
- case bfd_indirect_seclet:
- {
- asection *input_section;
- bfd *input_bfd;
- Elf32_RegInfo sub;
-
- input_section = p->u.indirect.section;
- input_bfd = input_section->owner;
- BFD_ASSERT (input_section->_raw_size
- == sizeof (Elf32_External_RegInfo));
- if (! bfd_get_section_contents (input_bfd, input_section,
- (PTR) &ext,
- (file_ptr) 0,
- sizeof ext))
- return false;
-
- bfd_mips_elf32_swap_reginfo_in (input_bfd, &ext, &sub);
-
- reginfo.ri_gprmask |= sub.ri_gprmask;
- reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
- reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
- reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
- reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
-
- /* ri_gp_value is set by the function
- mips_elf_section_processing when the section is
- finally written out. */
- }
- break;
-
- default:
- break;
+ /* I don't know what a non MIPS ELF bfd would be
+ doing with a .mdebug section, but I don't really
+ want to deal with it. */
+ continue;
}
+
+ input_swap = (get_elf_backend_data (input_bfd)
+ ->elf_backend_ecoff_debug_swap);
+
+ BFD_ASSERT (p->size == input_section->_raw_size);
+
+ /* The ECOFF linking code expects that we have already
+ read in the debugging information and set up an
+ ecoff_debug_info structure, so we do that now. */
+ if (! mips_elf_read_ecoff_info (input_bfd, input_section,
+ &input_debug))
+ return false;
+
+ if (! (bfd_ecoff_debug_accumulate
+ (abfd, &debug, swap,
+ input_bfd, &input_debug, input_swap,
+ info->relocateable)))
+ return false;
+
+ /* Loop through the external symbols. For each one with
+ interesting information, try to find the symbol on
+ the symbol table of abfd and save the information in
+ order to put it into the final external symbols. */
+ if (info->hash->creator == input_bfd->xvec)
+ {
+ char *eraw_src;
+ char *eraw_end;
+
+ eraw_src = input_debug.external_ext;
+ eraw_end = (eraw_src
+ + (input_debug.symbolic_header.iextMax
+ * input_swap->external_ext_size));
+ for (;
+ eraw_src < eraw_end;
+ eraw_src += input_swap->external_ext_size)
+ {
+ EXTR ext;
+ const char *name;
+ struct generic_link_hash_entry *h;
+ elf_symbol_type *elf_sym;
+
+ (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src,
+ &ext);
+ if (ext.asym.sc == scNil
+ || ext.asym.sc == scUndefined
+ || ext.asym.sc == scSUndefined)
+ continue;
+
+ name = input_debug.ssext + ext.asym.iss;
+ h = ((struct generic_link_hash_entry *)
+ bfd_link_hash_lookup (info->hash, name, false,
+ false, true));
+ if (h == (struct generic_link_hash_entry *) NULL
+ || h->sym == (asymbol *) NULL)
+ continue;
+
+ elf_sym = (elf_symbol_type *) (h->sym);
+
+ if (elf_sym->tc_data.mips_extr != NULL)
+ continue;
+
+ elf_sym->tc_data.mips_extr =
+ (EXTR *) bfd_alloc (abfd, sizeof (EXTR));
+
+ ext.ifd += input_debug.ifdbase;
+ *elf_sym->tc_data.mips_extr = ext;
+ }
+ }
+
+ /* Free up the information we just read. */
+ free (input_debug.line);
+ free (input_debug.external_dnr);
+ free (input_debug.external_pdr);
+ free (input_debug.external_sym);
+ free (input_debug.external_opt);
+ free (input_debug.external_aux);
+ free (input_debug.ss);
+ free (input_debug.ssext);
+ free (input_debug.external_fdr);
+ free (input_debug.external_rfd);
+ free (input_debug.external_ext);
}
- /* Write out the information we have accumulated. */
- bfd_mips_elf32_swap_reginfo_out (abfd, ®info, &ext);
- if (! bfd_set_section_contents (abfd, sec, (PTR) &ext,
- (file_ptr) 0, sizeof ext))
+ /* Build the external symbol information. */
+ if (! bfd_ecoff_debug_externals (abfd, &debug, swap,
+ info->relocateable,
+ mips_elf_get_extr,
+ mips_elf_set_index))
return false;
- /* Force the section size to the value we want. */
- sec->_raw_size = sizeof (Elf32_External_RegInfo);
+ /* Set the size of the section. */
+ o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
+
+ /* Skip this section later on. */
+ o->link_order_head = (struct bfd_link_order *) NULL;
+
+ mdebug_sec = o;
+ }
+ }
+
+ if (info->relocateable)
+ {
+ /* Allocate space for the output relocs for each section. */
+ for (o = abfd->sections;
+ o != (asection *) NULL;
+ o = o->next)
+ {
+ o->reloc_count = 0;
+ for (p = o->link_order_head;
+ p != (struct bfd_link_order *) NULL;
+ p = p->next)
+ {
+ if (p->type == bfd_indirect_link_order)
+ {
+ asection *input_section;
+ bfd *input_bfd;
+ bfd_size_type relsize;
+ arelent **relocs;
+ bfd_size_type reloc_count;
+
+ input_section = p->u.indirect.section;
+ input_bfd = input_section->owner;
+ relsize = bfd_get_reloc_upper_bound (input_bfd,
+ input_section);
+ relocs = (arelent **) bfd_xmalloc (relsize);
+ reloc_count =
+ bfd_canonicalize_reloc (input_bfd, input_section,
+ relocs,
+ bfd_get_outsymbols (input_bfd));
+ BFD_ASSERT (reloc_count == input_section->reloc_count);
+ o->reloc_count += reloc_count;
+ free (relocs);
+ }
+ }
+ if (o->reloc_count > 0)
+ {
+ o->orelocation = ((arelent **)
+ bfd_alloc (abfd,
+ (o->reloc_count
+ * sizeof (arelent *))));
+ /* Reset the count so that it can be used as an index
+ when putting in the output relocs. */
+ o->reloc_count = 0;
+ }
+ }
+ }
- /* Force bfd_generic_seclet_link to ignore this section. */
- sec->seclets_head = (bfd_seclet_type *) NULL;
+ /* Write out the information we have accumulated. */
+ if (reginfo_sec != (asection *) NULL)
+ {
+ Elf32_External_RegInfo ext;
+
+ bfd_mips_elf32_swap_reginfo_out (abfd, ®info, &ext);
+ if (! bfd_set_section_contents (abfd, reginfo_sec, (PTR) &ext,
+ (file_ptr) 0, sizeof ext))
+ return false;
+ }
- break;
+ if (mdebug_sec != (asection *) NULL)
+ {
+ if (! abfd->output_has_begun)
+ {
+ /* Force the section to be given a file position. */
+ bfd_set_section_contents (abfd, mdebug_sec, (PTR) NULL,
+ (file_ptr) 0, (bfd_size_type) 0);
+ BFD_ASSERT (abfd->output_has_begun);
}
+ if (! bfd_ecoff_write_debug (abfd, &debug, swap, mdebug_sec->filepos))
+ return false;
}
- return bfd_generic_seclet_link (abfd, data, relocateable);
+ /* Handle all the link order information for the sections. */
+ for (o = abfd->sections;
+ o != (asection *) NULL;
+ o = o->next)
+ {
+ for (p = o->link_order_head;
+ p != (struct bfd_link_order *) NULL;
+ p = p->next)
+ {
+ if (! _bfd_default_link_order (abfd, info, o, p))
+ return false;
+ }
+ }
+
+ return true;
}
\f
/* MIPS ELF uses two common sections. One is the usual one, and the
static asymbol mips_elf_scom_symbol;
static asymbol *mips_elf_scom_symbol_ptr;
+/* MIPS ELF also uses an acommon section, which represents an
+ allocated common symbol which may be overridden by a
+ definition in a shared library. */
+static asection mips_elf_acom_section;
+static asymbol mips_elf_acom_symbol;
+static asymbol *mips_elf_acom_symbol_ptr;
+
/* Handle the special MIPS section numbers that a symbol may use. */
static void
switch (elfsym->internal_elf_sym.st_shndx)
{
case SHN_MIPS_ACOMMON:
- /* FIXME: I don't really understand just what this section
- means or when it would be used. */
- abort ();
+ /* This section is used in a dynamically linked executable file.
+ It is an allocated common section. The dynamic linker can
+ either resolve these symbols to something in a shared
+ library, or it can just leave them here. For our purposes,
+ we can consider these symbols to be in a new section. */
+ if (mips_elf_acom_section.name == NULL)
+ {
+ /* Initialize the acommon section. */
+ mips_elf_acom_section.name = ".acommon";
+ mips_elf_acom_section.flags = SEC_NO_FLAGS;
+ mips_elf_acom_section.output_section = &mips_elf_acom_section;
+ mips_elf_acom_section.symbol = &mips_elf_acom_symbol;
+ mips_elf_acom_section.symbol_ptr_ptr = &mips_elf_acom_symbol_ptr;
+ mips_elf_acom_symbol.name = ".acommon";
+ mips_elf_acom_symbol.flags = BSF_SECTION_SYM;
+ mips_elf_acom_symbol.section = &mips_elf_acom_section;
+ mips_elf_acom_symbol_ptr = &mips_elf_acom_symbol;
+ }
+ asym->section = &mips_elf_acom_section;
break;
case SHN_COMMON:
}
}
\f
+/* ECOFF swapping routines. These are used when dealing with the
+ .mdebug section, which is in the ECOFF debugging format. */
+static const struct ecoff_debug_swap mips_elf_ecoff_debug_swap =
+{
+ /* Symbol table magic number. */
+ magicSym,
+ /* Alignment of debugging information. E.g., 4. */
+ 4,
+ /* Sizes of external symbolic information. */
+ sizeof (struct hdr_ext),
+ sizeof (struct dnr_ext),
+ sizeof (struct pdr_ext),
+ sizeof (struct sym_ext),
+ sizeof (struct opt_ext),
+ sizeof (struct fdr_ext),
+ sizeof (struct rfd_ext),
+ sizeof (struct ext_ext),
+ /* Functions to swap in external symbolic data. */
+ ecoff_swap_hdr_in,
+ ecoff_swap_dnr_in,
+ ecoff_swap_pdr_in,
+ ecoff_swap_sym_in,
+ ecoff_swap_opt_in,
+ ecoff_swap_fdr_in,
+ ecoff_swap_rfd_in,
+ ecoff_swap_ext_in,
+ /* Functions to swap out external symbolic data. */
+ ecoff_swap_hdr_out,
+ ecoff_swap_dnr_out,
+ ecoff_swap_pdr_out,
+ ecoff_swap_sym_out,
+ ecoff_swap_opt_out,
+ ecoff_swap_fdr_out,
+ ecoff_swap_rfd_out,
+ ecoff_swap_ext_out
+};
+\f
#define TARGET_LITTLE_SYM bfd_elf32_littlemips_vec
#define TARGET_LITTLE_NAME "elf32-littlemips"
#define TARGET_BIG_SYM bfd_elf32_bigmips_vec
#define TARGET_BIG_NAME "elf32-bigmips"
#define ELF_ARCH bfd_arch_mips
+#define ELF_MACHINE_CODE EM_MIPS
#define ELF_MAXPAGESIZE 0x10000
#define elf_info_to_howto 0
#define elf_info_to_howto_rel mips_info_to_howto_rel
+#define elf_backend_sym_is_global mips_elf_sym_is_global
+#define elf_backend_object_p mips_elf_object_p
#define elf_backend_section_from_shdr mips_elf_section_from_shdr
#define elf_backend_fake_sections mips_elf_fake_sections
#define elf_backend_section_from_bfd_section \
mips_elf_section_from_bfd_section
#define elf_backend_section_processing mips_elf_section_processing
#define elf_backend_symbol_processing mips_elf_symbol_processing
+#define elf_backend_final_write_processing \
+ mips_elf_final_write_processing
+#define elf_backend_ecoff_debug_swap &mips_elf_ecoff_debug_swap
-#define bfd_elf32_bfd_seclet_link mips_elf_seclet_link
+#define bfd_elf32_bfd_final_link mips_elf_final_link
#include "elf32-target.h"
static boolean default_fill_link_order
PARAMS ((bfd *, struct bfd_link_info *, asection *,
struct bfd_link_order *));
+static boolean default_indirect_link_order
+ PARAMS ((bfd *, struct bfd_link_info *, asection *,
+ struct bfd_link_order *));
/* The link hash table structure is defined in bfdlink.h. It provides
a base hash table which the backend specific hash tables are built
the object file. This is how a.out works. Object
formats that require different semantics must implement
this function differently. This symbol is already on the
- undefs list. */
+ undefs list. We add the section to a common section
+ attached to symbfd to ensure that it is in a BFD which
+ will be linked in. */
h->type = bfd_link_hash_common;
h->u.c.size = bfd_asymbol_value (p);
- h->u.c.section = bfd_make_section_old_way (symbfd,
- "COMMON");
+ if (p->section == &bfd_com_section)
+ h->u.c.section = bfd_make_section_old_way (symbfd, "COMMON");
+ else
+ h->u.c.section = bfd_make_section_old_way (symbfd,
+ p->section->name);
}
else
{
}
else
string = NULL;
+
+ /* We pass the constructor argument as false, for
+ compatibility. As backends are converted they can
+ arrange to pass the right value (the right value is the
+ size of a function pointer if gcc uses collect2 for the
+ object file format, zero if it does not).
+ FIXME: We pass the bitsize as 32, which is just plain
+ wrong, but actually doesn't matter very much. */
if (! (_bfd_generic_link_add_one_symbol
(info, abfd, name, p->flags, bfd_get_section (p),
- p->value, string, false,
+ p->value, string, false, 0, 32,
(struct bfd_link_hash_entry **) &h)))
return false;
which case it is the warning string.
COPY is true if NAME or STRING must be copied into locally
allocated memory if they need to be saved.
+ CONSTRUCTOR is true if we should automatically collect gcc
+ constructor or destructor names.
+ BITSIZE is the number of bits in constructor or set entries.
HASHP, if not NULL, is a place to store the created hash table
entry. */
boolean
_bfd_generic_link_add_one_symbol (info, abfd, name, flags, section, value,
- string, copy, hashp)
+ string, copy, constructor, bitsize, hashp)
struct bfd_link_info *info;
bfd *abfd;
const char *name;
bfd_vma value;
const char *string;
boolean copy;
+ boolean constructor;
+ unsigned int bitsize;
struct bfd_link_hash_entry **hashp;
{
enum link_row row;
h->type = bfd_link_hash_defined;
h->u.def.section = section;
h->u.def.value = value;
+
+ /* If we have been asked to, we act like collect2 and
+ identify all functions that might be global constructors
+ and destructors and pass them up in a callback. We only
+ do this for certain object file types, since many object
+ file types can handle this automatically. */
+ if (constructor && name[0] == '_')
+ {
+ const char *s;
+
+ /* A constructor or destructor name starts like this:
+ _+GLOBAL_[_.$][ID][_.$]
+ where the first [_.$] and the second are the same
+ character (we accept any character there, in case a
+ new object file format comes along with even worse
+ naming restrictions). */
+
+#define CONS_PREFIX "GLOBAL_"
+#define CONS_PREFIX_LEN (sizeof CONS_PREFIX - 1)
+
+ s = name + 1;
+ while (*s == '_')
+ ++s;
+ if (s[0] == 'G'
+ && strncmp (s, CONS_PREFIX, CONS_PREFIX_LEN - 1) == 0)
+ {
+ char c;
+
+ c = s[CONS_PREFIX_LEN + 1];
+ if ((c == 'I' || c == 'D')
+ && s[CONS_PREFIX_LEN] == s[CONS_PREFIX_LEN + 2])
+ {
+ if (! ((*info->callbacks->constructor)
+ (info,
+ c == 'I' ? true : false, bitsize,
+ name, abfd, section, value)))
+ return false;
+ }
+ }
+ }
+
break;
case COM:
if (h->type == bfd_link_hash_new)
return false;
if (value > h->u.c.size)
h->u.c.size = value;
- if (h->u.c.section == (asection *) NULL)
- h->u.c.section = bfd_make_section_old_way (abfd, "COMMON");
break;
case CREF:
BFD_ASSERT (h->type == bfd_link_hash_defined);
}
break;
case SET:
- if (! (*info->callbacks->add_to_set) (info, h, abfd, section, value))
+ if (! (*info->callbacks->add_to_set) (info, h, bitsize, abfd,
+ section, value))
return false;
break;
case WARN:
p != (struct bfd_link_order *) NULL;
p = p->next)
{
- switch (p->type)
- {
- case bfd_indirect_link_order:
- if (! _bfd_generic_indirect_link_order (abfd, info, o, p))
- return false;
- break;
- default:
- if (! _bfd_default_link_order (abfd, info, o, p))
- return false;
- break;
- }
+ if (! _bfd_default_link_order (abfd, info, o, p))
+ return false;
}
}
return true;
}
-
-/* Handle an indirect section when doing a generic link. */
-
-boolean
-_bfd_generic_indirect_link_order (output_bfd, info, output_section, link_order)
- bfd *output_bfd;
- struct bfd_link_info *info;
- asection *output_section;
- struct bfd_link_order *link_order;
-{
- asection *input_section;
- bfd *input_bfd;
- bfd_byte *contents;
-
- BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0);
-
- if (link_order->size == 0)
- return true;
-
- input_section = link_order->u.indirect.section;
- input_bfd = input_section->owner;
-
- BFD_ASSERT (input_section->output_section == output_section);
- BFD_ASSERT (input_section->output_offset == link_order->offset);
- BFD_ASSERT (bfd_section_size (input_bfd, input_section) == link_order->size);
-
- /* Get and relocate the section contents. */
- contents = (bfd_byte *) alloca (bfd_section_size (input_bfd, input_section));
- contents = (bfd_get_relocated_section_contents
- (output_bfd, info, link_order, contents, info->relocateable,
- bfd_get_outsymbols (input_bfd)));
-
- /* Output the section contents. */
- if (! bfd_set_section_contents (output_bfd, output_section, contents,
- link_order->offset, link_order->size))
- return false;
-
- return true;
-}
\f
/* Allocate a new link_order for a section. */
default:
abort ();
case bfd_indirect_link_order:
- abort ();
+ return default_indirect_link_order (abfd, info, sec, link_order);
case bfd_fill_link_order:
return default_fill_link_order (abfd, info, sec, link_order);
}
/* Default routine to handle a bfd_fill_link_order. */
+/*ARGSUSED*/
static boolean
default_fill_link_order (abfd, info, sec, link_order)
bfd *abfd;
(file_ptr) link_order->offset,
link_order->size);
}
+
+/* Default routine to handle a bfd_indirect_link_order. */
+
+static boolean
+default_indirect_link_order (output_bfd, info, output_section, link_order)
+ bfd *output_bfd;
+ struct bfd_link_info *info;
+ asection *output_section;
+ struct bfd_link_order *link_order;
+{
+ asection *input_section;
+ bfd *input_bfd;
+ bfd_byte *contents;
+
+ BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0);
+
+ if (link_order->size == 0)
+ return true;
+
+ input_section = link_order->u.indirect.section;
+ input_bfd = input_section->owner;
+
+ BFD_ASSERT (input_section->output_section == output_section);
+ BFD_ASSERT (input_section->output_offset == link_order->offset);
+ BFD_ASSERT (bfd_section_size (input_bfd, input_section) == link_order->size);
+
+ if (info->relocateable
+ && output_section->orelocation == (arelent **) NULL)
+ {
+ /* Space has not been allocated for the output relocations.
+ This can happen when we are called by a specific backend
+ because somebody is attempting to link together different
+ types of object files. Handling this case correctly is
+ difficult, and sometimes impossible. */
+ abort ();
+ }
+
+ /* Get the canonical symbols. The generic linker will always have
+ retrieved them by this point, but we may be being called by a
+ specific linker when linking different types of object files
+ together. */
+ if (bfd_get_outsymbols (input_bfd) == (asymbol **) NULL)
+ {
+ size_t symsize;
+
+ symsize = get_symtab_upper_bound (input_bfd);
+ input_bfd->outsymbols = (asymbol **) bfd_alloc (input_bfd, symsize);
+ input_bfd->symcount = bfd_canonicalize_symtab (input_bfd,
+ input_bfd->outsymbols);
+ }
+
+ /* Get and relocate the section contents. */
+ contents = (bfd_byte *) alloca (bfd_section_size (input_bfd, input_section));
+ contents = (bfd_get_relocated_section_contents
+ (output_bfd, info, link_order, contents, info->relocateable,
+ bfd_get_outsymbols (input_bfd)));
+
+ /* Output the section contents. */
+ if (! bfd_set_section_contents (output_bfd, output_section, (PTR) contents,
+ link_order->offset, link_order->size))
+ return false;
+
+ return true;
+}
projects / binutils-gdb.git / commitdiff