/* linker.c -- BFD linker routines
- Copyright (C) 1993, 1994, 1995 Free Software Foundation, Inc.
+ Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
+ Free Software Foundation, Inc.
Written by Steve Chamberlain and Ian Lance Taylor, Cygnus Support
This file is part of BFD, the Binary File Descriptor library.
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., 675 Mass Ave, Cambridge, MA 02139, USA. */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
#include "bfd.h"
#include "sysdep.h"
a.out (in <<aoutx.h>>) and ECOFF (in <<ecoff.c>>). The a.out
routines are used as examples throughout this section.
-@menu
+@menu
@* Creating a Linker Hash Table::
@* Adding Symbols to the Hash Table::
@* Performing the Final Link::
@cindex target vector (_bfd_link_hash_table_create)
The linker routines must create a hash table, which must be
derived from <<struct bfd_link_hash_table>> described in
- <<bfdlink.c>>. @xref{Hash Tables} for information on how to
+ <<bfdlink.c>>. @xref{Hash Tables}, for information on how to
create a derived hash table. This entry point is called using
the target vector of the linker output file.
is used to further controls which local symbols are included
in the output file. If the value is <<discard_l>>, then all
local symbols which begin with a certain prefix are discarded;
- this prefix is described by the <<lprefix>> and
- <<lprefix_len>> fields of the <<bfd_link_info>> structure.
+ this is controlled by the <<bfd_is_local_label_name>> entry point.
The a.out backend handles symbols by calling
<<aout_link_write_symbols>> on each input BFD and then
file at the end of <<NAME(aout,final_link)>>.
*/
-static struct bfd_hash_entry *generic_link_hash_newfunc
- PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *,
- const char *));
static boolean generic_link_read_symbols
PARAMS ((bfd *));
static boolean generic_link_add_symbols
static boolean generic_link_add_symbol_list
PARAMS ((bfd *, struct bfd_link_info *, bfd_size_type count, asymbol **,
boolean collect));
+static bfd *hash_entry_bfd PARAMS ((struct bfd_link_hash_entry *));
static void set_symbol_from_hash
PARAMS ((asymbol *, struct bfd_link_hash_entry *));
static boolean generic_add_output_symbol
PARAMS ((bfd *, size_t *psymalloc, asymbol *));
-static boolean default_fill_link_order
+static boolean default_data_link_order
PARAMS ((bfd *, struct bfd_link_info *, asection *,
struct bfd_link_order *));
static boolean default_indirect_link_order
struct bfd_hash_table *table;
const char *string;
{
- struct bfd_link_hash_entry *ret = (struct bfd_link_hash_entry *) entry;
-
/* Allocate the structure if it has not already been allocated by a
subclass. */
- if (ret == (struct bfd_link_hash_entry *) NULL)
- ret = ((struct bfd_link_hash_entry *)
- bfd_hash_allocate (table, sizeof (struct bfd_link_hash_entry)));
- if (ret == (struct bfd_link_hash_entry *) NULL)
+ if (entry == NULL)
{
- bfd_set_error (bfd_error_no_memory);
- return NULL;
+ entry = bfd_hash_allocate (table, sizeof (struct bfd_link_hash_entry));
+ if (entry == NULL)
+ return entry;
}
/* Call the allocation method of the superclass. */
- ret = ((struct bfd_link_hash_entry *)
- bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
-
- if (ret)
+ entry = bfd_hash_newfunc (entry, table, string);
+ if (entry)
{
+ struct bfd_link_hash_entry *h = (struct bfd_link_hash_entry *) entry;
+
/* Initialize the local fields. */
- ret->type = bfd_link_hash_new;
- ret->next = NULL;
+ h->type = bfd_link_hash_new;
+ h->next = NULL;
}
- return (struct bfd_hash_entry *) ret;
+ return entry;
}
/* Initialize a link hash table. The BFD argument is the one
table->creator = abfd->xvec;
table->undefs = NULL;
table->undefs_tail = NULL;
+ table->type = bfd_link_generic_hash_table;
+
return bfd_hash_table_init (&table->table, newfunc);
}
return ret;
}
+/* Look up a symbol in the main linker hash table if the symbol might
+ be wrapped. This should only be used for references to an
+ undefined symbol, not for definitions of a symbol. */
+
+struct bfd_link_hash_entry *
+bfd_wrapped_link_hash_lookup (abfd, info, string, create, copy, follow)
+ bfd *abfd;
+ struct bfd_link_info *info;
+ const char *string;
+ boolean create;
+ boolean copy;
+ boolean follow;
+{
+ bfd_size_type amt;
+
+ if (info->wrap_hash != NULL)
+ {
+ const char *l;
+
+ l = string;
+ if (*l == bfd_get_symbol_leading_char (abfd))
+ ++l;
+
+#undef WRAP
+#define WRAP "__wrap_"
+
+ if (bfd_hash_lookup (info->wrap_hash, l, false, false) != NULL)
+ {
+ char *n;
+ struct bfd_link_hash_entry *h;
+
+ /* This symbol is being wrapped. We want to replace all
+ references to SYM with references to __wrap_SYM. */
+
+ amt = strlen (l) + sizeof WRAP + 1;
+ n = (char *) bfd_malloc (amt);
+ if (n == NULL)
+ return NULL;
+
+ /* Note that symbol_leading_char may be '\0'. */
+ n[0] = bfd_get_symbol_leading_char (abfd);
+ n[1] = '\0';
+ strcat (n, WRAP);
+ strcat (n, l);
+ h = bfd_link_hash_lookup (info->hash, n, create, true, follow);
+ free (n);
+ return h;
+ }
+
+#undef WRAP
+
+#undef REAL
+#define REAL "__real_"
+
+ if (*l == '_'
+ && strncmp (l, REAL, sizeof REAL - 1) == 0
+ && bfd_hash_lookup (info->wrap_hash, l + sizeof REAL - 1,
+ false, false) != NULL)
+ {
+ char *n;
+ struct bfd_link_hash_entry *h;
+
+ /* This is a reference to __real_SYM, where SYM is being
+ wrapped. We want to replace all references to __real_SYM
+ with references to SYM. */
+
+ amt = strlen (l + sizeof REAL - 1) + 2;
+ n = (char *) bfd_malloc (amt);
+ if (n == NULL)
+ return NULL;
+
+ /* Note that symbol_leading_char may be '\0'. */
+ n[0] = bfd_get_symbol_leading_char (abfd);
+ n[1] = '\0';
+ strcat (n, l + sizeof REAL - 1);
+ h = bfd_link_hash_lookup (info->hash, n, create, true, follow);
+ free (n);
+ return h;
+ }
+
+#undef REAL
+ }
+
+ return bfd_link_hash_lookup (info->hash, string, create, copy, follow);
+}
+
/* Traverse a generic link hash table. The only reason this is not a
macro is to do better type checking. This code presumes that an
argument passed as a struct bfd_hash_entry * may be caught as a
struct bfd_link_hash_entry * with no explicit cast required on the
call. */
-void
+void
bfd_link_hash_traverse (table, func, info)
struct bfd_link_hash_table *table;
boolean (*func) PARAMS ((struct bfd_link_hash_entry *, PTR));
\f
/* Routine to create an entry in an generic link hash table. */
-static struct bfd_hash_entry *
-generic_link_hash_newfunc (entry, table, string)
+struct bfd_hash_entry *
+_bfd_generic_link_hash_newfunc (entry, table, string)
struct bfd_hash_entry *entry;
struct bfd_hash_table *table;
const char *string;
{
- struct generic_link_hash_entry *ret =
- (struct generic_link_hash_entry *) entry;
-
/* Allocate the structure if it has not already been allocated by a
subclass. */
- if (ret == (struct generic_link_hash_entry *) NULL)
- ret = ((struct generic_link_hash_entry *)
- bfd_hash_allocate (table, sizeof (struct generic_link_hash_entry)));
- if (ret == (struct generic_link_hash_entry *) NULL)
+ if (entry == NULL)
{
- bfd_set_error (bfd_error_no_memory);
- return NULL;
+ entry = bfd_hash_allocate (table,
+ sizeof (struct generic_link_hash_entry));
+ if (entry == NULL)
+ return entry;
}
/* Call the allocation method of the superclass. */
- ret = ((struct generic_link_hash_entry *)
- _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret,
- table, string));
-
- if (ret)
+ entry = _bfd_link_hash_newfunc (entry, table, string);
+ if (entry)
{
+ struct generic_link_hash_entry *ret;
+
/* Set local fields. */
+ ret = (struct generic_link_hash_entry *) entry;
ret->written = false;
ret->sym = NULL;
}
- return (struct bfd_hash_entry *) ret;
+ return entry;
}
/* Create an generic link hash table. */
bfd *abfd;
{
struct generic_link_hash_table *ret;
+ bfd_size_type amt = sizeof (struct generic_link_hash_table);
- ret = ((struct generic_link_hash_table *)
- malloc (sizeof (struct generic_link_hash_table)));
- if (!ret)
- {
- bfd_set_error (bfd_error_no_memory);
- return (struct bfd_link_hash_table *) NULL;
- }
+ ret = (struct generic_link_hash_table *) bfd_malloc (amt);
+ if (ret == NULL)
+ return (struct bfd_link_hash_table *) NULL;
if (! _bfd_link_hash_table_init (&ret->root, abfd,
- generic_link_hash_newfunc))
+ _bfd_generic_link_hash_newfunc))
{
free (ret);
return (struct bfd_link_hash_table *) NULL;
return &ret->root;
}
+void
+_bfd_generic_link_hash_table_free (hash)
+ struct bfd_link_hash_table *hash;
+{
+ struct generic_link_hash_table *ret
+ = (struct generic_link_hash_table *) hash;
+
+ bfd_hash_table_free (&ret->root.table);
+ free (ret);
+}
+
/* Grab the symbols for an object file when doing a generic link. We
store the symbols in the outsymbols field. We need to keep them
around for the entire link to ensure that we only read them once.
generic_link_read_symbols (abfd)
bfd *abfd;
{
- if (abfd->outsymbols == (asymbol **) NULL)
+ if (bfd_get_outsymbols (abfd) == (asymbol **) NULL)
{
long symsize;
long symcount;
symsize = bfd_get_symtab_upper_bound (abfd);
if (symsize < 0)
return false;
- abfd->outsymbols = (asymbol **) bfd_alloc (abfd, symsize);
- if (abfd->outsymbols == NULL && symsize != 0)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
- symcount = bfd_canonicalize_symtab (abfd, abfd->outsymbols);
+ bfd_get_outsymbols (abfd) =
+ (asymbol **) bfd_alloc (abfd, (bfd_size_type) symsize);
+ if (bfd_get_outsymbols (abfd) == NULL && symsize != 0)
+ return false;
+ symcount = bfd_canonicalize_symtab (abfd, bfd_get_outsymbols (abfd));
if (symcount < 0)
return false;
- abfd->symcount = symcount;
+ bfd_get_symcount (abfd) = symcount;
}
return true;
return generic_link_add_symbols (abfd, info, true);
}
+/* Indicate that we are only retrieving symbol values from this
+ section. We want the symbols to act as though the values in the
+ file are absolute. */
+
+void
+_bfd_generic_link_just_syms (sec, info)
+ asection *sec;
+ struct bfd_link_info *info ATTRIBUTE_UNUSED;
+{
+ sec->output_section = bfd_abs_section_ptr;
+ sec->output_offset = sec->vma;
+}
+
/* Add symbols from an object file to the global hash table. */
static boolean
struct bfd_link_info *info;
boolean collect;
{
+ bfd_size_type symcount;
+ struct symbol_cache_entry **outsyms;
+
if (! generic_link_read_symbols (abfd))
return false;
- return generic_link_add_symbol_list (abfd, info,
- _bfd_generic_link_get_symcount (abfd),
- _bfd_generic_link_get_symbols (abfd),
- collect);
+ symcount = _bfd_generic_link_get_symcount (abfd);
+ outsyms = _bfd_generic_link_get_symbols (abfd);
+ return generic_link_add_symbol_list (abfd, info, symcount, outsyms, collect);
}
\f
/* We build a hash table of all symbols defined in an archive. */
struct archive_list
{
struct archive_list *next;
- int indx;
+ unsigned int indx;
};
/* An entry in an archive hash table. */
ret = ((struct archive_hash_entry *)
bfd_hash_allocate (table, sizeof (struct archive_hash_entry)));
if (ret == (struct archive_hash_entry *) NULL)
- {
- bfd_set_error (bfd_error_no_memory);
- return NULL;
- }
+ return NULL;
/* Call the allocation method of the superclass. */
ret = ((struct archive_hash_entry *)
register carsym *arsym;
int pass;
struct archive_hash_table arsym_hash;
- int indx;
+ unsigned int indx;
struct bfd_link_hash_entry **pundef;
if (! bfd_has_map (abfd))
/* An empty archive is a special case. */
if (bfd_openr_next_archived_file (abfd, (bfd *) NULL) == NULL)
return true;
- bfd_set_error (bfd_error_no_symbols);
+ bfd_set_error (bfd_error_no_armap);
return false;
}
arh = archive_hash_lookup (&arsym_hash, h->root.string, false, false);
if (arh == (struct archive_hash_entry *) NULL)
{
- pundef = &(*pundef)->next;
- continue;
- }
+ /* If we haven't found the exact symbol we're looking for,
+ let's look for its import thunk */
+ if (info->pei386_auto_import)
+ {
+ bfd_size_type amt = strlen (h->root.string) + 10;
+ char *buf = (char *) bfd_malloc (amt);
+ if (buf == NULL)
+ return false;
+ sprintf (buf, "__imp_%s", h->root.string);
+ arh = archive_hash_lookup (&arsym_hash, buf, false, false);
+ free(buf);
+ }
+ if (arh == (struct archive_hash_entry *) NULL)
+ {
+ pundef = &(*pundef)->next;
+ continue;
+ }
+ }
/* Look at all the objects which define this symbol. */
for (l = arh->defs; l != (struct archive_list *) NULL; l = l->next)
{
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.p =
+ ((struct bfd_link_hash_common_entry *)
+ bfd_hash_allocate (&info->hash->table,
+ sizeof (struct bfd_link_hash_common_entry)));
+ if (h->u.c.p == NULL)
+ return false;
size = bfd_asymbol_value (p);
h->u.c.size = size;
- if (h->u.c.size != size)
- {
- /* The size did not fit in the bitfield. */
- bfd_set_error (bfd_error_bad_value);
- return false;
- }
power = bfd_log2 (size);
if (power > 4)
power = 4;
- h->u.c.alignment_power = power;
+ h->u.c.p->alignment_power = power;
if (p->section == bfd_com_section_ptr)
- h->u.c.section = bfd_make_section_old_way (symbfd, "COMMON");
+ h->u.c.p->section = bfd_make_section_old_way (symbfd, "COMMON");
else
- h->u.c.section = bfd_make_section_old_way (symbfd,
- p->section->name);
- h->u.c.section->flags = SEC_ALLOC;
+ h->u.c.p->section = bfd_make_section_old_way (symbfd,
+ p->section->name);
+ h->u.c.p->section->flags = SEC_ALLOC;
}
else
{
struct generic_link_hash_entry *h;
name = bfd_asymbol_name (p);
- if ((p->flags & BSF_INDIRECT) != 0
- || bfd_is_ind_section (p->section))
- string = bfd_asymbol_name ((asymbol *) p->value);
- else if ((p->flags & BSF_WARNING) != 0)
+ if (((p->flags & BSF_INDIRECT) != 0
+ || bfd_is_ind_section (p->section))
+ && pp + 1 < ppend)
+ {
+ pp++;
+ string = bfd_asymbol_name (*pp);
+ }
+ else if ((p->flags & BSF_WARNING) != 0
+ && pp + 1 < ppend)
{
/* The name of P is actually the warning string, and the
- value is actually a pointer to the symbol to warn
- about. */
+ next symbol is the one to warn about. */
string = name;
- name = bfd_asymbol_name ((asymbol *) p->value);
+ pp++;
+ name = bfd_asymbol_name (*pp);
}
else
string = NULL;
(struct bfd_link_hash_entry **) &h)))
return false;
+ /* If this is a constructor symbol, and the linker didn't do
+ anything with it, then we want to just pass the symbol
+ through to the output file. This will happen when
+ linking with -r. */
+ if ((p->flags & BSF_CONSTRUCTOR) != 0
+ && (h == NULL || h->root.type == bfd_link_hash_new))
+ {
+ p->udata.p = NULL;
+ continue;
+ }
+
/* Save the BFD symbol so that we don't lose any backend
specific information that may be attached to it. We only
want this one if it gives more information than the
if (bfd_is_com_section (bfd_get_section (p)))
p->flags |= BSF_OLD_COMMON;
}
-
- /* Store a back pointer from the symbol to the hash
- table entry for the benefit of relaxation code until
- it gets rewritten to not use asymbol structures.
- Setting this is also used to check whether these
- symbols were set up by the generic linker. */
- p->udata.p = (PTR) h;
}
+
+ /* Store a back pointer from the symbol to the hash
+ table entry for the benefit of relaxation code until
+ it gets rewritten to not use asymbol structures.
+ Setting this is also used to check whether these
+ symbols were set up by the generic linker. */
+ p->udata.p = (PTR) h;
}
}
enum link_action
{
- FAIL, /* Abort. */
+ FAIL, /* Abort. */
UND, /* Mark symbol undefined. */
WEAK, /* Mark symbol weak undefined. */
DEF, /* Mark symbol defined. */
static const enum link_action link_action[8][8] =
{
/* current\prev new undef undefw def defw com indr warn */
- /* UNDEF_ROW */ {UND, NOACT, NOACT, REF, REF, NOACT, REFC, WARNC },
- /* UNDEFW_ROW */ {WEAK, WEAK, NOACT, REF, REF, NOACT, REFC, WARNC },
+ /* UNDEF_ROW */ {UND, NOACT, UND, REF, REF, NOACT, REFC, WARNC },
+ /* UNDEFW_ROW */ {WEAK, NOACT, NOACT, REF, REF, NOACT, REFC, WARNC },
/* DEF_ROW */ {DEF, DEF, DEF, MDEF, DEF, CDEF, MDEF, CYCLE },
/* DEFW_ROW */ {DEFW, DEFW, DEFW, NOACT, NOACT, NOACT, NOACT, CYCLE },
- /* COMMON_ROW */ {COM, COM, COM, CREF, CREF, BIG, CREF, WARNC },
+ /* COMMON_ROW */ {COM, COM, COM, CREF, COM, BIG, REFC, WARNC },
/* INDR_ROW */ {IND, IND, IND, MDEF, IND, CIND, MIND, CYCLE },
- /* WARN_ROW */ {MWARN, WARN, WARN, CWARN, CWARN, WARN, CWARN, CYCLE },
+ /* WARN_ROW */ {MWARN, WARN, WARN, CWARN, CWARN, WARN, CWARN, NOACT },
/* SET_ROW */ {SET, SET, SET, SET, SET, SET, CYCLE, CYCLE }
};
Adding an entry to a set does not count as a reference to a set,
and no warning is issued (SET_ROW/warn). */
+/* Return the BFD in which a hash entry has been defined, if known. */
+
+static bfd *
+hash_entry_bfd (h)
+ struct bfd_link_hash_entry *h;
+{
+ while (h->type == bfd_link_hash_warning)
+ h = h->u.i.link;
+ switch (h->type)
+ {
+ default:
+ return NULL;
+ case bfd_link_hash_undefined:
+ case bfd_link_hash_undefweak:
+ return h->u.undef.abfd;
+ case bfd_link_hash_defined:
+ case bfd_link_hash_defweak:
+ return h->u.def.section->owner;
+ case bfd_link_hash_common:
+ return h->u.c.p->section->owner;
+ }
+ /*NOTREACHED*/
+}
+
/* Add a symbol to the global hash table.
ABFD is the BFD the symbol comes from.
NAME is the name of the symbol.
or destructor names as collect2 does.
HASHP, if not NULL, is a place to store the created hash table
entry; if *HASHP is not NULL, the caller has already looked up
- the hash table entry, and stored it in *HASHP. */
+ the hash table entry, and stored it in *HASHP. */
boolean
_bfd_generic_link_add_one_symbol (info, abfd, name, flags, section, value,
row = DEF_ROW;
if (hashp != NULL && *hashp != NULL)
- {
- h = *hashp;
- BFD_ASSERT (strcmp (h->root.string, name) == 0);
- }
+ h = *hashp;
else
{
- h = bfd_link_hash_lookup (info->hash, name, true, copy, false);
+ if (row == UNDEF_ROW || row == UNDEFW_ROW)
+ h = bfd_wrapped_link_hash_lookup (abfd, info, name, true, copy, false);
+ else
+ h = bfd_link_hash_lookup (info->hash, name, true, copy, false);
if (h == NULL)
{
if (hashp != NULL)
}
}
- if (info->notice_hash != (struct bfd_hash_table *) NULL
- && (bfd_hash_lookup (info->notice_hash, name, false, false)
- != (struct bfd_hash_entry *) NULL))
+ if (info->notice_all
+ || (info->notice_hash != (struct bfd_hash_table *) NULL
+ && (bfd_hash_lookup (info->notice_hash, name, false, false)
+ != (struct bfd_hash_entry *) NULL)))
{
- if (! (*info->callbacks->notice) (info, name, abfd, section, value))
+ if (! (*info->callbacks->notice) (info, h->root.string, abfd, section,
+ value))
return false;
}
previously common. */
BFD_ASSERT (h->type == bfd_link_hash_common);
if (! ((*info->callbacks->multiple_common)
- (info, name,
- h->u.c.section->owner, bfd_link_hash_common, h->u.c.size,
+ (info, h->root.string,
+ h->u.c.p->section->owner, bfd_link_hash_common, h->u.c.size,
abfd, bfd_link_hash_defined, (bfd_vma) 0)))
return false;
/* Fall through. */
case DEF:
case DEFW:
{
- enum bfd_link_order_type oldtype;
+ enum bfd_link_hash_type oldtype;
/* Define a symbol. */
oldtype = h->type;
abort ();
if (! ((*info->callbacks->constructor)
- (info,
- c == 'I' ? true : false,
- name, abfd, section, value)))
+ (info, c == 'I',
+ h->root.string, abfd, section, value)))
return false;
}
}
if (h->type == bfd_link_hash_new)
bfd_link_add_undef (info->hash, h);
h->type = bfd_link_hash_common;
+ h->u.c.p =
+ ((struct bfd_link_hash_common_entry *)
+ bfd_hash_allocate (&info->hash->table,
+ sizeof (struct bfd_link_hash_common_entry)));
+ if (h->u.c.p == NULL)
+ return false;
+
h->u.c.size = value;
- if (h->u.c.size != value)
- {
- /* The size did not fit in the bitfield. */
- bfd_set_error (bfd_error_bad_value);
- return false;
- }
/* Select a default alignment based on the size. This may
be overridden by the caller. */
power = bfd_log2 (value);
if (power > 4)
power = 4;
- h->u.c.alignment_power = power;
+ h->u.c.p->alignment_power = power;
}
/* The section of a common symbol is only used if the common
handling. */
if (section == bfd_com_section_ptr)
{
- h->u.c.section = bfd_make_section_old_way (abfd, "COMMON");
- h->u.c.section->flags = SEC_ALLOC;
+ h->u.c.p->section = bfd_make_section_old_way (abfd, "COMMON");
+ h->u.c.p->section->flags = SEC_ALLOC;
}
else if (section->owner != abfd)
{
- h->u.c.section = bfd_make_section_old_way (abfd, section->name);
- h->u.c.section->flags = SEC_ALLOC;
+ h->u.c.p->section = bfd_make_section_old_way (abfd,
+ section->name);
+ h->u.c.p->section->flags = SEC_ALLOC;
}
else
- h->u.c.section = section;
+ h->u.c.p->section = section;
break;
case REF:
case BIG:
/* We have found a common definition for a symbol which
already had a common definition. Use the maximum of the
- two sizes. */
+ two sizes, and use the section required by the larger symbol. */
BFD_ASSERT (h->type == bfd_link_hash_common);
if (! ((*info->callbacks->multiple_common)
- (info, name,
- h->u.c.section->owner, bfd_link_hash_common, h->u.c.size,
+ (info, h->root.string,
+ h->u.c.p->section->owner, bfd_link_hash_common, h->u.c.size,
abfd, bfd_link_hash_common, value)))
return false;
if (value > h->u.c.size)
power = bfd_log2 (value);
if (power > 4)
power = 4;
- h->u.c.alignment_power = power;
+ h->u.c.p->alignment_power = power;
+
+ /* Some systems have special treatment for small commons,
+ hence we want to select the section used by the larger
+ symbol. This makes sure the symbol does not go in a
+ small common section if it is now too large. */
+ if (section == bfd_com_section_ptr)
+ {
+ h->u.c.p->section
+ = bfd_make_section_old_way (abfd, "COMMON");
+ h->u.c.p->section->flags = SEC_ALLOC;
+ }
+ else if (section->owner != abfd)
+ {
+ h->u.c.p->section
+ = bfd_make_section_old_way (abfd, section->name);
+ h->u.c.p->section->flags = SEC_ALLOC;
+ }
+ else
+ h->u.c.p->section = section;
}
break;
else
obfd = NULL;
if (! ((*info->callbacks->multiple_common)
- (info, name, obfd, h->type, (bfd_vma) 0,
+ (info, h->root.string, obfd, h->type, (bfd_vma) 0,
abfd, bfd_link_hash_common, value)))
return false;
}
/* Fall through. */
case MDEF:
/* Handle a multiple definition. */
- {
- asection *msec;
- bfd_vma mval;
+ if (!info->allow_multiple_definition)
+ {
+ asection *msec = NULL;
+ bfd_vma mval = 0;
- switch (h->type)
- {
- case bfd_link_hash_defined:
- msec = h->u.def.section;
- mval = h->u.def.value;
- break;
- case bfd_link_hash_indirect:
- msec = bfd_ind_section_ptr;
- mval = 0;
- break;
- default:
- abort ();
- }
+ switch (h->type)
+ {
+ case bfd_link_hash_defined:
+ msec = h->u.def.section;
+ mval = h->u.def.value;
+ break;
+ case bfd_link_hash_indirect:
+ msec = bfd_ind_section_ptr;
+ mval = 0;
+ break;
+ default:
+ abort ();
+ }
- /* Ignore a redefinition of an absolute symbol to the same
- value; it's harmless. */
- if (h->type == bfd_link_hash_defined
- && bfd_is_abs_section (msec)
- && bfd_is_abs_section (section)
- && value == mval)
- break;
+ /* Ignore a redefinition of an absolute symbol to the
+ same value; it's harmless. */
+ if (h->type == bfd_link_hash_defined
+ && bfd_is_abs_section (msec)
+ && bfd_is_abs_section (section)
+ && value == mval)
+ break;
- if (! ((*info->callbacks->multiple_definition)
- (info, name, msec->owner, msec, mval, abfd, section,
- value)))
- return false;
- }
+ if (! ((*info->callbacks->multiple_definition)
+ (info, h->root.string, msec->owner, msec, mval,
+ abfd, section, value)))
+ return false;
+ }
break;
case CIND:
/* Create an indirect symbol from an existing common symbol. */
BFD_ASSERT (h->type == bfd_link_hash_common);
if (! ((*info->callbacks->multiple_common)
- (info, name,
- h->u.c.section->owner, bfd_link_hash_common, h->u.c.size,
+ (info, h->root.string,
+ h->u.c.p->section->owner, bfd_link_hash_common, h->u.c.size,
abfd, bfd_link_hash_indirect, (bfd_vma) 0)))
return false;
/* Fall through. */
/* STRING is the name of the symbol we want to indirect
to. */
- inh = bfd_link_hash_lookup (info->hash, string, true, copy,
- false);
+ inh = bfd_wrapped_link_hash_lookup (abfd, info, string, true,
+ copy, false);
if (inh == (struct bfd_link_hash_entry *) NULL)
return false;
+ if (inh->type == bfd_link_hash_indirect
+ && inh->u.i.link == h)
+ {
+ (*_bfd_error_handler)
+ (_("%s: indirect symbol `%s' to `%s' is a loop"),
+ bfd_archive_filename (abfd), name, string);
+ bfd_set_error (bfd_error_invalid_operation);
+ return false;
+ }
if (inh->type == bfd_link_hash_new)
{
inh->type = bfd_link_hash_undefined;
/* Issue a warning and cycle. */
if (h->u.i.warning != NULL)
{
- if (! (*info->callbacks->warning) (info, h->u.i.warning))
+ if (! (*info->callbacks->warning) (info, h->u.i.warning,
+ h->root.string, abfd,
+ (asection *) NULL,
+ (bfd_vma) 0))
return false;
/* Only issue a warning once. */
h->u.i.warning = NULL;
case WARN:
/* Issue a warning. */
- if (! (*info->callbacks->warning) (info, string))
+ if (! (*info->callbacks->warning) (info, string, h->root.string,
+ hash_entry_bfd (h),
+ (asection *) NULL, (bfd_vma) 0))
return false;
break;
ensure this. */
if (h->next != NULL || info->hash->undefs_tail == h)
{
- if (! (*info->callbacks->warning) (info, string))
+ if (! (*info->callbacks->warning) (info, string, h->root.string,
+ hash_entry_bfd (h),
+ (asection *) NULL,
+ (bfd_vma) 0))
return false;
break;
}
/* STRING is the warning to give. */
sub = ((struct bfd_link_hash_entry *)
- bfd_hash_allocate (&info->hash->table,
- sizeof (struct bfd_link_hash_entry)));
- if (!sub)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ ((*info->hash->table.newfunc)
+ ((struct bfd_hash_entry *) NULL, &info->hash->table,
+ h->root.string)));
+ if (sub == NULL)
+ return false;
*sub = *h;
- h->type = bfd_link_hash_warning;
- h->u.i.link = sub;
+ sub->type = bfd_link_hash_warning;
+ sub->u.i.link = h;
if (! copy)
- h->u.i.warning = string;
+ sub->u.i.warning = string;
else
{
char *w;
+ size_t len = strlen (string) + 1;
- w = bfd_hash_allocate (&info->hash->table,
- strlen (string) + 1);
- strcpy (w, string);
- h->u.i.warning = w;
+ w = bfd_hash_allocate (&info->hash->table, len);
+ if (w == NULL)
+ return false;
+ memcpy (w, string, len);
+ sub->u.i.warning = w;
}
+
+ bfd_hash_replace (&info->hash->table,
+ (struct bfd_hash_entry *) h,
+ (struct bfd_hash_entry *) sub);
+ if (hashp != NULL)
+ *hashp = sub;
}
break;
}
size_t outsymalloc;
struct generic_write_global_symbol_info wginfo;
- abfd->outsymbols = (asymbol **) NULL;
- abfd->symcount = 0;
+ bfd_get_outsymbols (abfd) = (asymbol **) NULL;
+ bfd_get_symcount (abfd) = 0;
outsymalloc = 0;
+ /* Mark all sections which will be included in the output file. */
+ for (o = abfd->sections; o != NULL; o = o->next)
+ for (p = o->link_order_head; p != NULL; p = p->next)
+ if (p->type == bfd_indirect_link_order)
+ p->u.indirect.section->linker_mark = true;
+
/* Build the output symbol table. */
for (sub = info->input_bfds; sub != (bfd *) NULL; sub = sub->link_next)
if (! _bfd_generic_link_output_symbols (abfd, sub, info, &outsymalloc))
_bfd_generic_link_write_global_symbol,
(PTR) &wginfo);
+ /* Make sure we have a trailing NULL pointer on OUTSYMBOLS. We
+ shouldn't really need one, since we have SYMCOUNT, but some old
+ code still expects one. */
+ if (! generic_add_output_symbol (abfd, &outsymalloc, NULL))
+ return false;
+
if (info->relocateable)
{
/* Allocate space for the output relocs for each section. */
input_section);
if (relsize < 0)
return false;
- relocs = (arelent **) malloc ((size_t) relsize);
+ relocs = (arelent **) bfd_malloc ((bfd_size_type) relsize);
if (!relocs && relsize != 0)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ return false;
symbols = _bfd_generic_link_get_symbols (input_bfd);
reloc_count = bfd_canonicalize_reloc (input_bfd,
input_section,
symbols);
if (reloc_count < 0)
return false;
- BFD_ASSERT (reloc_count == input_section->reloc_count);
+ BFD_ASSERT ((unsigned long) 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 *))));
+ bfd_size_type amt;
+
+ amt = o->reloc_count;
+ amt *= sizeof (arelent *);
+ o->orelocation = (arelent **) bfd_alloc (abfd, amt);
if (!o->orelocation)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ return false;
o->flags |= SEC_RELOC;
/* Reset the count so that it can be used as an index
when putting in the output relocs. */
size_t *psymalloc;
asymbol *sym;
{
- if (output_bfd->symcount >= *psymalloc)
+ if (bfd_get_symcount (output_bfd) >= *psymalloc)
{
asymbol **newsyms;
+ bfd_size_type amt;
if (*psymalloc == 0)
*psymalloc = 124;
else
*psymalloc *= 2;
- if (output_bfd->outsymbols == (asymbol **) NULL)
- newsyms = (asymbol **) malloc (*psymalloc * sizeof (asymbol *));
- else
- newsyms = (asymbol **) realloc (output_bfd->outsymbols,
- *psymalloc * sizeof (asymbol *));
+ amt = *psymalloc;
+ amt *= sizeof (asymbol *);
+ newsyms = (asymbol **) bfd_realloc (bfd_get_outsymbols (output_bfd), amt);
if (newsyms == (asymbol **) NULL)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
- output_bfd->outsymbols = newsyms;
+ return false;
+ bfd_get_outsymbols (output_bfd) = newsyms;
}
- output_bfd->outsymbols[output_bfd->symcount] = sym;
- ++output_bfd->symcount;
+ bfd_get_outsymbols (output_bfd) [bfd_get_symcount (output_bfd)] = sym;
+ if (sym != NULL)
+ ++ bfd_get_symcount (output_bfd);
return true;
}
|| bfd_is_com_section (bfd_get_section (sym))
|| bfd_is_ind_section (bfd_get_section (sym)))
{
- h = _bfd_generic_link_hash_lookup (_bfd_generic_hash_table (info),
- bfd_asymbol_name (sym),
- false, false, true);
+ if (sym->udata.p != NULL)
+ h = (struct generic_link_hash_entry *) sym->udata.p;
+ else if ((sym->flags & BSF_CONSTRUCTOR) != 0)
+ {
+ /* This case normally means that the main linker code
+ deliberately ignored this constructor symbol. We
+ should just pass it through. This will screw up if
+ the constructor symbol is from a different,
+ non-generic, object file format, but the case will
+ only arise when linking with -r, which will probably
+ fail anyhow, since there will be no way to represent
+ the relocs in the output format being used. */
+ h = NULL;
+ }
+ else if (bfd_is_und_section (bfd_get_section (sym)))
+ h = ((struct generic_link_hash_entry *)
+ bfd_wrapped_link_hash_lookup (output_bfd, info,
+ bfd_asymbol_name (sym),
+ false, false, true));
+ else
+ h = _bfd_generic_link_hash_lookup (_bfd_generic_hash_table (info),
+ bfd_asymbol_name (sym),
+ false, false, true);
+
if (h != (struct generic_link_hash_entry *) NULL)
{
/* Force all references to this symbol to point to
case bfd_link_hash_undefweak:
sym->flags |= BSF_WEAK;
break;
+ case bfd_link_hash_indirect:
+ h = (struct generic_link_hash_entry *) h->root.u.i.link;
+ /* fall through */
case bfd_link_hash_defined:
sym->flags |= BSF_GLOBAL;
+ sym->flags &=~ BSF_CONSTRUCTOR;
sym->value = h->root.u.def.value;
sym->section = h->root.u.def.section;
break;
case bfd_link_hash_defweak:
sym->flags |= BSF_WEAK;
+ sym->flags &=~ BSF_CONSTRUCTOR;
sym->value = h->root.u.def.value;
sym->section = h->root.u.def.section;
break;
sym->section = bfd_com_section_ptr;
}
/* We do not set the section of the symbol to
- h->root.u.c.section. That value was saved so
+ h->root.u.c.p->section. That value was saved so
that we would know where to allocate the symbol
if it was defined. In this case the type is
still bfd_link_hash_common, so we did not define
/* This switch is straight from the old code in
write_file_locals in ldsym.c. */
- if (info->strip == strip_some
- && (bfd_hash_lookup (info->keep_hash, bfd_asymbol_name (sym),
- false, false)
- == (struct bfd_hash_entry *) NULL))
+ if (info->strip == strip_all
+ || (info->strip == strip_some
+ && (bfd_hash_lookup (info->keep_hash, bfd_asymbol_name (sym),
+ false, false)
+ == (struct bfd_hash_entry *) NULL)))
output = false;
else if ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0)
{
case discard_all:
output = false;
break;
+ case discard_sec_merge:
+ output = true;
+ if (info->relocateable
+ || ! (sym->section->flags & SEC_MERGE))
+ break;
+ /* FALLTHROUGH */
case discard_l:
- if (bfd_asymbol_name (sym)[0] == info->lprefix[0]
- && (info->lprefix_len == 1
- || strncmp (bfd_asymbol_name (sym), info->lprefix,
- info->lprefix_len) == 0))
+ if (bfd_is_local_label (input_bfd, sym))
output = false;
else
output = true;
else
abort ();
+ /* If this symbol is in a section which is not being included
+ in the output file, then we don't want to output the symbol.
+
+ Gross. .bss and similar sections won't have the linker_mark
+ field set. */
+ if ((sym->section->flags & SEC_HAS_CONTENTS) != 0
+ && ! sym->section->linker_mark)
+ output = false;
+
if (output)
{
if (! generic_add_output_symbol (output_bfd, psymalloc, sym))
switch (h->type)
{
default:
- case bfd_link_hash_new:
abort ();
+ break;
+ case bfd_link_hash_new:
+ /* This can happen when a constructor symbol is seen but we are
+ not building constructors. */
+ if (sym->section != NULL)
+ {
+ BFD_ASSERT ((sym->flags & BSF_CONSTRUCTOR) != 0);
+ }
+ else
+ {
+ sym->flags |= BSF_CONSTRUCTOR;
+ sym->section = bfd_abs_section_ptr;
+ sym->value = 0;
+ }
+ break;
case bfd_link_hash_undefined:
sym->section = bfd_und_section_ptr;
sym->value = 0;
(struct generic_write_global_symbol_info *) data;
asymbol *sym;
+ if (h->root.type == bfd_link_hash_warning)
+ h = (struct generic_link_hash_entry *) h->root.u.i.link;
+
if (h->written)
return true;
return true;
if (h->sym != (asymbol *) NULL)
- {
- sym = h->sym;
- BFD_ASSERT (strcmp (bfd_asymbol_name (sym), h->root.root.string) == 0);
- }
+ sym = h->sym;
else
{
sym = bfd_make_empty_symbol (wginfo->output_bfd);
if (sec->orelocation == (arelent **) NULL)
abort ();
- r = (arelent *) bfd_alloc (abfd, sizeof (arelent));
+ r = (arelent *) bfd_alloc (abfd, (bfd_size_type) sizeof (arelent));
if (r == (arelent *) NULL)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
-
+ return false;
+
r->address = link_order->offset;
r->howto = bfd_reloc_type_lookup (abfd, link_order->u.reloc.p->reloc);
if (r->howto == 0)
{
struct generic_link_hash_entry *h;
- h = _bfd_generic_link_hash_lookup (_bfd_generic_hash_table (info),
+ h = ((struct generic_link_hash_entry *)
+ bfd_wrapped_link_hash_lookup (abfd, info,
link_order->u.reloc.p->u.name,
- false, false, true);
+ false, false, true));
if (h == (struct generic_link_hash_entry *) NULL
|| ! h->written)
{
bfd_reloc_status_type rstat;
bfd_byte *buf;
boolean ok;
+ file_ptr loc;
size = bfd_get_reloc_size (r->howto);
buf = (bfd_byte *) bfd_zmalloc (size);
if (buf == (bfd_byte *) NULL)
- {
- bfd_set_error (bfd_error_no_memory);
- return false;
- }
+ return false;
rstat = _bfd_relocate_contents (r->howto, abfd,
- link_order->u.reloc.p->addend, buf);
+ (bfd_vma) link_order->u.reloc.p->addend,
+ buf);
switch (rstat)
{
case bfd_reloc_ok:
}
break;
}
- ok = bfd_set_section_contents (abfd, sec, (PTR) buf,
- (file_ptr) link_order->offset, size);
+ loc = link_order->offset * bfd_octets_per_byte (abfd);
+ ok = bfd_set_section_contents (abfd, sec, (PTR) buf, loc,
+ (bfd_size_type) size);
free (buf);
if (! ok)
return false;
bfd *abfd;
asection *section;
{
+ bfd_size_type amt = sizeof (struct bfd_link_order);
struct bfd_link_order *new;
- new = ((struct bfd_link_order *)
- bfd_alloc_by_size_t (abfd, sizeof (struct bfd_link_order)));
+ new = (struct bfd_link_order *) bfd_zalloc (abfd, amt);
if (!new)
- {
- bfd_set_error (bfd_error_no_memory);
- return NULL;
- }
+ return NULL;
new->type = bfd_undefined_link_order;
- new->offset = 0;
- new->size = 0;
- new->next = (struct bfd_link_order *) NULL;
if (section->link_order_tail != (struct bfd_link_order *) NULL)
section->link_order_tail->next = new;
case bfd_indirect_link_order:
return default_indirect_link_order (abfd, info, sec, link_order,
false);
- case bfd_fill_link_order:
- return default_fill_link_order (abfd, info, sec, link_order);
case bfd_data_link_order:
- return bfd_set_section_contents (abfd, sec,
- (PTR) link_order->u.data.contents,
- (file_ptr) link_order->offset,
- link_order->size);
+ return default_data_link_order (abfd, info, sec, link_order);
}
}
-/* Default routine to handle a bfd_fill_link_order. */
+/* Default routine to handle a bfd_data_link_order. */
-/*ARGSUSED*/
static boolean
-default_fill_link_order (abfd, info, sec, link_order)
+default_data_link_order (abfd, info, sec, link_order)
bfd *abfd;
- struct bfd_link_info *info;
+ struct bfd_link_info *info ATTRIBUTE_UNUSED;
asection *sec;
struct bfd_link_order *link_order;
{
- size_t size;
- char *space;
- size_t i;
- int fill;
+ bfd_size_type size;
+ size_t fill_size;
+ bfd_byte *fill;
+ file_ptr loc;
boolean result;
BFD_ASSERT ((sec->flags & SEC_HAS_CONTENTS) != 0);
- size = (size_t) link_order->size;
- space = (char *) malloc (size);
- if (space == NULL && size != 0)
+ size = link_order->size;
+ if (size == 0)
+ return true;
+
+ fill = link_order->u.data.contents;
+ fill_size = link_order->u.data.size;
+ if (fill_size != 0 && fill_size < size)
{
- bfd_set_error (bfd_error_no_memory);
- return false;
+ bfd_byte *p;
+ fill = (bfd_byte *) bfd_malloc (size);
+ if (fill == NULL)
+ return false;
+ p = fill;
+ if (fill_size == 1)
+ memset (p, (int) link_order->u.data.contents[0], (size_t) size);
+ else
+ {
+ do
+ {
+ memcpy (p, link_order->u.data.contents, fill_size);
+ p += fill_size;
+ size -= fill_size;
+ }
+ while (size >= fill_size);
+ if (size != 0)
+ memcpy (p, link_order->u.data.contents, (size_t) size);
+ size = link_order->size;
+ }
}
- fill = link_order->u.fill.value;
- for (i = 0; i < size; i += 2)
- space[i] = fill >> 8;
- for (i = 1; i < size; i += 2)
- space[i] = fill;
- result = bfd_set_section_contents (abfd, sec, space,
- (file_ptr) link_order->offset,
- link_order->size);
- free (space);
+ loc = link_order->offset * bfd_octets_per_byte (abfd);
+ result = bfd_set_section_contents (abfd, sec, fill, loc, size);
+
+ if (fill != link_order->u.data.contents)
+ free (fill);
return result;
}
bfd *input_bfd;
bfd_byte *contents = NULL;
bfd_byte *new_contents;
+ bfd_size_type sec_size;
+ file_ptr loc;
BFD_ASSERT ((output_section->flags & SEC_HAS_CONTENTS) != 0);
because somebody is attempting to link together different
types of object files. Handling this case correctly is
difficult, and sometimes impossible. */
- abort ();
+ (*_bfd_error_handler)
+ (_("Attempt to do relocateable link with %s input and %s output"),
+ bfd_get_target (input_bfd), bfd_get_target (output_bfd));
+ bfd_set_error (bfd_error_wrong_format);
+ return false;
}
if (! generic_linker)
generic_link_add_symbol_list. */
if (sym->udata.p != NULL)
h = (struct bfd_link_hash_entry *) sym->udata.p;
+ else if (bfd_is_und_section (bfd_get_section (sym)))
+ h = bfd_wrapped_link_hash_lookup (output_bfd, info,
+ bfd_asymbol_name (sym),
+ false, false, true);
else
h = bfd_link_hash_lookup (info->hash,
bfd_asymbol_name (sym),
if (h != NULL)
set_symbol_from_hash (sym, h);
}
- }
+ }
}
/* Get and relocate the section contents. */
- contents = (bfd_byte *) malloc (bfd_section_size (input_bfd, input_section));
- if (contents == NULL && bfd_section_size (input_bfd, input_section) != 0)
- {
- bfd_set_error (bfd_error_no_memory);
- goto error_return;
- }
+ sec_size = bfd_section_size (input_bfd, input_section);
+ contents = ((bfd_byte *) bfd_malloc (sec_size));
+ if (contents == NULL && sec_size != 0)
+ goto error_return;
new_contents = (bfd_get_relocated_section_contents
(output_bfd, info, link_order, contents, info->relocateable,
_bfd_generic_link_get_symbols (input_bfd)));
goto error_return;
/* Output the section contents. */
+ loc = link_order->offset * bfd_octets_per_byte (output_bfd);
if (! bfd_set_section_contents (output_bfd, output_section,
- (PTR) new_contents,
- link_order->offset, link_order->size))
+ (PTR) new_contents, loc, link_order->size))
goto error_return;
if (contents != NULL)
return c;
}
+
+/*
+FUNCTION
+ bfd_link_split_section
+
+SYNOPSIS
+ boolean bfd_link_split_section(bfd *abfd, asection *sec);
+
+DESCRIPTION
+ Return nonzero if @var{sec} should be split during a
+ reloceatable or final link.
+
+.#define bfd_link_split_section(abfd, sec) \
+. BFD_SEND (abfd, _bfd_link_split_section, (abfd, sec))
+.
+
+*/
+
+boolean
+_bfd_generic_link_split_section (abfd, sec)
+ bfd *abfd ATTRIBUTE_UNUSED;
+ asection *sec ATTRIBUTE_UNUSED;
+{
+ return false;
+}
projects / deliverable / binutils-gdb.git / blobdiff