0,0 → 1,3196 |
/* COFF specific linker code. |
Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, |
2004, 2005, 2006, 2007, 2008, 2009, 2011 Free Software Foundation, Inc. |
Written by Ian Lance Taylor, Cygnus Support. |
|
This file is part of BFD, the Binary File Descriptor library. |
|
This program is free software; you can redistribute it and/or modify |
it under the terms of the GNU General Public License as published by |
the Free Software Foundation; either version 3 of the License, or |
(at your option) any later version. |
|
This program is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
GNU General Public License for more details. |
|
You should have received a copy of the GNU General Public License |
along with this program; if not, write to the Free Software |
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, |
MA 02110-1301, USA. */ |
|
/* This file contains the COFF backend linker code. */ |
|
#include "sysdep.h" |
#include "bfd.h" |
#include "bfdlink.h" |
#include "libbfd.h" |
#include "coff/internal.h" |
#include "libcoff.h" |
#include "safe-ctype.h" |
|
static bfd_boolean coff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info); |
static bfd_boolean coff_link_check_archive_element (bfd *abfd, struct bfd_link_info *info, bfd_boolean *pneeded); |
static bfd_boolean coff_link_add_symbols (bfd *abfd, struct bfd_link_info *info); |
|
/* Return TRUE if SYM is a weak, external symbol. */ |
#define IS_WEAK_EXTERNAL(abfd, sym) \ |
((sym).n_sclass == C_WEAKEXT \ |
|| (obj_pe (abfd) && (sym).n_sclass == C_NT_WEAK)) |
|
/* Return TRUE if SYM is an external symbol. */ |
#define IS_EXTERNAL(abfd, sym) \ |
((sym).n_sclass == C_EXT || IS_WEAK_EXTERNAL (abfd, sym)) |
|
/* Define macros so that the ISFCN, et. al., macros work correctly. |
These macros are defined in include/coff/internal.h in terms of |
N_TMASK, etc. These definitions require a user to define local |
variables with the appropriate names, and with values from the |
coff_data (abfd) structure. */ |
|
#define N_TMASK n_tmask |
#define N_BTSHFT n_btshft |
#define N_BTMASK n_btmask |
|
/* Create an entry in a COFF linker hash table. */ |
|
struct bfd_hash_entry * |
_bfd_coff_link_hash_newfunc (struct bfd_hash_entry *entry, |
struct bfd_hash_table *table, |
const char *string) |
{ |
struct coff_link_hash_entry *ret = (struct coff_link_hash_entry *) entry; |
|
/* Allocate the structure if it has not already been allocated by a |
subclass. */ |
if (ret == (struct coff_link_hash_entry *) NULL) |
ret = ((struct coff_link_hash_entry *) |
bfd_hash_allocate (table, sizeof (struct coff_link_hash_entry))); |
if (ret == (struct coff_link_hash_entry *) NULL) |
return (struct bfd_hash_entry *) ret; |
|
/* Call the allocation method of the superclass. */ |
ret = ((struct coff_link_hash_entry *) |
_bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret, |
table, string)); |
if (ret != (struct coff_link_hash_entry *) NULL) |
{ |
/* Set local fields. */ |
ret->indx = -1; |
ret->type = T_NULL; |
ret->symbol_class = C_NULL; |
ret->numaux = 0; |
ret->auxbfd = NULL; |
ret->aux = NULL; |
} |
|
return (struct bfd_hash_entry *) ret; |
} |
|
/* Initialize a COFF linker hash table. */ |
|
bfd_boolean |
_bfd_coff_link_hash_table_init (struct coff_link_hash_table *table, |
bfd *abfd, |
struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *, |
struct bfd_hash_table *, |
const char *), |
unsigned int entsize) |
{ |
memset (&table->stab_info, 0, sizeof (table->stab_info)); |
return _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize); |
} |
|
/* Create a COFF linker hash table. */ |
|
struct bfd_link_hash_table * |
_bfd_coff_link_hash_table_create (bfd *abfd) |
{ |
struct coff_link_hash_table *ret; |
bfd_size_type amt = sizeof (struct coff_link_hash_table); |
|
ret = (struct coff_link_hash_table *) bfd_malloc (amt); |
if (ret == NULL) |
return NULL; |
|
if (! _bfd_coff_link_hash_table_init (ret, abfd, |
_bfd_coff_link_hash_newfunc, |
sizeof (struct coff_link_hash_entry))) |
{ |
free (ret); |
return (struct bfd_link_hash_table *) NULL; |
} |
return &ret->root; |
} |
|
/* Create an entry in a COFF debug merge hash table. */ |
|
struct bfd_hash_entry * |
_bfd_coff_debug_merge_hash_newfunc (struct bfd_hash_entry *entry, |
struct bfd_hash_table *table, |
const char *string) |
{ |
struct coff_debug_merge_hash_entry *ret = |
(struct coff_debug_merge_hash_entry *) entry; |
|
/* Allocate the structure if it has not already been allocated by a |
subclass. */ |
if (ret == (struct coff_debug_merge_hash_entry *) NULL) |
ret = ((struct coff_debug_merge_hash_entry *) |
bfd_hash_allocate (table, |
sizeof (struct coff_debug_merge_hash_entry))); |
if (ret == (struct coff_debug_merge_hash_entry *) NULL) |
return (struct bfd_hash_entry *) ret; |
|
/* Call the allocation method of the superclass. */ |
ret = ((struct coff_debug_merge_hash_entry *) |
bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string)); |
if (ret != (struct coff_debug_merge_hash_entry *) NULL) |
{ |
/* Set local fields. */ |
ret->types = NULL; |
} |
|
return (struct bfd_hash_entry *) ret; |
} |
|
/* Given a COFF BFD, add symbols to the global hash table as |
appropriate. */ |
|
bfd_boolean |
_bfd_coff_link_add_symbols (bfd *abfd, struct bfd_link_info *info) |
{ |
switch (bfd_get_format (abfd)) |
{ |
case bfd_object: |
return coff_link_add_object_symbols (abfd, info); |
case bfd_archive: |
return _bfd_generic_link_add_archive_symbols |
(abfd, info, coff_link_check_archive_element); |
default: |
bfd_set_error (bfd_error_wrong_format); |
return FALSE; |
} |
} |
|
/* Add symbols from a COFF object file. */ |
|
static bfd_boolean |
coff_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info) |
{ |
if (! _bfd_coff_get_external_symbols (abfd)) |
return FALSE; |
if (! coff_link_add_symbols (abfd, info)) |
return FALSE; |
|
if (! info->keep_memory |
&& ! _bfd_coff_free_symbols (abfd)) |
return FALSE; |
|
return TRUE; |
} |
|
/* Look through the symbols to see if this object file should be |
included in the link. */ |
|
static bfd_boolean |
coff_link_check_ar_symbols (bfd *abfd, |
struct bfd_link_info *info, |
bfd_boolean *pneeded, |
bfd **subsbfd) |
{ |
bfd_size_type symesz; |
bfd_byte *esym; |
bfd_byte *esym_end; |
|
*pneeded = FALSE; |
|
symesz = bfd_coff_symesz (abfd); |
esym = (bfd_byte *) obj_coff_external_syms (abfd); |
esym_end = esym + obj_raw_syment_count (abfd) * symesz; |
while (esym < esym_end) |
{ |
struct internal_syment sym; |
enum coff_symbol_classification classification; |
|
bfd_coff_swap_sym_in (abfd, esym, &sym); |
|
classification = bfd_coff_classify_symbol (abfd, &sym); |
if (classification == COFF_SYMBOL_GLOBAL |
|| classification == COFF_SYMBOL_COMMON) |
{ |
const char *name; |
char buf[SYMNMLEN + 1]; |
struct bfd_link_hash_entry *h; |
|
/* This symbol is externally visible, and is defined by this |
object file. */ |
name = _bfd_coff_internal_syment_name (abfd, &sym, buf); |
if (name == NULL) |
return FALSE; |
h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE); |
|
/* Auto import. */ |
if (!h |
&& info->pei386_auto_import |
&& CONST_STRNEQ (name, "__imp_")) |
h = bfd_link_hash_lookup (info->hash, name + 6, FALSE, FALSE, TRUE); |
|
/* We are only interested in symbols that are currently |
undefined. If a symbol is currently known to be common, |
COFF linkers do not bring in an object file which defines |
it. */ |
if (h != (struct bfd_link_hash_entry *) NULL |
&& h->type == bfd_link_hash_undefined) |
{ |
if (!(*info->callbacks |
->add_archive_element) (info, abfd, name, subsbfd)) |
return FALSE; |
*pneeded = TRUE; |
return TRUE; |
} |
} |
|
esym += (sym.n_numaux + 1) * symesz; |
} |
|
/* We do not need this object file. */ |
return TRUE; |
} |
|
/* Check a single archive element to see if we need to include it in |
the link. *PNEEDED is set according to whether this element is |
needed in the link or not. This is called via |
_bfd_generic_link_add_archive_symbols. */ |
|
static bfd_boolean |
coff_link_check_archive_element (bfd *abfd, |
struct bfd_link_info *info, |
bfd_boolean *pneeded) |
{ |
bfd *oldbfd; |
bfd_boolean needed; |
|
if (!_bfd_coff_get_external_symbols (abfd)) |
return FALSE; |
|
oldbfd = abfd; |
if (!coff_link_check_ar_symbols (abfd, info, pneeded, &abfd)) |
return FALSE; |
|
needed = *pneeded; |
if (needed) |
{ |
/* Potentially, the add_archive_element hook may have set a |
substitute BFD for us. */ |
if (abfd != oldbfd) |
{ |
if (!info->keep_memory |
&& !_bfd_coff_free_symbols (oldbfd)) |
return FALSE; |
if (!_bfd_coff_get_external_symbols (abfd)) |
return FALSE; |
} |
if (!coff_link_add_symbols (abfd, info)) |
return FALSE; |
} |
|
if (!info->keep_memory || !needed) |
{ |
if (!_bfd_coff_free_symbols (abfd)) |
return FALSE; |
} |
return TRUE; |
} |
|
/* Add all the symbols from an object file to the hash table. */ |
|
static bfd_boolean |
coff_link_add_symbols (bfd *abfd, |
struct bfd_link_info *info) |
{ |
unsigned int n_tmask = coff_data (abfd)->local_n_tmask; |
unsigned int n_btshft = coff_data (abfd)->local_n_btshft; |
unsigned int n_btmask = coff_data (abfd)->local_n_btmask; |
bfd_boolean keep_syms; |
bfd_boolean default_copy; |
bfd_size_type symcount; |
struct coff_link_hash_entry **sym_hash; |
bfd_size_type symesz; |
bfd_byte *esym; |
bfd_byte *esym_end; |
bfd_size_type amt; |
|
symcount = obj_raw_syment_count (abfd); |
|
if (symcount == 0) |
return TRUE; /* Nothing to do. */ |
|
/* Keep the symbols during this function, in case the linker needs |
to read the generic symbols in order to report an error message. */ |
keep_syms = obj_coff_keep_syms (abfd); |
obj_coff_keep_syms (abfd) = TRUE; |
|
if (info->keep_memory) |
default_copy = FALSE; |
else |
default_copy = TRUE; |
|
/* We keep a list of the linker hash table entries that correspond |
to particular symbols. */ |
amt = symcount * sizeof (struct coff_link_hash_entry *); |
sym_hash = (struct coff_link_hash_entry **) bfd_zalloc (abfd, amt); |
if (sym_hash == NULL) |
goto error_return; |
obj_coff_sym_hashes (abfd) = sym_hash; |
|
symesz = bfd_coff_symesz (abfd); |
BFD_ASSERT (symesz == bfd_coff_auxesz (abfd)); |
esym = (bfd_byte *) obj_coff_external_syms (abfd); |
esym_end = esym + symcount * symesz; |
while (esym < esym_end) |
{ |
struct internal_syment sym; |
enum coff_symbol_classification classification; |
bfd_boolean copy; |
|
bfd_coff_swap_sym_in (abfd, esym, &sym); |
|
classification = bfd_coff_classify_symbol (abfd, &sym); |
if (classification != COFF_SYMBOL_LOCAL) |
{ |
const char *name; |
char buf[SYMNMLEN + 1]; |
flagword flags; |
asection *section; |
bfd_vma value; |
bfd_boolean addit; |
|
/* This symbol is externally visible. */ |
|
name = _bfd_coff_internal_syment_name (abfd, &sym, buf); |
if (name == NULL) |
goto error_return; |
|
/* We must copy the name into memory if we got it from the |
syment itself, rather than the string table. */ |
copy = default_copy; |
if (sym._n._n_n._n_zeroes != 0 |
|| sym._n._n_n._n_offset == 0) |
copy = TRUE; |
|
value = sym.n_value; |
|
switch (classification) |
{ |
default: |
abort (); |
|
case COFF_SYMBOL_GLOBAL: |
flags = BSF_EXPORT | BSF_GLOBAL; |
section = coff_section_from_bfd_index (abfd, sym.n_scnum); |
if (! obj_pe (abfd)) |
value -= section->vma; |
break; |
|
case COFF_SYMBOL_UNDEFINED: |
flags = 0; |
section = bfd_und_section_ptr; |
break; |
|
case COFF_SYMBOL_COMMON: |
flags = BSF_GLOBAL; |
section = bfd_com_section_ptr; |
break; |
|
case COFF_SYMBOL_PE_SECTION: |
flags = BSF_SECTION_SYM | BSF_GLOBAL; |
section = coff_section_from_bfd_index (abfd, sym.n_scnum); |
break; |
} |
|
if (IS_WEAK_EXTERNAL (abfd, sym)) |
flags = BSF_WEAK; |
|
addit = TRUE; |
|
/* In the PE format, section symbols actually refer to the |
start of the output section. We handle them specially |
here. */ |
if (obj_pe (abfd) && (flags & BSF_SECTION_SYM) != 0) |
{ |
*sym_hash = coff_link_hash_lookup (coff_hash_table (info), |
name, FALSE, copy, FALSE); |
if (*sym_hash != NULL) |
{ |
if (((*sym_hash)->coff_link_hash_flags |
& COFF_LINK_HASH_PE_SECTION_SYMBOL) == 0 |
&& (*sym_hash)->root.type != bfd_link_hash_undefined |
&& (*sym_hash)->root.type != bfd_link_hash_undefweak) |
(*_bfd_error_handler) |
("Warning: symbol `%s' is both section and non-section", |
name); |
|
addit = FALSE; |
} |
} |
|
/* The Microsoft Visual C compiler does string pooling by |
hashing the constants to an internal symbol name, and |
relying on the linker comdat support to discard |
duplicate names. However, if one string is a literal and |
one is a data initializer, one will end up in the .data |
section and one will end up in the .rdata section. The |
Microsoft linker will combine them into the .data |
section, which seems to be wrong since it might cause the |
literal to change. |
|
As long as there are no external references to the |
symbols, which there shouldn't be, we can treat the .data |
and .rdata instances as separate symbols. The comdat |
code in the linker will do the appropriate merging. Here |
we avoid getting a multiple definition error for one of |
these special symbols. |
|
FIXME: I don't think this will work in the case where |
there are two object files which use the constants as a |
literal and two object files which use it as a data |
initializer. One or the other of the second object files |
is going to wind up with an inappropriate reference. */ |
if (obj_pe (abfd) |
&& (classification == COFF_SYMBOL_GLOBAL |
|| classification == COFF_SYMBOL_PE_SECTION) |
&& coff_section_data (abfd, section) != NULL |
&& coff_section_data (abfd, section)->comdat != NULL |
&& CONST_STRNEQ (name, "??_") |
&& strcmp (name, coff_section_data (abfd, section)->comdat->name) == 0) |
{ |
if (*sym_hash == NULL) |
*sym_hash = coff_link_hash_lookup (coff_hash_table (info), |
name, FALSE, copy, FALSE); |
if (*sym_hash != NULL |
&& (*sym_hash)->root.type == bfd_link_hash_defined |
&& coff_section_data (abfd, (*sym_hash)->root.u.def.section)->comdat != NULL |
&& strcmp (coff_section_data (abfd, (*sym_hash)->root.u.def.section)->comdat->name, |
coff_section_data (abfd, section)->comdat->name) == 0) |
addit = FALSE; |
} |
|
if (addit) |
{ |
if (! (bfd_coff_link_add_one_symbol |
(info, abfd, name, flags, section, value, |
(const char *) NULL, copy, FALSE, |
(struct bfd_link_hash_entry **) sym_hash))) |
goto error_return; |
} |
|
if (obj_pe (abfd) && (flags & BSF_SECTION_SYM) != 0) |
(*sym_hash)->coff_link_hash_flags |= |
COFF_LINK_HASH_PE_SECTION_SYMBOL; |
|
/* Limit the alignment of a common symbol to the possible |
alignment of a section. There is no point to permitting |
a higher alignment for a common symbol: we can not |
guarantee it, and it may cause us to allocate extra space |
in the common section. */ |
if (section == bfd_com_section_ptr |
&& (*sym_hash)->root.type == bfd_link_hash_common |
&& ((*sym_hash)->root.u.c.p->alignment_power |
> bfd_coff_default_section_alignment_power (abfd))) |
(*sym_hash)->root.u.c.p->alignment_power |
= bfd_coff_default_section_alignment_power (abfd); |
|
if (bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd)) |
{ |
/* If we don't have any symbol information currently in |
the hash table, or if we are looking at a symbol |
definition, then update the symbol class and type in |
the hash table. */ |
if (((*sym_hash)->symbol_class == C_NULL |
&& (*sym_hash)->type == T_NULL) |
|| sym.n_scnum != 0 |
|| (sym.n_value != 0 |
&& (*sym_hash)->root.type != bfd_link_hash_defined |
&& (*sym_hash)->root.type != bfd_link_hash_defweak)) |
{ |
(*sym_hash)->symbol_class = sym.n_sclass; |
if (sym.n_type != T_NULL) |
{ |
/* We want to warn if the type changed, but not |
if it changed from an unspecified type. |
Testing the whole type byte may work, but the |
change from (e.g.) a function of unspecified |
type to function of known type also wants to |
skip the warning. */ |
if ((*sym_hash)->type != T_NULL |
&& (*sym_hash)->type != sym.n_type |
&& !(DTYPE ((*sym_hash)->type) == DTYPE (sym.n_type) |
&& (BTYPE ((*sym_hash)->type) == T_NULL |
|| BTYPE (sym.n_type) == T_NULL))) |
(*_bfd_error_handler) |
(_("Warning: type of symbol `%s' changed from %d to %d in %B"), |
abfd, name, (*sym_hash)->type, sym.n_type); |
|
/* We don't want to change from a meaningful |
base type to a null one, but if we know |
nothing, take what little we might now know. */ |
if (BTYPE (sym.n_type) != T_NULL |
|| (*sym_hash)->type == T_NULL) |
(*sym_hash)->type = sym.n_type; |
} |
(*sym_hash)->auxbfd = abfd; |
if (sym.n_numaux != 0) |
{ |
union internal_auxent *alloc; |
unsigned int i; |
bfd_byte *eaux; |
union internal_auxent *iaux; |
|
(*sym_hash)->numaux = sym.n_numaux; |
alloc = ((union internal_auxent *) |
bfd_hash_allocate (&info->hash->table, |
(sym.n_numaux |
* sizeof (*alloc)))); |
if (alloc == NULL) |
goto error_return; |
for (i = 0, eaux = esym + symesz, iaux = alloc; |
i < sym.n_numaux; |
i++, eaux += symesz, iaux++) |
bfd_coff_swap_aux_in (abfd, eaux, sym.n_type, |
sym.n_sclass, (int) i, |
sym.n_numaux, iaux); |
(*sym_hash)->aux = alloc; |
} |
} |
} |
|
if (classification == COFF_SYMBOL_PE_SECTION |
&& (*sym_hash)->numaux != 0) |
{ |
/* Some PE sections (such as .bss) have a zero size in |
the section header, but a non-zero size in the AUX |
record. Correct that here. |
|
FIXME: This is not at all the right place to do this. |
For example, it won't help objdump. This needs to be |
done when we swap in the section header. */ |
BFD_ASSERT ((*sym_hash)->numaux == 1); |
if (section->size == 0) |
section->size = (*sym_hash)->aux[0].x_scn.x_scnlen; |
|
/* FIXME: We could test whether the section sizes |
matches the size in the aux entry, but apparently |
that sometimes fails unexpectedly. */ |
} |
} |
|
esym += (sym.n_numaux + 1) * symesz; |
sym_hash += sym.n_numaux + 1; |
} |
|
/* If this is a non-traditional, non-relocatable link, try to |
optimize the handling of any .stab/.stabstr sections. */ |
if (! info->relocatable |
&& ! info->traditional_format |
&& bfd_get_flavour (info->output_bfd) == bfd_get_flavour (abfd) |
&& (info->strip != strip_all && info->strip != strip_debugger)) |
{ |
asection *stabstr; |
|
stabstr = bfd_get_section_by_name (abfd, ".stabstr"); |
|
if (stabstr != NULL) |
{ |
bfd_size_type string_offset = 0; |
asection *stab; |
|
for (stab = abfd->sections; stab; stab = stab->next) |
if (CONST_STRNEQ (stab->name, ".stab") |
&& (!stab->name[5] |
|| (stab->name[5] == '.' && ISDIGIT (stab->name[6])))) |
{ |
struct coff_link_hash_table *table; |
struct coff_section_tdata *secdata |
= coff_section_data (abfd, stab); |
|
if (secdata == NULL) |
{ |
amt = sizeof (struct coff_section_tdata); |
stab->used_by_bfd = bfd_zalloc (abfd, amt); |
if (stab->used_by_bfd == NULL) |
goto error_return; |
secdata = coff_section_data (abfd, stab); |
} |
|
table = coff_hash_table (info); |
|
if (! _bfd_link_section_stabs (abfd, &table->stab_info, |
stab, stabstr, |
&secdata->stab_info, |
&string_offset)) |
goto error_return; |
} |
} |
} |
|
obj_coff_keep_syms (abfd) = keep_syms; |
|
return TRUE; |
|
error_return: |
obj_coff_keep_syms (abfd) = keep_syms; |
return FALSE; |
} |
|
/* Do the final link step. */ |
|
bfd_boolean |
_bfd_coff_final_link (bfd *abfd, |
struct bfd_link_info *info) |
{ |
bfd_size_type symesz; |
struct coff_final_link_info flaginfo; |
bfd_boolean debug_merge_allocated; |
bfd_boolean long_section_names; |
asection *o; |
struct bfd_link_order *p; |
bfd_size_type max_sym_count; |
bfd_size_type max_lineno_count; |
bfd_size_type max_reloc_count; |
bfd_size_type max_output_reloc_count; |
bfd_size_type max_contents_size; |
file_ptr rel_filepos; |
unsigned int relsz; |
file_ptr line_filepos; |
unsigned int linesz; |
bfd *sub; |
bfd_byte *external_relocs = NULL; |
char strbuf[STRING_SIZE_SIZE]; |
bfd_size_type amt; |
|
symesz = bfd_coff_symesz (abfd); |
|
flaginfo.info = info; |
flaginfo.output_bfd = abfd; |
flaginfo.strtab = NULL; |
flaginfo.section_info = NULL; |
flaginfo.last_file_index = -1; |
flaginfo.last_bf_index = -1; |
flaginfo.internal_syms = NULL; |
flaginfo.sec_ptrs = NULL; |
flaginfo.sym_indices = NULL; |
flaginfo.outsyms = NULL; |
flaginfo.linenos = NULL; |
flaginfo.contents = NULL; |
flaginfo.external_relocs = NULL; |
flaginfo.internal_relocs = NULL; |
flaginfo.global_to_static = FALSE; |
debug_merge_allocated = FALSE; |
|
coff_data (abfd)->link_info = info; |
|
flaginfo.strtab = _bfd_stringtab_init (); |
if (flaginfo.strtab == NULL) |
goto error_return; |
|
if (! coff_debug_merge_hash_table_init (&flaginfo.debug_merge)) |
goto error_return; |
debug_merge_allocated = TRUE; |
|
/* Compute the file positions for all the sections. */ |
if (! abfd->output_has_begun) |
{ |
if (! bfd_coff_compute_section_file_positions (abfd)) |
goto error_return; |
} |
|
/* Count the line numbers and relocation entries required for the |
output file. Set the file positions for the relocs. */ |
rel_filepos = obj_relocbase (abfd); |
relsz = bfd_coff_relsz (abfd); |
max_contents_size = 0; |
max_lineno_count = 0; |
max_reloc_count = 0; |
|
long_section_names = FALSE; |
for (o = abfd->sections; o != NULL; o = o->next) |
{ |
o->reloc_count = 0; |
o->lineno_count = 0; |
for (p = o->map_head.link_order; p != NULL; p = p->next) |
{ |
if (p->type == bfd_indirect_link_order) |
{ |
asection *sec; |
|
sec = p->u.indirect.section; |
|
/* Mark all sections which are to be included in the |
link. This will normally be every section. We need |
to do this so that we can identify any sections which |
the linker has decided to not include. */ |
sec->linker_mark = TRUE; |
|
if (info->strip == strip_none |
|| info->strip == strip_some) |
o->lineno_count += sec->lineno_count; |
|
if (info->relocatable) |
o->reloc_count += sec->reloc_count; |
|
if (sec->rawsize > max_contents_size) |
max_contents_size = sec->rawsize; |
if (sec->size > max_contents_size) |
max_contents_size = sec->size; |
if (sec->lineno_count > max_lineno_count) |
max_lineno_count = sec->lineno_count; |
if (sec->reloc_count > max_reloc_count) |
max_reloc_count = sec->reloc_count; |
} |
else if (info->relocatable |
&& (p->type == bfd_section_reloc_link_order |
|| p->type == bfd_symbol_reloc_link_order)) |
++o->reloc_count; |
} |
if (o->reloc_count == 0) |
o->rel_filepos = 0; |
else |
{ |
o->flags |= SEC_RELOC; |
o->rel_filepos = rel_filepos; |
rel_filepos += o->reloc_count * relsz; |
/* In PE COFF, if there are at least 0xffff relocations an |
extra relocation will be written out to encode the count. */ |
if (obj_pe (abfd) && o->reloc_count >= 0xffff) |
rel_filepos += relsz; |
} |
|
if (bfd_coff_long_section_names (abfd) |
&& strlen (o->name) > SCNNMLEN) |
{ |
/* This section has a long name which must go in the string |
table. This must correspond to the code in |
coff_write_object_contents which puts the string index |
into the s_name field of the section header. That is why |
we pass hash as FALSE. */ |
if (_bfd_stringtab_add (flaginfo.strtab, o->name, FALSE, FALSE) |
== (bfd_size_type) -1) |
goto error_return; |
long_section_names = TRUE; |
} |
} |
|
/* If doing a relocatable link, allocate space for the pointers we |
need to keep. */ |
if (info->relocatable) |
{ |
unsigned int i; |
|
/* We use section_count + 1, rather than section_count, because |
the target_index fields are 1 based. */ |
amt = abfd->section_count + 1; |
amt *= sizeof (struct coff_link_section_info); |
flaginfo.section_info = (struct coff_link_section_info *) bfd_malloc (amt); |
if (flaginfo.section_info == NULL) |
goto error_return; |
for (i = 0; i <= abfd->section_count; i++) |
{ |
flaginfo.section_info[i].relocs = NULL; |
flaginfo.section_info[i].rel_hashes = NULL; |
} |
} |
|
/* We now know the size of the relocs, so we can determine the file |
positions of the line numbers. */ |
line_filepos = rel_filepos; |
linesz = bfd_coff_linesz (abfd); |
max_output_reloc_count = 0; |
for (o = abfd->sections; o != NULL; o = o->next) |
{ |
if (o->lineno_count == 0) |
o->line_filepos = 0; |
else |
{ |
o->line_filepos = line_filepos; |
line_filepos += o->lineno_count * linesz; |
} |
|
if (o->reloc_count != 0) |
{ |
/* We don't know the indices of global symbols until we have |
written out all the local symbols. For each section in |
the output file, we keep an array of pointers to hash |
table entries. Each entry in the array corresponds to a |
reloc. When we find a reloc against a global symbol, we |
set the corresponding entry in this array so that we can |
fix up the symbol index after we have written out all the |
local symbols. |
|
Because of this problem, we also keep the relocs in |
memory until the end of the link. This wastes memory, |
but only when doing a relocatable link, which is not the |
common case. */ |
BFD_ASSERT (info->relocatable); |
amt = o->reloc_count; |
amt *= sizeof (struct internal_reloc); |
flaginfo.section_info[o->target_index].relocs = |
(struct internal_reloc *) bfd_malloc (amt); |
amt = o->reloc_count; |
amt *= sizeof (struct coff_link_hash_entry *); |
flaginfo.section_info[o->target_index].rel_hashes = |
(struct coff_link_hash_entry **) bfd_malloc (amt); |
if (flaginfo.section_info[o->target_index].relocs == NULL |
|| flaginfo.section_info[o->target_index].rel_hashes == NULL) |
goto error_return; |
|
if (o->reloc_count > max_output_reloc_count) |
max_output_reloc_count = o->reloc_count; |
} |
|
/* Reset the reloc and lineno counts, so that we can use them to |
count the number of entries we have output so far. */ |
o->reloc_count = 0; |
o->lineno_count = 0; |
} |
|
obj_sym_filepos (abfd) = line_filepos; |
|
/* Figure out the largest number of symbols in an input BFD. Take |
the opportunity to clear the output_has_begun fields of all the |
input BFD's. */ |
max_sym_count = 0; |
for (sub = info->input_bfds; sub != NULL; sub = sub->link_next) |
{ |
size_t sz; |
|
sub->output_has_begun = FALSE; |
sz = bfd_family_coff (sub) ? obj_raw_syment_count (sub) : 2; |
if (sz > max_sym_count) |
max_sym_count = sz; |
} |
|
/* Allocate some buffers used while linking. */ |
amt = max_sym_count * sizeof (struct internal_syment); |
flaginfo.internal_syms = (struct internal_syment *) bfd_malloc (amt); |
amt = max_sym_count * sizeof (asection *); |
flaginfo.sec_ptrs = (asection **) bfd_malloc (amt); |
amt = max_sym_count * sizeof (long); |
flaginfo.sym_indices = (long int *) bfd_malloc (amt); |
flaginfo.outsyms = (bfd_byte *) bfd_malloc ((max_sym_count + 1) * symesz); |
amt = max_lineno_count * bfd_coff_linesz (abfd); |
flaginfo.linenos = (bfd_byte *) bfd_malloc (amt); |
flaginfo.contents = (bfd_byte *) bfd_malloc (max_contents_size); |
amt = max_reloc_count * relsz; |
flaginfo.external_relocs = (bfd_byte *) bfd_malloc (amt); |
if (! info->relocatable) |
{ |
amt = max_reloc_count * sizeof (struct internal_reloc); |
flaginfo.internal_relocs = (struct internal_reloc *) bfd_malloc (amt); |
} |
if ((flaginfo.internal_syms == NULL && max_sym_count > 0) |
|| (flaginfo.sec_ptrs == NULL && max_sym_count > 0) |
|| (flaginfo.sym_indices == NULL && max_sym_count > 0) |
|| flaginfo.outsyms == NULL |
|| (flaginfo.linenos == NULL && max_lineno_count > 0) |
|| (flaginfo.contents == NULL && max_contents_size > 0) |
|| (flaginfo.external_relocs == NULL && max_reloc_count > 0) |
|| (! info->relocatable |
&& flaginfo.internal_relocs == NULL |
&& max_reloc_count > 0)) |
goto error_return; |
|
/* We now know the position of everything in the file, except that |
we don't know the size of the symbol table and therefore we don't |
know where the string table starts. We just build the string |
table in memory as we go along. We process all the relocations |
for a single input file at once. */ |
obj_raw_syment_count (abfd) = 0; |
|
if (coff_backend_info (abfd)->_bfd_coff_start_final_link) |
{ |
if (! bfd_coff_start_final_link (abfd, info)) |
goto error_return; |
} |
|
for (o = abfd->sections; o != NULL; o = o->next) |
{ |
for (p = o->map_head.link_order; p != NULL; p = p->next) |
{ |
if (p->type == bfd_indirect_link_order |
&& bfd_family_coff (p->u.indirect.section->owner)) |
{ |
sub = p->u.indirect.section->owner; |
if (! bfd_coff_link_output_has_begun (sub, & flaginfo)) |
{ |
if (! _bfd_coff_link_input_bfd (&flaginfo, sub)) |
goto error_return; |
sub->output_has_begun = TRUE; |
} |
} |
else if (p->type == bfd_section_reloc_link_order |
|| p->type == bfd_symbol_reloc_link_order) |
{ |
if (! _bfd_coff_reloc_link_order (abfd, &flaginfo, o, p)) |
goto error_return; |
} |
else |
{ |
if (! _bfd_default_link_order (abfd, info, o, p)) |
goto error_return; |
} |
} |
} |
|
if (flaginfo.info->strip != strip_all && flaginfo.info->discard != discard_all) |
{ |
/* Add local symbols from foreign inputs. */ |
for (sub = info->input_bfds; sub != NULL; sub = sub->link_next) |
{ |
unsigned int i; |
|
if (bfd_family_coff (sub) || ! bfd_get_outsymbols (sub)) |
continue; |
for (i = 0; i < bfd_get_symcount (sub); ++i) |
{ |
asymbol *sym = bfd_get_outsymbols (sub) [i]; |
file_ptr pos; |
struct internal_syment isym; |
bfd_size_type string_size = 0; |
bfd_vma written = 0; |
bfd_boolean rewrite = FALSE; |
|
if (! (sym->flags & BSF_LOCAL) |
|| (sym->flags & (BSF_SECTION_SYM | BSF_DEBUGGING_RELOC |
| BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC |
| BSF_SYNTHETIC)) |
|| ((sym->flags & BSF_DEBUGGING) |
&& ! (sym->flags & BSF_FILE))) |
continue; |
|
/* See if we are discarding symbols with this name. */ |
if ((flaginfo.info->strip == strip_some |
&& (bfd_hash_lookup (flaginfo.info->keep_hash, |
bfd_asymbol_name(sym), FALSE, FALSE) |
== NULL)) |
|| (((flaginfo.info->discard == discard_sec_merge |
&& (bfd_get_section (sym)->flags & SEC_MERGE) |
&& ! flaginfo.info->relocatable) |
|| flaginfo.info->discard == discard_l) |
&& bfd_is_local_label_name (sub, bfd_asymbol_name(sym)))) |
continue; |
|
pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd) |
* symesz; |
if (bfd_seek (abfd, pos, SEEK_SET) != 0) |
goto error_return; |
if (! coff_write_alien_symbol(abfd, sym, &isym, &written, |
&string_size, NULL, NULL)) |
goto error_return; |
|
if (string_size) |
{ |
bfd_boolean hash = ! (abfd->flags & BFD_TRADITIONAL_FORMAT); |
bfd_size_type indx; |
|
indx = _bfd_stringtab_add (flaginfo.strtab, |
bfd_asymbol_name (sym), hash, |
FALSE); |
if (indx == (bfd_size_type) -1) |
goto error_return; |
isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx; |
bfd_coff_swap_sym_out (abfd, &isym, flaginfo.outsyms); |
rewrite = TRUE; |
} |
|
if (isym.n_sclass == C_FILE) |
{ |
if (flaginfo.last_file_index != -1) |
{ |
flaginfo.last_file.n_value = obj_raw_syment_count (abfd); |
bfd_coff_swap_sym_out (abfd, &flaginfo.last_file, |
flaginfo.outsyms); |
pos = obj_sym_filepos (abfd) + flaginfo.last_file_index |
* symesz; |
rewrite = TRUE; |
} |
flaginfo.last_file_index = obj_raw_syment_count (abfd); |
flaginfo.last_file = isym; |
} |
|
if (rewrite |
&& (bfd_seek (abfd, pos, SEEK_SET) != 0 |
|| bfd_bwrite (flaginfo.outsyms, symesz, abfd) != symesz)) |
goto error_return; |
|
obj_raw_syment_count (abfd) += written; |
} |
} |
} |
|
if (! bfd_coff_final_link_postscript (abfd, & flaginfo)) |
goto error_return; |
|
/* Free up the buffers used by _bfd_coff_link_input_bfd. */ |
|
coff_debug_merge_hash_table_free (&flaginfo.debug_merge); |
debug_merge_allocated = FALSE; |
|
if (flaginfo.internal_syms != NULL) |
{ |
free (flaginfo.internal_syms); |
flaginfo.internal_syms = NULL; |
} |
if (flaginfo.sec_ptrs != NULL) |
{ |
free (flaginfo.sec_ptrs); |
flaginfo.sec_ptrs = NULL; |
} |
if (flaginfo.sym_indices != NULL) |
{ |
free (flaginfo.sym_indices); |
flaginfo.sym_indices = NULL; |
} |
if (flaginfo.linenos != NULL) |
{ |
free (flaginfo.linenos); |
flaginfo.linenos = NULL; |
} |
if (flaginfo.contents != NULL) |
{ |
free (flaginfo.contents); |
flaginfo.contents = NULL; |
} |
if (flaginfo.external_relocs != NULL) |
{ |
free (flaginfo.external_relocs); |
flaginfo.external_relocs = NULL; |
} |
if (flaginfo.internal_relocs != NULL) |
{ |
free (flaginfo.internal_relocs); |
flaginfo.internal_relocs = NULL; |
} |
|
/* The value of the last C_FILE symbol is supposed to be the symbol |
index of the first external symbol. Write it out again if |
necessary. */ |
if (flaginfo.last_file_index != -1 |
&& (unsigned int) flaginfo.last_file.n_value != obj_raw_syment_count (abfd)) |
{ |
file_ptr pos; |
|
flaginfo.last_file.n_value = obj_raw_syment_count (abfd); |
bfd_coff_swap_sym_out (abfd, &flaginfo.last_file, |
flaginfo.outsyms); |
|
pos = obj_sym_filepos (abfd) + flaginfo.last_file_index * symesz; |
if (bfd_seek (abfd, pos, SEEK_SET) != 0 |
|| bfd_bwrite (flaginfo.outsyms, symesz, abfd) != symesz) |
return FALSE; |
} |
|
/* If doing task linking (ld --task-link) then make a pass through the |
global symbols, writing out any that are defined, and making them |
static. */ |
if (info->task_link) |
{ |
flaginfo.failed = FALSE; |
coff_link_hash_traverse (coff_hash_table (info), |
_bfd_coff_write_task_globals, &flaginfo); |
if (flaginfo.failed) |
goto error_return; |
} |
|
/* Write out the global symbols. */ |
flaginfo.failed = FALSE; |
bfd_hash_traverse (&info->hash->table, _bfd_coff_write_global_sym, &flaginfo); |
if (flaginfo.failed) |
goto error_return; |
|
/* The outsyms buffer is used by _bfd_coff_write_global_sym. */ |
if (flaginfo.outsyms != NULL) |
{ |
free (flaginfo.outsyms); |
flaginfo.outsyms = NULL; |
} |
|
if (info->relocatable && max_output_reloc_count > 0) |
{ |
/* Now that we have written out all the global symbols, we know |
the symbol indices to use for relocs against them, and we can |
finally write out the relocs. */ |
amt = max_output_reloc_count * relsz; |
external_relocs = (bfd_byte *) bfd_malloc (amt); |
if (external_relocs == NULL) |
goto error_return; |
|
for (o = abfd->sections; o != NULL; o = o->next) |
{ |
struct internal_reloc *irel; |
struct internal_reloc *irelend; |
struct coff_link_hash_entry **rel_hash; |
bfd_byte *erel; |
|
if (o->reloc_count == 0) |
continue; |
|
irel = flaginfo.section_info[o->target_index].relocs; |
irelend = irel + o->reloc_count; |
rel_hash = flaginfo.section_info[o->target_index].rel_hashes; |
erel = external_relocs; |
for (; irel < irelend; irel++, rel_hash++, erel += relsz) |
{ |
if (*rel_hash != NULL) |
{ |
BFD_ASSERT ((*rel_hash)->indx >= 0); |
irel->r_symndx = (*rel_hash)->indx; |
} |
bfd_coff_swap_reloc_out (abfd, irel, erel); |
} |
|
if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0) |
goto error_return; |
if (obj_pe (abfd) && o->reloc_count >= 0xffff) |
{ |
/* In PE COFF, write the count of relocs as the first |
reloc. The header overflow bit will be set |
elsewhere. */ |
struct internal_reloc incount; |
bfd_byte *excount = (bfd_byte *)bfd_malloc (relsz); |
|
memset (&incount, 0, sizeof (incount)); |
incount.r_vaddr = o->reloc_count + 1; |
bfd_coff_swap_reloc_out (abfd, &incount, excount); |
if (bfd_bwrite (excount, relsz, abfd) != relsz) |
/* We'll leak, but it's an error anyway. */ |
goto error_return; |
free (excount); |
} |
if (bfd_bwrite (external_relocs, |
(bfd_size_type) relsz * o->reloc_count, abfd) |
!= (bfd_size_type) relsz * o->reloc_count) |
goto error_return; |
} |
|
free (external_relocs); |
external_relocs = NULL; |
} |
|
/* Free up the section information. */ |
if (flaginfo.section_info != NULL) |
{ |
unsigned int i; |
|
for (i = 0; i < abfd->section_count; i++) |
{ |
if (flaginfo.section_info[i].relocs != NULL) |
free (flaginfo.section_info[i].relocs); |
if (flaginfo.section_info[i].rel_hashes != NULL) |
free (flaginfo.section_info[i].rel_hashes); |
} |
free (flaginfo.section_info); |
flaginfo.section_info = NULL; |
} |
|
/* If we have optimized stabs strings, output them. */ |
if (coff_hash_table (info)->stab_info.stabstr != NULL) |
{ |
if (! _bfd_write_stab_strings (abfd, &coff_hash_table (info)->stab_info)) |
return FALSE; |
} |
|
/* Write out the string table. */ |
if (obj_raw_syment_count (abfd) != 0 || long_section_names) |
{ |
file_ptr pos; |
|
pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd) * symesz; |
if (bfd_seek (abfd, pos, SEEK_SET) != 0) |
return FALSE; |
|
#if STRING_SIZE_SIZE == 4 |
H_PUT_32 (abfd, |
_bfd_stringtab_size (flaginfo.strtab) + STRING_SIZE_SIZE, |
strbuf); |
#else |
#error Change H_PUT_32 above |
#endif |
|
if (bfd_bwrite (strbuf, (bfd_size_type) STRING_SIZE_SIZE, abfd) |
!= STRING_SIZE_SIZE) |
return FALSE; |
|
if (! _bfd_stringtab_emit (abfd, flaginfo.strtab)) |
return FALSE; |
|
obj_coff_strings_written (abfd) = TRUE; |
} |
|
_bfd_stringtab_free (flaginfo.strtab); |
|
/* Setting bfd_get_symcount to 0 will cause write_object_contents to |
not try to write out the symbols. */ |
bfd_get_symcount (abfd) = 0; |
|
return TRUE; |
|
error_return: |
if (debug_merge_allocated) |
coff_debug_merge_hash_table_free (&flaginfo.debug_merge); |
if (flaginfo.strtab != NULL) |
_bfd_stringtab_free (flaginfo.strtab); |
if (flaginfo.section_info != NULL) |
{ |
unsigned int i; |
|
for (i = 0; i < abfd->section_count; i++) |
{ |
if (flaginfo.section_info[i].relocs != NULL) |
free (flaginfo.section_info[i].relocs); |
if (flaginfo.section_info[i].rel_hashes != NULL) |
free (flaginfo.section_info[i].rel_hashes); |
} |
free (flaginfo.section_info); |
} |
if (flaginfo.internal_syms != NULL) |
free (flaginfo.internal_syms); |
if (flaginfo.sec_ptrs != NULL) |
free (flaginfo.sec_ptrs); |
if (flaginfo.sym_indices != NULL) |
free (flaginfo.sym_indices); |
if (flaginfo.outsyms != NULL) |
free (flaginfo.outsyms); |
if (flaginfo.linenos != NULL) |
free (flaginfo.linenos); |
if (flaginfo.contents != NULL) |
free (flaginfo.contents); |
if (flaginfo.external_relocs != NULL) |
free (flaginfo.external_relocs); |
if (flaginfo.internal_relocs != NULL) |
free (flaginfo.internal_relocs); |
if (external_relocs != NULL) |
free (external_relocs); |
return FALSE; |
} |
|
/* Parse out a -heap <reserved>,<commit> line. */ |
|
static char * |
dores_com (char *ptr, bfd *output_bfd, int heap) |
{ |
if (coff_data(output_bfd)->pe) |
{ |
int val = strtoul (ptr, &ptr, 0); |
|
if (heap) |
pe_data(output_bfd)->pe_opthdr.SizeOfHeapReserve = val; |
else |
pe_data(output_bfd)->pe_opthdr.SizeOfStackReserve = val; |
|
if (ptr[0] == ',') |
{ |
val = strtoul (ptr+1, &ptr, 0); |
if (heap) |
pe_data(output_bfd)->pe_opthdr.SizeOfHeapCommit = val; |
else |
pe_data(output_bfd)->pe_opthdr.SizeOfStackCommit = val; |
} |
} |
return ptr; |
} |
|
static char * |
get_name (char *ptr, char **dst) |
{ |
while (*ptr == ' ') |
ptr++; |
*dst = ptr; |
while (*ptr && *ptr != ' ') |
ptr++; |
*ptr = 0; |
return ptr+1; |
} |
|
/* Process any magic embedded commands in a section called .drectve. */ |
|
static int |
process_embedded_commands (bfd *output_bfd, |
struct bfd_link_info *info ATTRIBUTE_UNUSED, |
bfd *abfd) |
{ |
asection *sec = bfd_get_section_by_name (abfd, ".drectve"); |
char *s; |
char *e; |
bfd_byte *copy; |
|
if (!sec) |
return 1; |
|
if (!bfd_malloc_and_get_section (abfd, sec, ©)) |
{ |
if (copy != NULL) |
free (copy); |
return 0; |
} |
e = (char *) copy + sec->size; |
|
for (s = (char *) copy; s < e ; ) |
{ |
if (s[0] != '-') |
{ |
s++; |
continue; |
} |
if (CONST_STRNEQ (s, "-attr")) |
{ |
char *name; |
char *attribs; |
asection *asec; |
int loop = 1; |
int had_write = 0; |
int had_exec= 0; |
|
s += 5; |
s = get_name (s, &name); |
s = get_name (s, &attribs); |
|
while (loop) |
{ |
switch (*attribs++) |
{ |
case 'W': |
had_write = 1; |
break; |
case 'R': |
break; |
case 'S': |
break; |
case 'X': |
had_exec = 1; |
break; |
default: |
loop = 0; |
} |
} |
asec = bfd_get_section_by_name (abfd, name); |
if (asec) |
{ |
if (had_exec) |
asec->flags |= SEC_CODE; |
if (!had_write) |
asec->flags |= SEC_READONLY; |
} |
} |
else if (CONST_STRNEQ (s, "-heap")) |
s = dores_com (s + 5, output_bfd, 1); |
|
else if (CONST_STRNEQ (s, "-stack")) |
s = dores_com (s + 6, output_bfd, 0); |
|
/* GNU extension for aligned commons. */ |
else if (CONST_STRNEQ (s, "-aligncomm:")) |
{ |
/* Common symbols must be aligned on reading, as it |
is too late to do anything here, after they have |
already been allocated, so just skip the directive. */ |
s += 11; |
} |
|
else |
s++; |
} |
free (copy); |
return 1; |
} |
|
/* Place a marker against all symbols which are used by relocations. |
This marker can be picked up by the 'do we skip this symbol ?' |
loop in _bfd_coff_link_input_bfd() and used to prevent skipping |
that symbol. */ |
|
static void |
mark_relocs (struct coff_final_link_info *flaginfo, bfd *input_bfd) |
{ |
asection * a; |
|
if ((bfd_get_file_flags (input_bfd) & HAS_SYMS) == 0) |
return; |
|
for (a = input_bfd->sections; a != (asection *) NULL; a = a->next) |
{ |
struct internal_reloc * internal_relocs; |
struct internal_reloc * irel; |
struct internal_reloc * irelend; |
|
if ((a->flags & SEC_RELOC) == 0 || a->reloc_count < 1 |
|| a->linker_mark == 0) |
continue; |
/* Don't mark relocs in excluded sections. */ |
if (a->output_section == bfd_abs_section_ptr) |
continue; |
|
/* Read in the relocs. */ |
internal_relocs = _bfd_coff_read_internal_relocs |
(input_bfd, a, FALSE, |
flaginfo->external_relocs, |
flaginfo->info->relocatable, |
(flaginfo->info->relocatable |
? (flaginfo->section_info[ a->output_section->target_index ].relocs + a->output_section->reloc_count) |
: flaginfo->internal_relocs) |
); |
|
if (internal_relocs == NULL) |
continue; |
|
irel = internal_relocs; |
irelend = irel + a->reloc_count; |
|
/* Place a mark in the sym_indices array (whose entries have |
been initialised to 0) for all of the symbols that are used |
in the relocation table. This will then be picked up in the |
skip/don't-skip pass. */ |
for (; irel < irelend; irel++) |
flaginfo->sym_indices[ irel->r_symndx ] = -1; |
} |
} |
|
/* Link an input file into the linker output file. This function |
handles all the sections and relocations of the input file at once. */ |
|
bfd_boolean |
_bfd_coff_link_input_bfd (struct coff_final_link_info *flaginfo, bfd *input_bfd) |
{ |
unsigned int n_tmask = coff_data (input_bfd)->local_n_tmask; |
unsigned int n_btshft = coff_data (input_bfd)->local_n_btshft; |
bfd_boolean (*adjust_symndx) |
(bfd *, struct bfd_link_info *, bfd *, asection *, |
struct internal_reloc *, bfd_boolean *); |
bfd *output_bfd; |
const char *strings; |
bfd_size_type syment_base; |
bfd_boolean copy, hash; |
bfd_size_type isymesz; |
bfd_size_type osymesz; |
bfd_size_type linesz; |
bfd_byte *esym; |
bfd_byte *esym_end; |
struct internal_syment *isymp; |
asection **secpp; |
long *indexp; |
unsigned long output_index; |
bfd_byte *outsym; |
struct coff_link_hash_entry **sym_hash; |
asection *o; |
|
/* Move all the symbols to the output file. */ |
|
output_bfd = flaginfo->output_bfd; |
strings = NULL; |
syment_base = obj_raw_syment_count (output_bfd); |
isymesz = bfd_coff_symesz (input_bfd); |
osymesz = bfd_coff_symesz (output_bfd); |
linesz = bfd_coff_linesz (input_bfd); |
BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd)); |
|
copy = FALSE; |
if (! flaginfo->info->keep_memory) |
copy = TRUE; |
hash = TRUE; |
if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0) |
hash = FALSE; |
|
if (! _bfd_coff_get_external_symbols (input_bfd)) |
return FALSE; |
|
esym = (bfd_byte *) obj_coff_external_syms (input_bfd); |
esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz; |
isymp = flaginfo->internal_syms; |
secpp = flaginfo->sec_ptrs; |
indexp = flaginfo->sym_indices; |
output_index = syment_base; |
outsym = flaginfo->outsyms; |
|
if (coff_data (output_bfd)->pe |
&& ! process_embedded_commands (output_bfd, flaginfo->info, input_bfd)) |
return FALSE; |
|
/* If we are going to perform relocations and also strip/discard some |
symbols then we must make sure that we do not strip/discard those |
symbols that are going to be involved in the relocations. */ |
if (( flaginfo->info->strip != strip_none |
|| flaginfo->info->discard != discard_none) |
&& flaginfo->info->relocatable) |
{ |
/* Mark the symbol array as 'not-used'. */ |
memset (indexp, 0, obj_raw_syment_count (input_bfd) * sizeof * indexp); |
|
mark_relocs (flaginfo, input_bfd); |
} |
|
while (esym < esym_end) |
{ |
struct internal_syment isym; |
enum coff_symbol_classification classification; |
bfd_boolean skip; |
bfd_boolean global; |
bfd_boolean dont_skip_symbol; |
int add; |
|
bfd_coff_swap_sym_in (input_bfd, esym, isymp); |
|
/* Make a copy of *isymp so that the relocate_section function |
always sees the original values. This is more reliable than |
always recomputing the symbol value even if we are stripping |
the symbol. */ |
isym = *isymp; |
|
classification = bfd_coff_classify_symbol (input_bfd, &isym); |
switch (classification) |
{ |
default: |
abort (); |
case COFF_SYMBOL_GLOBAL: |
case COFF_SYMBOL_PE_SECTION: |
case COFF_SYMBOL_LOCAL: |
*secpp = coff_section_from_bfd_index (input_bfd, isym.n_scnum); |
break; |
case COFF_SYMBOL_COMMON: |
*secpp = bfd_com_section_ptr; |
break; |
case COFF_SYMBOL_UNDEFINED: |
*secpp = bfd_und_section_ptr; |
break; |
} |
|
/* Extract the flag indicating if this symbol is used by a |
relocation. */ |
if ((flaginfo->info->strip != strip_none |
|| flaginfo->info->discard != discard_none) |
&& flaginfo->info->relocatable) |
dont_skip_symbol = *indexp; |
else |
dont_skip_symbol = FALSE; |
|
*indexp = -1; |
|
skip = FALSE; |
global = FALSE; |
add = 1 + isym.n_numaux; |
|
/* If we are stripping all symbols, we want to skip this one. */ |
if (flaginfo->info->strip == strip_all && ! dont_skip_symbol) |
skip = TRUE; |
|
if (! skip) |
{ |
switch (classification) |
{ |
default: |
abort (); |
case COFF_SYMBOL_GLOBAL: |
case COFF_SYMBOL_COMMON: |
case COFF_SYMBOL_PE_SECTION: |
/* This is a global symbol. Global symbols come at the |
end of the symbol table, so skip them for now. |
Locally defined function symbols, however, are an |
exception, and are not moved to the end. */ |
global = TRUE; |
if (! ISFCN (isym.n_type)) |
skip = TRUE; |
break; |
|
case COFF_SYMBOL_UNDEFINED: |
/* Undefined symbols are left for the end. */ |
global = TRUE; |
skip = TRUE; |
break; |
|
case COFF_SYMBOL_LOCAL: |
/* This is a local symbol. Skip it if we are discarding |
local symbols. */ |
if (flaginfo->info->discard == discard_all && ! dont_skip_symbol) |
skip = TRUE; |
break; |
} |
} |
|
#ifndef COFF_WITH_PE |
/* Skip section symbols for sections which are not going to be |
emitted. */ |
if (!skip |
&& !dont_skip_symbol |
&& isym.n_sclass == C_STAT |
&& isym.n_type == T_NULL |
&& isym.n_numaux > 0 |
&& ((*secpp)->output_section == bfd_abs_section_ptr |
|| bfd_section_removed_from_list (output_bfd, |
(*secpp)->output_section))) |
skip = TRUE; |
#endif |
|
/* If we stripping debugging symbols, and this is a debugging |
symbol, then skip it. FIXME: gas sets the section to N_ABS |
for some types of debugging symbols; I don't know if this is |
a bug or not. In any case, we handle it here. */ |
if (! skip |
&& flaginfo->info->strip == strip_debugger |
&& ! dont_skip_symbol |
&& (isym.n_scnum == N_DEBUG |
|| (isym.n_scnum == N_ABS |
&& (isym.n_sclass == C_AUTO |
|| isym.n_sclass == C_REG |
|| isym.n_sclass == C_MOS |
|| isym.n_sclass == C_MOE |
|| isym.n_sclass == C_MOU |
|| isym.n_sclass == C_ARG |
|| isym.n_sclass == C_REGPARM |
|| isym.n_sclass == C_FIELD |
|| isym.n_sclass == C_EOS)))) |
skip = TRUE; |
|
/* If some symbols are stripped based on the name, work out the |
name and decide whether to skip this symbol. */ |
if (! skip |
&& (flaginfo->info->strip == strip_some |
|| flaginfo->info->discard == discard_l)) |
{ |
const char *name; |
char buf[SYMNMLEN + 1]; |
|
name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf); |
if (name == NULL) |
return FALSE; |
|
if (! dont_skip_symbol |
&& ((flaginfo->info->strip == strip_some |
&& (bfd_hash_lookup (flaginfo->info->keep_hash, name, FALSE, |
FALSE) == NULL)) |
|| (! global |
&& flaginfo->info->discard == discard_l |
&& bfd_is_local_label_name (input_bfd, name)))) |
skip = TRUE; |
} |
|
/* If this is an enum, struct, or union tag, see if we have |
already output an identical type. */ |
if (! skip |
&& (flaginfo->output_bfd->flags & BFD_TRADITIONAL_FORMAT) == 0 |
&& (isym.n_sclass == C_ENTAG |
|| isym.n_sclass == C_STRTAG |
|| isym.n_sclass == C_UNTAG) |
&& isym.n_numaux == 1) |
{ |
const char *name; |
char buf[SYMNMLEN + 1]; |
struct coff_debug_merge_hash_entry *mh; |
struct coff_debug_merge_type *mt; |
union internal_auxent aux; |
struct coff_debug_merge_element **epp; |
bfd_byte *esl, *eslend; |
struct internal_syment *islp; |
bfd_size_type amt; |
|
name = _bfd_coff_internal_syment_name (input_bfd, &isym, buf); |
if (name == NULL) |
return FALSE; |
|
/* Ignore fake names invented by compiler; treat them all as |
the same name. */ |
if (*name == '~' || *name == '.' || *name == '$' |
|| (*name == bfd_get_symbol_leading_char (input_bfd) |
&& (name[1] == '~' || name[1] == '.' || name[1] == '$'))) |
name = ""; |
|
mh = coff_debug_merge_hash_lookup (&flaginfo->debug_merge, name, |
TRUE, TRUE); |
if (mh == NULL) |
return FALSE; |
|
/* Allocate memory to hold type information. If this turns |
out to be a duplicate, we pass this address to |
bfd_release. */ |
amt = sizeof (struct coff_debug_merge_type); |
mt = (struct coff_debug_merge_type *) bfd_alloc (input_bfd, amt); |
if (mt == NULL) |
return FALSE; |
mt->type_class = isym.n_sclass; |
|
/* Pick up the aux entry, which points to the end of the tag |
entries. */ |
bfd_coff_swap_aux_in (input_bfd, (esym + isymesz), |
isym.n_type, isym.n_sclass, 0, isym.n_numaux, |
&aux); |
|
/* Gather the elements. */ |
epp = &mt->elements; |
mt->elements = NULL; |
islp = isymp + 2; |
esl = esym + 2 * isymesz; |
eslend = ((bfd_byte *) obj_coff_external_syms (input_bfd) |
+ aux.x_sym.x_fcnary.x_fcn.x_endndx.l * isymesz); |
while (esl < eslend) |
{ |
const char *elename; |
char elebuf[SYMNMLEN + 1]; |
char *name_copy; |
|
bfd_coff_swap_sym_in (input_bfd, esl, islp); |
|
amt = sizeof (struct coff_debug_merge_element); |
*epp = (struct coff_debug_merge_element *) |
bfd_alloc (input_bfd, amt); |
if (*epp == NULL) |
return FALSE; |
|
elename = _bfd_coff_internal_syment_name (input_bfd, islp, |
elebuf); |
if (elename == NULL) |
return FALSE; |
|
amt = strlen (elename) + 1; |
name_copy = (char *) bfd_alloc (input_bfd, amt); |
if (name_copy == NULL) |
return FALSE; |
strcpy (name_copy, elename); |
|
(*epp)->name = name_copy; |
(*epp)->type = islp->n_type; |
(*epp)->tagndx = 0; |
if (islp->n_numaux >= 1 |
&& islp->n_type != T_NULL |
&& islp->n_sclass != C_EOS) |
{ |
union internal_auxent eleaux; |
long indx; |
|
bfd_coff_swap_aux_in (input_bfd, (esl + isymesz), |
islp->n_type, islp->n_sclass, 0, |
islp->n_numaux, &eleaux); |
indx = eleaux.x_sym.x_tagndx.l; |
|
/* FIXME: If this tagndx entry refers to a symbol |
defined later in this file, we just ignore it. |
Handling this correctly would be tedious, and may |
not be required. */ |
if (indx > 0 |
&& (indx |
< ((esym - |
(bfd_byte *) obj_coff_external_syms (input_bfd)) |
/ (long) isymesz))) |
{ |
(*epp)->tagndx = flaginfo->sym_indices[indx]; |
if ((*epp)->tagndx < 0) |
(*epp)->tagndx = 0; |
} |
} |
epp = &(*epp)->next; |
*epp = NULL; |
|
esl += (islp->n_numaux + 1) * isymesz; |
islp += islp->n_numaux + 1; |
} |
|
/* See if we already have a definition which matches this |
type. We always output the type if it has no elements, |
for simplicity. */ |
if (mt->elements == NULL) |
bfd_release (input_bfd, mt); |
else |
{ |
struct coff_debug_merge_type *mtl; |
|
for (mtl = mh->types; mtl != NULL; mtl = mtl->next) |
{ |
struct coff_debug_merge_element *me, *mel; |
|
if (mtl->type_class != mt->type_class) |
continue; |
|
for (me = mt->elements, mel = mtl->elements; |
me != NULL && mel != NULL; |
me = me->next, mel = mel->next) |
{ |
if (strcmp (me->name, mel->name) != 0 |
|| me->type != mel->type |
|| me->tagndx != mel->tagndx) |
break; |
} |
|
if (me == NULL && mel == NULL) |
break; |
} |
|
if (mtl == NULL || (bfd_size_type) mtl->indx >= syment_base) |
{ |
/* This is the first definition of this type. */ |
mt->indx = output_index; |
mt->next = mh->types; |
mh->types = mt; |
} |
else |
{ |
/* This is a redefinition which can be merged. */ |
bfd_release (input_bfd, mt); |
*indexp = mtl->indx; |
add = (eslend - esym) / isymesz; |
skip = TRUE; |
} |
} |
} |
|
/* We now know whether we are to skip this symbol or not. */ |
if (! skip) |
{ |
/* Adjust the symbol in order to output it. */ |
|
if (isym._n._n_n._n_zeroes == 0 |
&& isym._n._n_n._n_offset != 0) |
{ |
const char *name; |
bfd_size_type indx; |
|
/* This symbol has a long name. Enter it in the string |
table we are building. Note that we do not check |
bfd_coff_symname_in_debug. That is only true for |
XCOFF, and XCOFF requires different linking code |
anyhow. */ |
name = _bfd_coff_internal_syment_name (input_bfd, &isym, NULL); |
if (name == NULL) |
return FALSE; |
indx = _bfd_stringtab_add (flaginfo->strtab, name, hash, copy); |
if (indx == (bfd_size_type) -1) |
return FALSE; |
isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx; |
} |
|
switch (isym.n_sclass) |
{ |
case C_AUTO: |
case C_MOS: |
case C_EOS: |
case C_MOE: |
case C_MOU: |
case C_UNTAG: |
case C_STRTAG: |
case C_ENTAG: |
case C_TPDEF: |
case C_ARG: |
case C_USTATIC: |
case C_REG: |
case C_REGPARM: |
case C_FIELD: |
/* The symbol value should not be modified. */ |
break; |
|
case C_FCN: |
if (obj_pe (input_bfd) |
&& strcmp (isym.n_name, ".bf") != 0 |
&& isym.n_scnum > 0) |
{ |
/* For PE, .lf and .ef get their value left alone, |
while .bf gets relocated. However, they all have |
"real" section numbers, and need to be moved into |
the new section. */ |
isym.n_scnum = (*secpp)->output_section->target_index; |
break; |
} |
/* Fall through. */ |
default: |
case C_LABEL: /* Not completely sure about these 2 */ |
case C_EXTDEF: |
case C_BLOCK: |
case C_EFCN: |
case C_NULL: |
case C_EXT: |
case C_STAT: |
case C_SECTION: |
case C_NT_WEAK: |
/* Compute new symbol location. */ |
if (isym.n_scnum > 0) |
{ |
isym.n_scnum = (*secpp)->output_section->target_index; |
isym.n_value += (*secpp)->output_offset; |
if (! obj_pe (input_bfd)) |
isym.n_value -= (*secpp)->vma; |
if (! obj_pe (flaginfo->output_bfd)) |
isym.n_value += (*secpp)->output_section->vma; |
} |
break; |
|
case C_FILE: |
/* The value of a C_FILE symbol is the symbol index of |
the next C_FILE symbol. The value of the last C_FILE |
symbol is the symbol index to the first external |
symbol (actually, coff_renumber_symbols does not get |
this right--it just sets the value of the last C_FILE |
symbol to zero--and nobody has ever complained about |
it). We try to get this right, below, just before we |
write the symbols out, but in the general case we may |
have to write the symbol out twice. */ |
if (flaginfo->last_file_index != -1 |
&& flaginfo->last_file.n_value != (bfd_vma) output_index) |
{ |
/* We must correct the value of the last C_FILE |
entry. */ |
flaginfo->last_file.n_value = output_index; |
if ((bfd_size_type) flaginfo->last_file_index >= syment_base) |
{ |
/* The last C_FILE symbol is in this input file. */ |
bfd_coff_swap_sym_out (output_bfd, |
&flaginfo->last_file, |
(flaginfo->outsyms |
+ ((flaginfo->last_file_index |
- syment_base) |
* osymesz))); |
} |
else |
{ |
file_ptr pos; |
|
/* We have already written out the last C_FILE |
symbol. We need to write it out again. We |
borrow *outsym temporarily. */ |
bfd_coff_swap_sym_out (output_bfd, |
&flaginfo->last_file, outsym); |
pos = obj_sym_filepos (output_bfd); |
pos += flaginfo->last_file_index * osymesz; |
if (bfd_seek (output_bfd, pos, SEEK_SET) != 0 |
|| bfd_bwrite (outsym, osymesz, output_bfd) != osymesz) |
return FALSE; |
} |
} |
|
flaginfo->last_file_index = output_index; |
flaginfo->last_file = isym; |
break; |
} |
|
/* If doing task linking, convert normal global function symbols to |
static functions. */ |
if (flaginfo->info->task_link && IS_EXTERNAL (input_bfd, isym)) |
isym.n_sclass = C_STAT; |
|
/* Output the symbol. */ |
bfd_coff_swap_sym_out (output_bfd, &isym, outsym); |
|
*indexp = output_index; |
|
if (global) |
{ |
long indx; |
struct coff_link_hash_entry *h; |
|
indx = ((esym - (bfd_byte *) obj_coff_external_syms (input_bfd)) |
/ isymesz); |
h = obj_coff_sym_hashes (input_bfd)[indx]; |
if (h == NULL) |
{ |
/* This can happen if there were errors earlier in |
the link. */ |
bfd_set_error (bfd_error_bad_value); |
return FALSE; |
} |
h->indx = output_index; |
} |
|
output_index += add; |
outsym += add * osymesz; |
} |
|
esym += add * isymesz; |
isymp += add; |
++secpp; |
++indexp; |
for (--add; add > 0; --add) |
{ |
*secpp++ = NULL; |
*indexp++ = -1; |
} |
} |
|
/* Fix up the aux entries. This must be done in a separate pass, |
because we don't know the correct symbol indices until we have |
already decided which symbols we are going to keep. */ |
esym = (bfd_byte *) obj_coff_external_syms (input_bfd); |
esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz; |
isymp = flaginfo->internal_syms; |
indexp = flaginfo->sym_indices; |
sym_hash = obj_coff_sym_hashes (input_bfd); |
outsym = flaginfo->outsyms; |
|
while (esym < esym_end) |
{ |
int add; |
|
add = 1 + isymp->n_numaux; |
|
if ((*indexp < 0 |
|| (bfd_size_type) *indexp < syment_base) |
&& (*sym_hash == NULL |
|| (*sym_hash)->auxbfd != input_bfd)) |
esym += add * isymesz; |
else |
{ |
struct coff_link_hash_entry *h; |
int i; |
|
h = NULL; |
if (*indexp < 0) |
{ |
h = *sym_hash; |
|
/* The m68k-motorola-sysv assembler will sometimes |
generate two symbols with the same name, but only one |
will have aux entries. */ |
BFD_ASSERT (isymp->n_numaux == 0 |
|| h->numaux == 0 |
|| h->numaux == isymp->n_numaux); |
} |
|
esym += isymesz; |
|
if (h == NULL) |
outsym += osymesz; |
|
/* Handle the aux entries. This handling is based on |
coff_pointerize_aux. I don't know if it always correct. */ |
for (i = 0; i < isymp->n_numaux && esym < esym_end; i++) |
{ |
union internal_auxent aux; |
union internal_auxent *auxp; |
|
if (h != NULL && h->aux != NULL && (h->numaux > i)) |
auxp = h->aux + i; |
else |
{ |
bfd_coff_swap_aux_in (input_bfd, esym, isymp->n_type, |
isymp->n_sclass, i, isymp->n_numaux, &aux); |
auxp = &aux; |
} |
|
if (isymp->n_sclass == C_FILE) |
{ |
/* If this is a long filename, we must put it in the |
string table. */ |
if (auxp->x_file.x_n.x_zeroes == 0 |
&& auxp->x_file.x_n.x_offset != 0) |
{ |
const char *filename; |
bfd_size_type indx; |
|
BFD_ASSERT (auxp->x_file.x_n.x_offset |
>= STRING_SIZE_SIZE); |
if (strings == NULL) |
{ |
strings = _bfd_coff_read_string_table (input_bfd); |
if (strings == NULL) |
return FALSE; |
} |
filename = strings + auxp->x_file.x_n.x_offset; |
indx = _bfd_stringtab_add (flaginfo->strtab, filename, |
hash, copy); |
if (indx == (bfd_size_type) -1) |
return FALSE; |
auxp->x_file.x_n.x_offset = STRING_SIZE_SIZE + indx; |
} |
} |
else if ((isymp->n_sclass != C_STAT || isymp->n_type != T_NULL) |
&& isymp->n_sclass != C_NT_WEAK) |
{ |
unsigned long indx; |
|
if (ISFCN (isymp->n_type) |
|| ISTAG (isymp->n_sclass) |
|| isymp->n_sclass == C_BLOCK |
|| isymp->n_sclass == C_FCN) |
{ |
indx = auxp->x_sym.x_fcnary.x_fcn.x_endndx.l; |
if (indx > 0 |
&& indx < obj_raw_syment_count (input_bfd)) |
{ |
/* We look forward through the symbol for |
the index of the next symbol we are going |
to include. I don't know if this is |
entirely right. */ |
while ((flaginfo->sym_indices[indx] < 0 |
|| ((bfd_size_type) flaginfo->sym_indices[indx] |
< syment_base)) |
&& indx < obj_raw_syment_count (input_bfd)) |
++indx; |
if (indx >= obj_raw_syment_count (input_bfd)) |
indx = output_index; |
else |
indx = flaginfo->sym_indices[indx]; |
auxp->x_sym.x_fcnary.x_fcn.x_endndx.l = indx; |
} |
} |
|
indx = auxp->x_sym.x_tagndx.l; |
if (indx > 0 && indx < obj_raw_syment_count (input_bfd)) |
{ |
long symindx; |
|
symindx = flaginfo->sym_indices[indx]; |
if (symindx < 0) |
auxp->x_sym.x_tagndx.l = 0; |
else |
auxp->x_sym.x_tagndx.l = symindx; |
} |
|
/* The .bf symbols are supposed to be linked through |
the endndx field. We need to carry this list |
across object files. */ |
if (i == 0 |
&& h == NULL |
&& isymp->n_sclass == C_FCN |
&& (isymp->_n._n_n._n_zeroes != 0 |
|| isymp->_n._n_n._n_offset == 0) |
&& isymp->_n._n_name[0] == '.' |
&& isymp->_n._n_name[1] == 'b' |
&& isymp->_n._n_name[2] == 'f' |
&& isymp->_n._n_name[3] == '\0') |
{ |
if (flaginfo->last_bf_index != -1) |
{ |
flaginfo->last_bf.x_sym.x_fcnary.x_fcn.x_endndx.l = |
*indexp; |
|
if ((bfd_size_type) flaginfo->last_bf_index |
>= syment_base) |
{ |
void *auxout; |
|
/* The last .bf symbol is in this input |
file. This will only happen if the |
assembler did not set up the .bf |
endndx symbols correctly. */ |
auxout = (flaginfo->outsyms |
+ ((flaginfo->last_bf_index |
- syment_base) |
* osymesz)); |
|
bfd_coff_swap_aux_out (output_bfd, |
&flaginfo->last_bf, |
isymp->n_type, |
isymp->n_sclass, |
0, isymp->n_numaux, |
auxout); |
} |
else |
{ |
file_ptr pos; |
|
/* We have already written out the last |
.bf aux entry. We need to write it |
out again. We borrow *outsym |
temporarily. FIXME: This case should |
be made faster. */ |
bfd_coff_swap_aux_out (output_bfd, |
&flaginfo->last_bf, |
isymp->n_type, |
isymp->n_sclass, |
0, isymp->n_numaux, |
outsym); |
pos = obj_sym_filepos (output_bfd); |
pos += flaginfo->last_bf_index * osymesz; |
if (bfd_seek (output_bfd, pos, SEEK_SET) != 0 |
|| (bfd_bwrite (outsym, osymesz, output_bfd) |
!= osymesz)) |
return FALSE; |
} |
} |
|
if (auxp->x_sym.x_fcnary.x_fcn.x_endndx.l != 0) |
flaginfo->last_bf_index = -1; |
else |
{ |
/* The endndx field of this aux entry must |
be updated with the symbol number of the |
next .bf symbol. */ |
flaginfo->last_bf = *auxp; |
flaginfo->last_bf_index = (((outsym - flaginfo->outsyms) |
/ osymesz) |
+ syment_base); |
} |
} |
} |
|
if (h == NULL) |
{ |
bfd_coff_swap_aux_out (output_bfd, auxp, isymp->n_type, |
isymp->n_sclass, i, isymp->n_numaux, |
outsym); |
outsym += osymesz; |
} |
|
esym += isymesz; |
} |
} |
|
indexp += add; |
isymp += add; |
sym_hash += add; |
} |
|
/* Relocate the line numbers, unless we are stripping them. */ |
if (flaginfo->info->strip == strip_none |
|| flaginfo->info->strip == strip_some) |
{ |
for (o = input_bfd->sections; o != NULL; o = o->next) |
{ |
bfd_vma offset; |
bfd_byte *eline; |
bfd_byte *elineend; |
bfd_byte *oeline; |
bfd_boolean skipping; |
file_ptr pos; |
bfd_size_type amt; |
|
/* FIXME: If SEC_HAS_CONTENTS is not for the section, then |
build_link_order in ldwrite.c will not have created a |
link order, which means that we will not have seen this |
input section in _bfd_coff_final_link, which means that |
we will not have allocated space for the line numbers of |
this section. I don't think line numbers can be |
meaningful for a section which does not have |
SEC_HAS_CONTENTS set, but, if they do, this must be |
changed. */ |
if (o->lineno_count == 0 |
|| (o->output_section->flags & SEC_HAS_CONTENTS) == 0) |
continue; |
|
if (bfd_seek (input_bfd, o->line_filepos, SEEK_SET) != 0 |
|| bfd_bread (flaginfo->linenos, linesz * o->lineno_count, |
input_bfd) != linesz * o->lineno_count) |
return FALSE; |
|
offset = o->output_section->vma + o->output_offset - o->vma; |
eline = flaginfo->linenos; |
oeline = flaginfo->linenos; |
elineend = eline + linesz * o->lineno_count; |
skipping = FALSE; |
for (; eline < elineend; eline += linesz) |
{ |
struct internal_lineno iline; |
|
bfd_coff_swap_lineno_in (input_bfd, eline, &iline); |
|
if (iline.l_lnno != 0) |
iline.l_addr.l_paddr += offset; |
else if (iline.l_addr.l_symndx >= 0 |
&& ((unsigned long) iline.l_addr.l_symndx |
< obj_raw_syment_count (input_bfd))) |
{ |
long indx; |
|
indx = flaginfo->sym_indices[iline.l_addr.l_symndx]; |
|
if (indx < 0) |
{ |
/* These line numbers are attached to a symbol |
which we are stripping. We must discard the |
line numbers because reading them back with |
no associated symbol (or associating them all |
with symbol #0) will fail. We can't regain |
the space in the output file, but at least |
they're dense. */ |
skipping = TRUE; |
} |
else |
{ |
struct internal_syment is; |
union internal_auxent ia; |
|
/* Fix up the lnnoptr field in the aux entry of |
the symbol. It turns out that we can't do |
this when we modify the symbol aux entries, |
because gas sometimes screws up the lnnoptr |
field and makes it an offset from the start |
of the line numbers rather than an absolute |
file index. */ |
bfd_coff_swap_sym_in (output_bfd, |
(flaginfo->outsyms |
+ ((indx - syment_base) |
* osymesz)), &is); |
if ((ISFCN (is.n_type) |
|| is.n_sclass == C_BLOCK) |
&& is.n_numaux >= 1) |
{ |
void *auxptr; |
|
auxptr = (flaginfo->outsyms |
+ ((indx - syment_base + 1) |
* osymesz)); |
bfd_coff_swap_aux_in (output_bfd, auxptr, |
is.n_type, is.n_sclass, |
0, is.n_numaux, &ia); |
ia.x_sym.x_fcnary.x_fcn.x_lnnoptr = |
(o->output_section->line_filepos |
+ o->output_section->lineno_count * linesz |
+ eline - flaginfo->linenos); |
bfd_coff_swap_aux_out (output_bfd, &ia, |
is.n_type, is.n_sclass, 0, |
is.n_numaux, auxptr); |
} |
|
skipping = FALSE; |
} |
|
iline.l_addr.l_symndx = indx; |
} |
|
if (!skipping) |
{ |
bfd_coff_swap_lineno_out (output_bfd, &iline, oeline); |
oeline += linesz; |
} |
} |
|
pos = o->output_section->line_filepos; |
pos += o->output_section->lineno_count * linesz; |
amt = oeline - flaginfo->linenos; |
if (bfd_seek (output_bfd, pos, SEEK_SET) != 0 |
|| bfd_bwrite (flaginfo->linenos, amt, output_bfd) != amt) |
return FALSE; |
|
o->output_section->lineno_count += amt / linesz; |
} |
} |
|
/* If we swapped out a C_FILE symbol, guess that the next C_FILE |
symbol will be the first symbol in the next input file. In the |
normal case, this will save us from writing out the C_FILE symbol |
again. */ |
if (flaginfo->last_file_index != -1 |
&& (bfd_size_type) flaginfo->last_file_index >= syment_base) |
{ |
flaginfo->last_file.n_value = output_index; |
bfd_coff_swap_sym_out (output_bfd, &flaginfo->last_file, |
(flaginfo->outsyms |
+ ((flaginfo->last_file_index - syment_base) |
* osymesz))); |
} |
|
/* Write the modified symbols to the output file. */ |
if (outsym > flaginfo->outsyms) |
{ |
file_ptr pos; |
bfd_size_type amt; |
|
pos = obj_sym_filepos (output_bfd) + syment_base * osymesz; |
amt = outsym - flaginfo->outsyms; |
if (bfd_seek (output_bfd, pos, SEEK_SET) != 0 |
|| bfd_bwrite (flaginfo->outsyms, amt, output_bfd) != amt) |
return FALSE; |
|
BFD_ASSERT ((obj_raw_syment_count (output_bfd) |
+ (outsym - flaginfo->outsyms) / osymesz) |
== output_index); |
|
obj_raw_syment_count (output_bfd) = output_index; |
} |
|
/* Relocate the contents of each section. */ |
adjust_symndx = coff_backend_info (input_bfd)->_bfd_coff_adjust_symndx; |
for (o = input_bfd->sections; o != NULL; o = o->next) |
{ |
bfd_byte *contents; |
struct coff_section_tdata *secdata; |
|
if (! o->linker_mark) |
/* This section was omitted from the link. */ |
continue; |
|
if ((o->flags & SEC_LINKER_CREATED) != 0) |
continue; |
|
if ((o->flags & SEC_HAS_CONTENTS) == 0 |
|| (o->size == 0 && (o->flags & SEC_RELOC) == 0)) |
{ |
if ((o->flags & SEC_RELOC) != 0 |
&& o->reloc_count != 0) |
{ |
(*_bfd_error_handler) |
(_("%B: relocs in section `%A', but it has no contents"), |
input_bfd, o); |
bfd_set_error (bfd_error_no_contents); |
return FALSE; |
} |
|
continue; |
} |
|
secdata = coff_section_data (input_bfd, o); |
if (secdata != NULL && secdata->contents != NULL) |
contents = secdata->contents; |
else |
{ |
contents = flaginfo->contents; |
if (! bfd_get_full_section_contents (input_bfd, o, &contents)) |
return FALSE; |
} |
|
if ((o->flags & SEC_RELOC) != 0) |
{ |
int target_index; |
struct internal_reloc *internal_relocs; |
struct internal_reloc *irel; |
|
/* Read in the relocs. */ |
target_index = o->output_section->target_index; |
internal_relocs = (_bfd_coff_read_internal_relocs |
(input_bfd, o, FALSE, flaginfo->external_relocs, |
flaginfo->info->relocatable, |
(flaginfo->info->relocatable |
? (flaginfo->section_info[target_index].relocs |
+ o->output_section->reloc_count) |
: flaginfo->internal_relocs))); |
if (internal_relocs == NULL |
&& o->reloc_count > 0) |
return FALSE; |
|
/* Run through the relocs looking for relocs against symbols |
coming from discarded sections and complain about them. */ |
irel = internal_relocs; |
for (; irel < &internal_relocs[o->reloc_count]; irel++) |
{ |
struct coff_link_hash_entry *h; |
asection *ps = NULL; |
long symndx = irel->r_symndx; |
if (symndx < 0) |
continue; |
h = obj_coff_sym_hashes (input_bfd)[symndx]; |
if (h == NULL) |
continue; |
while (h->root.type == bfd_link_hash_indirect |
|| h->root.type == bfd_link_hash_warning) |
h = (struct coff_link_hash_entry *) h->root.u.i.link; |
if (h->root.type == bfd_link_hash_defined |
|| h->root.type == bfd_link_hash_defweak) |
ps = h->root.u.def.section; |
if (ps == NULL) |
continue; |
/* Complain if definition comes from an excluded section. */ |
if (ps->flags & SEC_EXCLUDE) |
(*flaginfo->info->callbacks->einfo) |
(_("%X`%s' referenced in section `%A' of %B: " |
"defined in discarded section `%A' of %B\n"), |
h->root.root.string, o, input_bfd, ps, ps->owner); |
} |
|
/* Call processor specific code to relocate the section |
contents. */ |
if (! bfd_coff_relocate_section (output_bfd, flaginfo->info, |
input_bfd, o, |
contents, |
internal_relocs, |
flaginfo->internal_syms, |
flaginfo->sec_ptrs)) |
return FALSE; |
|
if (flaginfo->info->relocatable) |
{ |
bfd_vma offset; |
struct internal_reloc *irelend; |
struct coff_link_hash_entry **rel_hash; |
|
offset = o->output_section->vma + o->output_offset - o->vma; |
irel = internal_relocs; |
irelend = irel + o->reloc_count; |
rel_hash = (flaginfo->section_info[target_index].rel_hashes |
+ o->output_section->reloc_count); |
for (; irel < irelend; irel++, rel_hash++) |
{ |
struct coff_link_hash_entry *h; |
bfd_boolean adjusted; |
|
*rel_hash = NULL; |
|
/* Adjust the reloc address and symbol index. */ |
irel->r_vaddr += offset; |
|
if (irel->r_symndx == -1) |
continue; |
|
if (adjust_symndx) |
{ |
if (! (*adjust_symndx) (output_bfd, flaginfo->info, |
input_bfd, o, irel, |
&adjusted)) |
return FALSE; |
if (adjusted) |
continue; |
} |
|
h = obj_coff_sym_hashes (input_bfd)[irel->r_symndx]; |
if (h != NULL) |
{ |
/* This is a global symbol. */ |
if (h->indx >= 0) |
irel->r_symndx = h->indx; |
else |
{ |
/* This symbol is being written at the end |
of the file, and we do not yet know the |
symbol index. We save the pointer to the |
hash table entry in the rel_hash list. |
We set the indx field to -2 to indicate |
that this symbol must not be stripped. */ |
*rel_hash = h; |
h->indx = -2; |
} |
} |
else |
{ |
long indx; |
|
indx = flaginfo->sym_indices[irel->r_symndx]; |
if (indx != -1) |
irel->r_symndx = indx; |
else |
{ |
struct internal_syment *is; |
const char *name; |
char buf[SYMNMLEN + 1]; |
|
/* This reloc is against a symbol we are |
stripping. This should have been handled |
by the 'dont_skip_symbol' code in the while |
loop at the top of this function. */ |
is = flaginfo->internal_syms + irel->r_symndx; |
|
name = (_bfd_coff_internal_syment_name |
(input_bfd, is, buf)); |
if (name == NULL) |
return FALSE; |
|
if (! ((*flaginfo->info->callbacks->unattached_reloc) |
(flaginfo->info, name, input_bfd, o, |
irel->r_vaddr))) |
return FALSE; |
} |
} |
} |
|
o->output_section->reloc_count += o->reloc_count; |
} |
} |
|
/* Write out the modified section contents. */ |
if (secdata == NULL || secdata->stab_info == NULL) |
{ |
file_ptr loc = o->output_offset * bfd_octets_per_byte (output_bfd); |
if (! bfd_set_section_contents (output_bfd, o->output_section, |
contents, loc, o->size)) |
return FALSE; |
} |
else |
{ |
if (! (_bfd_write_section_stabs |
(output_bfd, &coff_hash_table (flaginfo->info)->stab_info, |
o, &secdata->stab_info, contents))) |
return FALSE; |
} |
} |
|
if (! flaginfo->info->keep_memory |
&& ! _bfd_coff_free_symbols (input_bfd)) |
return FALSE; |
|
return TRUE; |
} |
|
/* Write out a global symbol. Called via bfd_hash_traverse. */ |
|
bfd_boolean |
_bfd_coff_write_global_sym (struct bfd_hash_entry *bh, void *data) |
{ |
struct coff_link_hash_entry *h = (struct coff_link_hash_entry *) bh; |
struct coff_final_link_info *flaginfo = (struct coff_final_link_info *) data; |
bfd *output_bfd; |
struct internal_syment isym; |
bfd_size_type symesz; |
unsigned int i; |
file_ptr pos; |
|
output_bfd = flaginfo->output_bfd; |
|
if (h->root.type == bfd_link_hash_warning) |
{ |
h = (struct coff_link_hash_entry *) h->root.u.i.link; |
if (h->root.type == bfd_link_hash_new) |
return TRUE; |
} |
|
if (h->indx >= 0) |
return TRUE; |
|
if (h->indx != -2 |
&& (flaginfo->info->strip == strip_all |
|| (flaginfo->info->strip == strip_some |
&& (bfd_hash_lookup (flaginfo->info->keep_hash, |
h->root.root.string, FALSE, FALSE) |
== NULL)))) |
return TRUE; |
|
switch (h->root.type) |
{ |
default: |
case bfd_link_hash_new: |
case bfd_link_hash_warning: |
abort (); |
return FALSE; |
|
case bfd_link_hash_undefined: |
case bfd_link_hash_undefweak: |
isym.n_scnum = N_UNDEF; |
isym.n_value = 0; |
break; |
|
case bfd_link_hash_defined: |
case bfd_link_hash_defweak: |
{ |
asection *sec; |
|
sec = h->root.u.def.section->output_section; |
if (bfd_is_abs_section (sec)) |
isym.n_scnum = N_ABS; |
else |
isym.n_scnum = sec->target_index; |
isym.n_value = (h->root.u.def.value |
+ h->root.u.def.section->output_offset); |
if (! obj_pe (flaginfo->output_bfd)) |
isym.n_value += sec->vma; |
} |
break; |
|
case bfd_link_hash_common: |
isym.n_scnum = N_UNDEF; |
isym.n_value = h->root.u.c.size; |
break; |
|
case bfd_link_hash_indirect: |
/* Just ignore these. They can't be handled anyhow. */ |
return TRUE; |
} |
|
if (strlen (h->root.root.string) <= SYMNMLEN) |
strncpy (isym._n._n_name, h->root.root.string, SYMNMLEN); |
else |
{ |
bfd_boolean hash; |
bfd_size_type indx; |
|
hash = TRUE; |
if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0) |
hash = FALSE; |
indx = _bfd_stringtab_add (flaginfo->strtab, h->root.root.string, hash, |
FALSE); |
if (indx == (bfd_size_type) -1) |
{ |
flaginfo->failed = TRUE; |
return FALSE; |
} |
isym._n._n_n._n_zeroes = 0; |
isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx; |
} |
|
isym.n_sclass = h->symbol_class; |
isym.n_type = h->type; |
|
if (isym.n_sclass == C_NULL) |
isym.n_sclass = C_EXT; |
|
/* If doing task linking and this is the pass where we convert |
defined globals to statics, then do that conversion now. If the |
symbol is not being converted, just ignore it and it will be |
output during a later pass. */ |
if (flaginfo->global_to_static) |
{ |
if (! IS_EXTERNAL (output_bfd, isym)) |
return TRUE; |
|
isym.n_sclass = C_STAT; |
} |
|
/* When a weak symbol is not overridden by a strong one, |
turn it into an external symbol when not building a |
shared or relocatable object. */ |
if (! flaginfo->info->shared |
&& ! flaginfo->info->relocatable |
&& IS_WEAK_EXTERNAL (flaginfo->output_bfd, isym)) |
isym.n_sclass = C_EXT; |
|
isym.n_numaux = h->numaux; |
|
bfd_coff_swap_sym_out (output_bfd, &isym, flaginfo->outsyms); |
|
symesz = bfd_coff_symesz (output_bfd); |
|
pos = obj_sym_filepos (output_bfd); |
pos += obj_raw_syment_count (output_bfd) * symesz; |
if (bfd_seek (output_bfd, pos, SEEK_SET) != 0 |
|| bfd_bwrite (flaginfo->outsyms, symesz, output_bfd) != symesz) |
{ |
flaginfo->failed = TRUE; |
return FALSE; |
} |
|
h->indx = obj_raw_syment_count (output_bfd); |
|
++obj_raw_syment_count (output_bfd); |
|
/* Write out any associated aux entries. Most of the aux entries |
will have been modified in _bfd_coff_link_input_bfd. We have to |
handle section aux entries here, now that we have the final |
relocation and line number counts. */ |
for (i = 0; i < isym.n_numaux; i++) |
{ |
union internal_auxent *auxp; |
|
auxp = h->aux + i; |
|
/* Look for a section aux entry here using the same tests that |
coff_swap_aux_out uses. */ |
if (i == 0 |
&& (isym.n_sclass == C_STAT |
|| isym.n_sclass == C_HIDDEN) |
&& isym.n_type == T_NULL |
&& (h->root.type == bfd_link_hash_defined |
|| h->root.type == bfd_link_hash_defweak)) |
{ |
asection *sec; |
|
sec = h->root.u.def.section->output_section; |
if (sec != NULL) |
{ |
auxp->x_scn.x_scnlen = sec->size; |
|
/* For PE, an overflow on the final link reportedly does |
not matter. FIXME: Why not? */ |
if (sec->reloc_count > 0xffff |
&& (! obj_pe (output_bfd) |
|| flaginfo->info->relocatable)) |
(*_bfd_error_handler) |
(_("%s: %s: reloc overflow: 0x%lx > 0xffff"), |
bfd_get_filename (output_bfd), |
bfd_get_section_name (output_bfd, sec), |
sec->reloc_count); |
|
if (sec->lineno_count > 0xffff |
&& (! obj_pe (output_bfd) |
|| flaginfo->info->relocatable)) |
(*_bfd_error_handler) |
(_("%s: warning: %s: line number overflow: 0x%lx > 0xffff"), |
bfd_get_filename (output_bfd), |
bfd_get_section_name (output_bfd, sec), |
sec->lineno_count); |
|
auxp->x_scn.x_nreloc = sec->reloc_count; |
auxp->x_scn.x_nlinno = sec->lineno_count; |
auxp->x_scn.x_checksum = 0; |
auxp->x_scn.x_associated = 0; |
auxp->x_scn.x_comdat = 0; |
} |
} |
|
bfd_coff_swap_aux_out (output_bfd, auxp, isym.n_type, |
isym.n_sclass, (int) i, isym.n_numaux, |
flaginfo->outsyms); |
if (bfd_bwrite (flaginfo->outsyms, symesz, output_bfd) != symesz) |
{ |
flaginfo->failed = TRUE; |
return FALSE; |
} |
++obj_raw_syment_count (output_bfd); |
} |
|
return TRUE; |
} |
|
/* Write out task global symbols, converting them to statics. Called |
via coff_link_hash_traverse. Calls bfd_coff_write_global_sym to do |
the dirty work, if the symbol we are processing needs conversion. */ |
|
bfd_boolean |
_bfd_coff_write_task_globals (struct coff_link_hash_entry *h, void *data) |
{ |
struct coff_final_link_info *flaginfo = (struct coff_final_link_info *) data; |
bfd_boolean rtnval = TRUE; |
bfd_boolean save_global_to_static; |
|
if (h->root.type == bfd_link_hash_warning) |
h = (struct coff_link_hash_entry *) h->root.u.i.link; |
|
if (h->indx < 0) |
{ |
switch (h->root.type) |
{ |
case bfd_link_hash_defined: |
case bfd_link_hash_defweak: |
save_global_to_static = flaginfo->global_to_static; |
flaginfo->global_to_static = TRUE; |
rtnval = _bfd_coff_write_global_sym (&h->root.root, data); |
flaginfo->global_to_static = save_global_to_static; |
break; |
default: |
break; |
} |
} |
return (rtnval); |
} |
|
/* Handle a link order which is supposed to generate a reloc. */ |
|
bfd_boolean |
_bfd_coff_reloc_link_order (bfd *output_bfd, |
struct coff_final_link_info *flaginfo, |
asection *output_section, |
struct bfd_link_order *link_order) |
{ |
reloc_howto_type *howto; |
struct internal_reloc *irel; |
struct coff_link_hash_entry **rel_hash_ptr; |
|
howto = bfd_reloc_type_lookup (output_bfd, link_order->u.reloc.p->reloc); |
if (howto == NULL) |
{ |
bfd_set_error (bfd_error_bad_value); |
return FALSE; |
} |
|
if (link_order->u.reloc.p->addend != 0) |
{ |
bfd_size_type size; |
bfd_byte *buf; |
bfd_reloc_status_type rstat; |
bfd_boolean ok; |
file_ptr loc; |
|
size = bfd_get_reloc_size (howto); |
buf = (bfd_byte *) bfd_zmalloc (size); |
if (buf == NULL) |
return FALSE; |
|
rstat = _bfd_relocate_contents (howto, output_bfd, |
(bfd_vma) link_order->u.reloc.p->addend,\ |
buf); |
switch (rstat) |
{ |
case bfd_reloc_ok: |
break; |
default: |
case bfd_reloc_outofrange: |
abort (); |
case bfd_reloc_overflow: |
if (! ((*flaginfo->info->callbacks->reloc_overflow) |
(flaginfo->info, NULL, |
(link_order->type == bfd_section_reloc_link_order |
? bfd_section_name (output_bfd, |
link_order->u.reloc.p->u.section) |
: link_order->u.reloc.p->u.name), |
howto->name, link_order->u.reloc.p->addend, |
(bfd *) NULL, (asection *) NULL, (bfd_vma) 0))) |
{ |
free (buf); |
return FALSE; |
} |
break; |
} |
loc = link_order->offset * bfd_octets_per_byte (output_bfd); |
ok = bfd_set_section_contents (output_bfd, output_section, buf, |
loc, size); |
free (buf); |
if (! ok) |
return FALSE; |
} |
|
/* Store the reloc information in the right place. It will get |
swapped and written out at the end of the final_link routine. */ |
irel = (flaginfo->section_info[output_section->target_index].relocs |
+ output_section->reloc_count); |
rel_hash_ptr = (flaginfo->section_info[output_section->target_index].rel_hashes |
+ output_section->reloc_count); |
|
memset (irel, 0, sizeof (struct internal_reloc)); |
*rel_hash_ptr = NULL; |
|
irel->r_vaddr = output_section->vma + link_order->offset; |
|
if (link_order->type == bfd_section_reloc_link_order) |
{ |
/* We need to somehow locate a symbol in the right section. The |
symbol must either have a value of zero, or we must adjust |
the addend by the value of the symbol. FIXME: Write this |
when we need it. The old linker couldn't handle this anyhow. */ |
abort (); |
*rel_hash_ptr = NULL; |
irel->r_symndx = 0; |
} |
else |
{ |
struct coff_link_hash_entry *h; |
|
h = ((struct coff_link_hash_entry *) |
bfd_wrapped_link_hash_lookup (output_bfd, flaginfo->info, |
link_order->u.reloc.p->u.name, |
FALSE, FALSE, TRUE)); |
if (h != NULL) |
{ |
if (h->indx >= 0) |
irel->r_symndx = h->indx; |
else |
{ |
/* Set the index to -2 to force this symbol to get |
written out. */ |
h->indx = -2; |
*rel_hash_ptr = h; |
irel->r_symndx = 0; |
} |
} |
else |
{ |
if (! ((*flaginfo->info->callbacks->unattached_reloc) |
(flaginfo->info, link_order->u.reloc.p->u.name, (bfd *) NULL, |
(asection *) NULL, (bfd_vma) 0))) |
return FALSE; |
irel->r_symndx = 0; |
} |
} |
|
/* FIXME: Is this always right? */ |
irel->r_type = howto->type; |
|
/* r_size is only used on the RS/6000, which needs its own linker |
routines anyhow. r_extern is only used for ECOFF. */ |
|
/* FIXME: What is the right value for r_offset? Is zero OK? */ |
++output_section->reloc_count; |
|
return TRUE; |
} |
|
/* A basic reloc handling routine which may be used by processors with |
simple relocs. */ |
|
bfd_boolean |
_bfd_coff_generic_relocate_section (bfd *output_bfd, |
struct bfd_link_info *info, |
bfd *input_bfd, |
asection *input_section, |
bfd_byte *contents, |
struct internal_reloc *relocs, |
struct internal_syment *syms, |
asection **sections) |
{ |
struct internal_reloc *rel; |
struct internal_reloc *relend; |
|
rel = relocs; |
relend = rel + input_section->reloc_count; |
for (; rel < relend; rel++) |
{ |
long symndx; |
struct coff_link_hash_entry *h; |
struct internal_syment *sym; |
bfd_vma addend; |
bfd_vma val; |
reloc_howto_type *howto; |
bfd_reloc_status_type rstat; |
|
symndx = rel->r_symndx; |
|
if (symndx == -1) |
{ |
h = NULL; |
sym = NULL; |
} |
else if (symndx < 0 |
|| (unsigned long) symndx >= obj_raw_syment_count (input_bfd)) |
{ |
(*_bfd_error_handler) |
("%B: illegal symbol index %ld in relocs", input_bfd, symndx); |
return FALSE; |
} |
else |
{ |
h = obj_coff_sym_hashes (input_bfd)[symndx]; |
sym = syms + symndx; |
} |
|
/* COFF treats common symbols in one of two ways. Either the |
size of the symbol is included in the section contents, or it |
is not. We assume that the size is not included, and force |
the rtype_to_howto function to adjust the addend as needed. */ |
if (sym != NULL && sym->n_scnum != 0) |
addend = - sym->n_value; |
else |
addend = 0; |
|
howto = bfd_coff_rtype_to_howto (input_bfd, input_section, rel, h, |
sym, &addend); |
if (howto == NULL) |
return FALSE; |
|
/* If we are doing a relocatable link, then we can just ignore |
a PC relative reloc that is pcrel_offset. It will already |
have the correct value. If this is not a relocatable link, |
then we should ignore the symbol value. */ |
if (howto->pc_relative && howto->pcrel_offset) |
{ |
if (info->relocatable) |
continue; |
if (sym != NULL && sym->n_scnum != 0) |
addend += sym->n_value; |
} |
|
val = 0; |
|
if (h == NULL) |
{ |
asection *sec; |
|
if (symndx == -1) |
{ |
sec = bfd_abs_section_ptr; |
val = 0; |
} |
else |
{ |
sec = sections[symndx]; |
val = (sec->output_section->vma |
+ sec->output_offset |
+ sym->n_value); |
if (! obj_pe (input_bfd)) |
val -= sec->vma; |
} |
} |
else |
{ |
if (h->root.type == bfd_link_hash_defined |
|| h->root.type == bfd_link_hash_defweak) |
{ |
/* Defined weak symbols are a GNU extension. */ |
asection *sec; |
|
sec = h->root.u.def.section; |
val = (h->root.u.def.value |
+ sec->output_section->vma |
+ sec->output_offset); |
} |
|
else if (h->root.type == bfd_link_hash_undefweak) |
{ |
if (h->symbol_class == C_NT_WEAK && h->numaux == 1) |
{ |
/* See _Microsoft Portable Executable and Common Object |
File Format Specification_, section 5.5.3. |
Note that weak symbols without aux records are a GNU |
extension. |
FIXME: All weak externals are treated as having |
characteristic IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY (1). |
These behave as per SVR4 ABI: A library member |
will resolve a weak external only if a normal |
external causes the library member to be linked. |
See also linker.c: generic_link_check_archive_element. */ |
asection *sec; |
struct coff_link_hash_entry *h2 = |
h->auxbfd->tdata.coff_obj_data->sym_hashes[ |
h->aux->x_sym.x_tagndx.l]; |
|
if (!h2 || h2->root.type == bfd_link_hash_undefined) |
{ |
sec = bfd_abs_section_ptr; |
val = 0; |
} |
else |
{ |
sec = h2->root.u.def.section; |
val = h2->root.u.def.value |
+ sec->output_section->vma + sec->output_offset; |
} |
} |
else |
/* This is a GNU extension. */ |
val = 0; |
} |
|
else if (! info->relocatable) |
{ |
if (! ((*info->callbacks->undefined_symbol) |
(info, h->root.root.string, input_bfd, input_section, |
rel->r_vaddr - input_section->vma, TRUE))) |
return FALSE; |
} |
} |
|
if (info->base_file) |
{ |
/* Emit a reloc if the backend thinks it needs it. */ |
if (sym && pe_data (output_bfd)->in_reloc_p (output_bfd, howto)) |
{ |
/* Relocation to a symbol in a section which isn't |
absolute. We output the address here to a file. |
This file is then read by dlltool when generating the |
reloc section. Note that the base file is not |
portable between systems. We write out a bfd_vma here, |
and dlltool reads in a bfd_vma. */ |
bfd_vma addr = (rel->r_vaddr |
- input_section->vma |
+ input_section->output_offset |
+ input_section->output_section->vma); |
if (coff_data (output_bfd)->pe) |
addr -= pe_data(output_bfd)->pe_opthdr.ImageBase; |
if (fwrite (&addr, 1, sizeof (bfd_vma), (FILE *) info->base_file) |
!= sizeof (bfd_vma)) |
{ |
bfd_set_error (bfd_error_system_call); |
return FALSE; |
} |
} |
} |
|
rstat = _bfd_final_link_relocate (howto, input_bfd, input_section, |
contents, |
rel->r_vaddr - input_section->vma, |
val, addend); |
|
switch (rstat) |
{ |
default: |
abort (); |
case bfd_reloc_ok: |
break; |
case bfd_reloc_outofrange: |
(*_bfd_error_handler) |
(_("%B: bad reloc address 0x%lx in section `%A'"), |
input_bfd, input_section, (unsigned long) rel->r_vaddr); |
return FALSE; |
case bfd_reloc_overflow: |
{ |
const char *name; |
char buf[SYMNMLEN + 1]; |
|
if (symndx == -1) |
name = "*ABS*"; |
else if (h != NULL) |
name = NULL; |
else |
{ |
name = _bfd_coff_internal_syment_name (input_bfd, sym, buf); |
if (name == NULL) |
return FALSE; |
} |
|
if (! ((*info->callbacks->reloc_overflow) |
(info, (h ? &h->root : NULL), name, howto->name, |
(bfd_vma) 0, input_bfd, input_section, |
rel->r_vaddr - input_section->vma))) |
return FALSE; |
} |
} |
} |
return TRUE; |
} |