/* linker.c -- BFD linker routines
- Copyright (C) 1993, 94 Free Software Foundation, Inc.
+ Copyright (C) 1993, 1994, 1995 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.
add, notably symbol flags, a section, and an offset. The
symbol flags include such things as <<BSF_WEAK>> or
<<BSF_INDIRECT>>. The section is a section in the object
- file, or something like <<bfd_und_section>> for an undefined
- symbol or <<bfd_com_section>> for a common symbol.
+ file, or something like <<bfd_und_section_ptr>> for an undefined
+ symbol or <<bfd_com_section_ptr>> for a common symbol.
If the <<_bfd_final_link>> routine is also going to need to
read the symbol information, the <<_bfd_link_add_symbols>>
written out when considering the symbols of each input file,
but it is still necessary to traverse the hash table since the
linker script may have defined some symbols that are not in
- any of the input files. The <<written>> field in the
- <<bfd_link_hash_entry>> structure may be used to determine
- which entries in the hash table have not already been written
- out.
+ any of the input files.
The <<strip>> field of the <<bfd_link_info>> structure
controls which symbols are written out. The possible values
static boolean generic_link_add_symbol_list
PARAMS ((bfd *, struct bfd_link_info *, bfd_size_type count, asymbol **,
boolean collect));
+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
struct bfd_link_order *));
static boolean default_indirect_link_order
PARAMS ((bfd *, struct bfd_link_info *, asection *,
- struct bfd_link_order *));
+ struct bfd_link_order *, boolean));
/* The link hash table structure is defined in bfdlink.h. It provides
a base hash table which the backend specific hash tables are built
((struct archive_hash_entry *) \
bfd_hash_lookup (&(t)->table, (string), (create), (copy)))
+/* Allocate space in an archive hash table. */
+
+#define archive_hash_allocate(t, size) bfd_hash_allocate (&(t)->table, (size))
+
/* Free an archive hash table. */
#define archive_hash_table_free(t) bfd_hash_table_free (&(t)->table)
if (! bfd_has_map (abfd))
{
- bfd_set_error (bfd_error_no_symbols);
+ /* 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_armap);
return false;
}
arh = archive_hash_lookup (&arsym_hash, arsym->name, true, false);
if (arh == (struct archive_hash_entry *) NULL)
goto error_return;
- l = (struct archive_list *)
- obstack_alloc (&(&(&arsym_hash)->table)->memory,
- sizeof (struct archive_list));
+ l = ((struct archive_list *)
+ archive_hash_allocate (&arsym_hash, sizeof (struct archive_list)));
if (l == NULL)
- {
- bfd_set_error (bfd_error_no_memory);
- goto error_return;
- }
+ goto error_return;
l->indx = indx;
for (pp = &arh->defs;
*pp != (struct archive_list *) NULL;
l->next = NULL;
}
- pass = 1;
+ /* The archive_pass field in the archive itself is used to
+ initialize PASS, sine we may search the same archive multiple
+ times. */
+ pass = abfd->archive_pass + 1;
/* New undefined symbols are added to the end of the list, so we
only need to look through it once. */
and because we are going to look through the list again
if we search any more libraries. We can't remove the
entry if it is the tail, because that would lose any
- entries we add to the list later on. */
+ entries we add to the list later on (it would also cause
+ us to lose track of whether the symbol has been
+ referenced). */
if (*pundef != info->hash->undefs_tail)
*pundef = (*pundef)->next;
else
archive_hash_table_free (&arsym_hash);
+ /* Save PASS in case we are called again. */
+ abfd->archive_pass = pass;
+
return true;
error_return:
/* We are only interested if we know something about this
symbol, and it is undefined or common. An undefined weak
- symbol (type bfd_link_hash_weak) is not considered to be a
- reference when pulling files out of an archive. See the SVR4
- ABI, p. 4-27. */
+ symbol (type bfd_link_hash_undefweak) is not considered to be
+ a reference when pulling files out of an archive. See the
+ SVR4 ABI, p. 4-27. */
h = bfd_link_hash_lookup (info->hash, bfd_asymbol_name (p), false,
false, true);
if (h == (struct bfd_link_hash_entry *) NULL
if (h->type == bfd_link_hash_undefined)
{
bfd *symbfd;
+ bfd_vma size;
+ unsigned int power;
symbfd = h->u.undef.abfd;
if (symbfd == (bfd *) NULL)
attached to symbfd to ensure that it is in a BFD which
will be linked in. */
h->type = bfd_link_hash_common;
- h->u.c.size = bfd_asymbol_value (p);
- if (p->section == &bfd_com_section)
- h->u.c.section = bfd_make_section_old_way (symbfd, "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;
+
+ power = bfd_log2 (size);
+ if (power > 4)
+ power = 4;
+ h->u.c.p->alignment_power = power;
+
+ if (p->section == bfd_com_section_ptr)
+ 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
{
| BSF_GLOBAL
| BSF_CONSTRUCTOR
| BSF_WEAK)) != 0
- || bfd_get_section (p) == &bfd_und_section
+ || bfd_is_und_section (bfd_get_section (p))
|| bfd_is_com_section (bfd_get_section (p))
- || bfd_get_section (p) == &bfd_ind_section)
+ || bfd_is_ind_section (bfd_get_section (p)))
{
const char *name;
const char *string;
name = bfd_asymbol_name (p);
if ((p->flags & BSF_INDIRECT) != 0
- || p->section == &bfd_ind_section)
+ || bfd_is_ind_section (p->section))
string = bfd_asymbol_name ((asymbol *) p->value);
else if ((p->flags & BSF_WARNING) != 0)
{
(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 (info->hash->creator == abfd->xvec)
{
if (h->sym == (asymbol *) NULL
- || (bfd_get_section (p) != &bfd_und_section
+ || (! bfd_is_und_section (bfd_get_section (p))
&& (! bfd_is_com_section (bfd_get_section (p))
- || (bfd_get_section (h->sym) == &bfd_und_section))))
+ || bfd_is_und_section (bfd_get_section (h->sym)))))
{
h->sym = p;
/* BSF_OLD_COMMON is a hack to support COFF reloc
/* 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. */
- p->udata = (PTR) h;
+ 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;
}
}
}
SET_ROW /* Member of set. */
};
+/* apparently needed for Hitachi 3050R(HI-UX/WE2)? */
+#undef FAIL
+
/* The actions to take in the state table. */
enum link_action
UND, /* Mark symbol undefined. */
WEAK, /* Mark symbol weak undefined. */
DEF, /* Mark symbol defined. */
+ DEFW, /* Mark symbol weak defined. */
COM, /* Mark symbol common. */
+ REF, /* Mark defined symbol referenced. */
CREF, /* Possibly warn about common reference to defined symbol. */
CDEF, /* Define existing common symbol. */
NOACT, /* No action. */
BIG, /* Mark symbol common using largest size. */
MDEF, /* Multiple definition error. */
+ MIND, /* Multiple indirect symbols. */
IND, /* Make indirect symbol. */
+ CIND, /* Make indirect symbol from existing common symbol. */
SET, /* Add value to set. */
MWARN, /* Make warning symbol. */
WARN, /* Issue warning. */
+ CWARN, /* Warn if referenced, else MWARN. */
CYCLE, /* Repeat with symbol pointed to. */
+ REFC, /* Mark indirect symbol referenced and then CYCLE. */
WARNC /* Issue warning and then CYCLE. */
};
/* The state table itself. The first index is a link_row and the
second index is a bfd_link_hash_type. */
-static const enum link_action link_action[8][7] =
+static const enum link_action link_action[8][8] =
{
- /* current\prev new undef weak def com indr warn */
- /* UNDEF_ROW */ {UND, NOACT, NOACT, NOACT, NOACT, CYCLE, WARNC },
- /* UNDEFW_ROW */ {WEAK, WEAK, NOACT, NOACT, NOACT, CYCLE, WARNC },
- /* DEF_ROW */ {DEF, DEF, DEF, MDEF, CDEF, CYCLE, CYCLE },
- /* DEFW_ROW */ {DEF, DEF, DEF, NOACT, NOACT, CYCLE, CYCLE },
- /* COMMON_ROW */ {COM, COM, COM, CREF, BIG, CYCLE, WARNC },
- /* INDR_ROW */ {IND, IND, IND, MDEF, MDEF, MDEF, WARNC },
- /* WARN_ROW */ {MWARN, WARN, WARN, MWARN, MWARN, MWARN, NOACT },
- /* SET_ROW */ {SET, SET, SET, SET, SET, CYCLE, WARNC }
+ /* current\prev new undef undefw def defw com indr warn */
+ /* UNDEF_ROW */ {UND, NOACT, NOACT, 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 },
+ /* INDR_ROW */ {IND, IND, IND, MDEF, IND, CIND, MIND, CYCLE },
+ /* WARN_ROW */ {MWARN, WARN, WARN, CWARN, CWARN, WARN, CWARN, CYCLE },
+ /* SET_ROW */ {SET, SET, SET, SET, SET, SET, CYCLE, CYCLE }
};
+/* Most of the entries in the LINK_ACTION table are straightforward,
+ but a few are somewhat subtle.
+
+ A reference to an indirect symbol (UNDEF_ROW/indr or
+ UNDEFW_ROW/indr) is counted as a reference both to the indirect
+ symbol and to the symbol the indirect symbol points to.
+
+ A reference to a warning symbol (UNDEF_ROW/warn or UNDEFW_ROW/warn)
+ causes the warning to be issued.
+
+ A common definition of an indirect symbol (COMMON_ROW/indr) is
+ treated as a multiple definition error. Likewise for an indirect
+ definition of a common symbol (INDR_ROW/com).
+
+ An indirect definition of a warning (INDR_ROW/warn) does not cause
+ the warning to be issued.
+
+ If a warning is created for an indirect symbol (WARN_ROW/indr) no
+ warning is created for the symbol the indirect symbol points to.
+
+ Adding an entry to a set does not count as a reference to a set,
+ and no warning is issued (SET_ROW/warn). */
+
/* Add a symbol to the global hash table.
ABFD is the BFD the symbol comes from.
NAME is the name of the symbol.
FLAGS is the BSF_* bits associated with the symbol.
SECTION is the section in which the symbol is defined; this may be
- bfd_und_section or bfd_com_section.
+ bfd_und_section_ptr or bfd_com_section_ptr.
VALUE is the value of the symbol, relative to the section.
STRING is used for either an indirect symbol, in which case it is
the name of the symbol to indirect to, or a warning symbol, in
struct bfd_link_hash_entry *h;
boolean cycle;
- if (section == &bfd_ind_section
+ if (bfd_is_ind_section (section)
|| (flags & BSF_INDIRECT) != 0)
row = INDR_ROW;
else if ((flags & BSF_WARNING) != 0)
row = WARN_ROW;
else if ((flags & BSF_CONSTRUCTOR) != 0)
row = SET_ROW;
- else if (section == &bfd_und_section)
+ else if (bfd_is_und_section (section))
{
if ((flags & BSF_WEAK) != 0)
row = UNDEFW_ROW;
{
case FAIL:
abort ();
+
+ case NOACT:
+ /* Do nothing. */
+ break;
+
case UND:
+ /* Make a new undefined symbol. */
h->type = bfd_link_hash_undefined;
h->u.undef.abfd = abfd;
bfd_link_add_undef (info->hash, h);
break;
+
case WEAK:
- h->type = bfd_link_hash_weak;
+ /* Make a new weak undefined symbol. */
+ h->type = bfd_link_hash_undefweak;
h->u.undef.abfd = abfd;
break;
+
case CDEF:
+ /* We have found a definition for a symbol which was
+ 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,
+ 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:
- h->type = bfd_link_hash_defined;
- h->u.def.section = section;
- h->u.def.value = value;
-
- /* If we have been asked to, we act like collect2 and
- identify all functions that might be global constructors
- and destructors and pass them up in a callback. We only
- do this for certain object file types, since many object
- file types can handle this automatically. */
- if (collect && name[0] == '_')
- {
- const char *s;
+ case DEFW:
+ {
+ enum bfd_link_order_type oldtype;
+
+ /* Define a symbol. */
+ oldtype = h->type;
+ if (action == DEFW)
+ h->type = bfd_link_hash_defweak;
+ else
+ h->type = bfd_link_hash_defined;
+ h->u.def.section = section;
+ h->u.def.value = value;
+
+ /* If we have been asked to, we act like collect2 and
+ identify all functions that might be global
+ constructors and destructors and pass them up in a
+ callback. We only do this for certain object file
+ types, since many object file types can handle this
+ automatically. */
+ if (collect && name[0] == '_')
+ {
+ const char *s;
- /* A constructor or destructor name starts like this:
- _+GLOBAL_[_.$][ID][_.$]
- where the first [_.$] and the second are the same
- character (we accept any character there, in case a
- new object file format comes along with even worse
- naming restrictions). */
+ /* A constructor or destructor name starts like this:
+ _+GLOBAL_[_.$][ID][_.$] where the first [_.$] and
+ the second are the same character (we accept any
+ character there, in case a new object file format
+ comes along with even worse naming restrictions). */
#define CONS_PREFIX "GLOBAL_"
#define CONS_PREFIX_LEN (sizeof CONS_PREFIX - 1)
- s = name + 1;
- while (*s == '_')
- ++s;
- if (s[0] == 'G'
- && strncmp (s, CONS_PREFIX, CONS_PREFIX_LEN - 1) == 0)
- {
- char c;
-
- c = s[CONS_PREFIX_LEN + 1];
- if ((c == 'I' || c == 'D')
- && s[CONS_PREFIX_LEN] == s[CONS_PREFIX_LEN + 2])
- {
- if (! ((*info->callbacks->constructor)
- (info,
- c == 'I' ? true : false,
- name, abfd, section, value)))
- return false;
- }
- }
- }
+ s = name + 1;
+ while (*s == '_')
+ ++s;
+ if (s[0] == 'G'
+ && strncmp (s, CONS_PREFIX, CONS_PREFIX_LEN - 1) == 0)
+ {
+ char c;
+
+ c = s[CONS_PREFIX_LEN + 1];
+ if ((c == 'I' || c == 'D')
+ && s[CONS_PREFIX_LEN] == s[CONS_PREFIX_LEN + 2])
+ {
+ /* If this is a definition of a symbol which
+ was previously weakly defined, we are in
+ trouble. We have already added a
+ constructor entry for the weak defined
+ symbol, and now we are trying to add one
+ for the new symbol. Fortunately, this case
+ should never arise in practice. */
+ if (oldtype == bfd_link_hash_defweak)
+ abort ();
+
+ if (! ((*info->callbacks->constructor)
+ (info,
+ c == 'I' ? true : false,
+ name, abfd, section, value)))
+ return false;
+ }
+ }
+ }
+ }
break;
+
case COM:
+ /* We have found a common definition for a symbol. */
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 (section == &bfd_com_section)
+
+ /* Select a default alignment based on the size. This may
+ be overridden by the caller. */
+ {
+ unsigned int power;
+
+ power = bfd_log2 (value);
+ if (power > 4)
+ power = 4;
+ h->u.c.p->alignment_power = power;
+ }
+
+ /* The section of a common symbol is only used if the common
+ symbol is actually allocated. It basically provides a
+ hook for the linker script to decide which output section
+ the common symbols should be put in. In most cases, the
+ section of a common symbol will be bfd_com_section_ptr,
+ the code here will choose a common symbol section named
+ "COMMON", and the linker script will contain *(COMMON) in
+ the appropriate place. A few targets use separate common
+ sections for small symbols, and they require special
+ 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 NOACT:
+
+ case REF:
+ /* A reference to a defined symbol. */
+ if (h->next == NULL && info->hash->undefs_tail != h)
+ h->next = h;
break;
+
case BIG:
+ /* We have found a common definition for a symbol which
+ already had a common definition. Use the maximum of the
+ two sizes. */
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,
+ 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)
- h->u.c.size = value;
+ {
+ unsigned int power;
+
+ h->u.c.size = value;
+
+ /* 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.p->alignment_power = power;
+ }
break;
+
case CREF:
- BFD_ASSERT (h->type == bfd_link_hash_defined);
- if (! ((*info->callbacks->multiple_common)
- (info, name,
- h->u.def.section->owner, bfd_link_hash_defined, (bfd_vma) 0,
- abfd, bfd_link_hash_common, value)))
- return false;
+ {
+ bfd *obfd;
+
+ /* We have found a common definition for a symbol which
+ was already defined. FIXME: It would nice if we could
+ report the BFD which defined an indirect symbol, but we
+ don't have anywhere to store the information. */
+ if (h->type == bfd_link_hash_defined
+ || h->type == bfd_link_hash_defweak)
+ obfd = h->u.def.section->owner;
+ else
+ obfd = NULL;
+ if (! ((*info->callbacks->multiple_common)
+ (info, name, obfd, h->type, (bfd_vma) 0,
+ abfd, bfd_link_hash_common, value)))
+ return false;
+ }
break;
+
+ case MIND:
+ /* Multiple indirect symbols. This is OK if they both point
+ to the same symbol. */
+ if (strcmp (h->u.i.link->root.string, string) == 0)
+ break;
+ /* Fall through. */
case MDEF:
+ /* Handle a multiple definition. */
{
asection *msec;
bfd_vma mval;
msec = h->u.def.section;
mval = h->u.def.value;
break;
- case bfd_link_hash_common:
- msec = &bfd_com_section;
- mval = h->u.c.size;
- break;
case bfd_link_hash_indirect:
- msec = &bfd_ind_section;
+ 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;
+
if (! ((*info->callbacks->multiple_definition)
(info, name, 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.p->section->owner, bfd_link_hash_common, h->u.c.size,
+ abfd, bfd_link_hash_indirect, (bfd_vma) 0)))
+ return false;
+ /* Fall through. */
case IND:
+ /* Create an indirect symbol. */
{
struct bfd_link_hash_entry *inh;
inh->u.undef.abfd = abfd;
bfd_link_add_undef (info->hash, inh);
}
+
+ /* If the indirect symbol has been referenced, we need to
+ push the reference down to the symbol we are
+ referencing. */
+ if (h->type != bfd_link_hash_new)
+ {
+ row = UNDEF_ROW;
+ cycle = true;
+ }
+
h->type = bfd_link_hash_indirect;
h->u.i.link = inh;
}
break;
+
case SET:
+ /* Add an entry to a set. */
if (! (*info->callbacks->add_to_set) (info, h, BFD_RELOC_CTOR,
abfd, section, value))
return false;
break;
- case WARN:
+
case WARNC:
+ /* Issue a warning and cycle. */
if (h->u.i.warning != NULL)
{
if (! (*info->callbacks->warning) (info, h->u.i.warning))
/* Only issue a warning once. */
h->u.i.warning = NULL;
}
- if (action == WARN)
- break;
/* Fall through. */
case CYCLE:
+ /* Try again with the referenced symbol. */
+ h = h->u.i.link;
+ cycle = true;
+ break;
+
+ case REFC:
+ /* A reference to an indirect symbol. */
+ if (h->next == NULL && info->hash->undefs_tail != h)
+ h->next = h;
h = h->u.i.link;
cycle = true;
break;
+
+ case WARN:
+ /* Issue a warning. */
+ if (! (*info->callbacks->warning) (info, string))
+ return false;
+ break;
+
+ case CWARN:
+ /* Warn if this symbol has been referenced already,
+ otherwise add a warning. A symbol has been referenced if
+ the next field is not NULL, or it is the tail of the
+ undefined symbol list. The REF case above helps to
+ ensure this. */
+ if (h->next != NULL || info->hash->undefs_tail == h)
+ {
+ if (! (*info->callbacks->warning) (info, string))
+ return false;
+ break;
+ }
+ /* Fall through. */
case MWARN:
+ /* Make a warning symbol. */
{
struct bfd_link_hash_entry *sub;
if (! _bfd_generic_reloc_link_order (abfd, info, o, p))
return false;
break;
+ case bfd_indirect_link_order:
+ if (! default_indirect_link_order (abfd, info, o, p, true))
+ return false;
+ break;
default:
if (! _bfd_default_link_order (abfd, info, o, p))
return false;
| BSF_GLOBAL
| BSF_CONSTRUCTOR
| BSF_WEAK)) != 0
- || bfd_get_section (sym) == &bfd_und_section
+ || bfd_is_und_section (bfd_get_section (sym))
|| bfd_is_com_section (bfd_get_section (sym))
- || bfd_get_section (sym) == &bfd_ind_section)
+ || 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
+ 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_new:
abort ();
case bfd_link_hash_undefined:
- case bfd_link_hash_weak:
break;
+ 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;
- sym->flags |= BSF_GLOBAL;
break;
case bfd_link_hash_common:
sym->value = h->root.u.c.size;
sym->flags |= BSF_GLOBAL;
if (! bfd_is_com_section (sym->section))
{
- BFD_ASSERT (sym->section == &bfd_und_section);
- sym->section = &bfd_com_section;
+ BFD_ASSERT (bfd_is_und_section (sym->section));
+ 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
else
output = false;
}
- else if (sym->section == &bfd_ind_section)
+ else if (bfd_is_ind_section (sym->section))
output = false;
else if ((sym->flags & BSF_DEBUGGING) != 0)
{
else
output = false;
}
- else if (sym->section == &bfd_und_section
+ else if (bfd_is_und_section (sym->section)
|| bfd_is_com_section (sym->section))
output = false;
else if ((sym->flags & BSF_LOCAL) != 0)
return true;
}
+/* Set the section and value of a generic BFD symbol based on a linker
+ hash table entry. */
+
+static void
+set_symbol_from_hash (sym, h)
+ asymbol *sym;
+ struct bfd_link_hash_entry *h;
+{
+ switch (h->type)
+ {
+ default:
+ case bfd_link_hash_new:
+ abort ();
+ case bfd_link_hash_undefined:
+ sym->section = bfd_und_section_ptr;
+ sym->value = 0;
+ break;
+ case bfd_link_hash_undefweak:
+ sym->section = bfd_und_section_ptr;
+ sym->value = 0;
+ sym->flags |= BSF_WEAK;
+ break;
+ case bfd_link_hash_defined:
+ sym->section = h->u.def.section;
+ sym->value = h->u.def.value;
+ break;
+ case bfd_link_hash_defweak:
+ sym->flags |= BSF_WEAK;
+ sym->section = h->u.def.section;
+ sym->value = h->u.def.value;
+ break;
+ case bfd_link_hash_common:
+ sym->value = h->u.c.size;
+ if (sym->section == NULL)
+ sym->section = bfd_com_section_ptr;
+ else if (! bfd_is_com_section (sym->section))
+ {
+ BFD_ASSERT (bfd_is_und_section (sym->section));
+ sym->section = bfd_com_section_ptr;
+ }
+ /* Do not set the section; see _bfd_generic_link_output_symbols. */
+ break;
+ case bfd_link_hash_indirect:
+ case bfd_link_hash_warning:
+ /* FIXME: What should we do here? */
+ break;
+ }
+}
+
/* Write out a global symbol, if it hasn't already been written out.
This is called for each symbol in the hash table. */
sym->flags = 0;
}
- switch (h->root.type)
- {
- default:
- case bfd_link_hash_new:
- abort ();
- case bfd_link_hash_undefined:
- sym->section = &bfd_und_section;
- sym->value = 0;
- break;
- case bfd_link_hash_weak:
- sym->section = &bfd_und_section;
- sym->value = 0;
- sym->flags |= BSF_WEAK;
- break;
- case bfd_link_hash_defined:
- sym->section = h->root.u.def.section;
- sym->value = h->root.u.def.value;
- break;
- case bfd_link_hash_common:
- sym->value = h->root.u.c.size;
- if (! bfd_is_com_section (sym->section))
- {
- BFD_ASSERT (sym->section == &bfd_und_section);
- sym->section = &bfd_com_section;
- }
- /* Do not set the section; see _bfd_generic_link_output_symbols. */
- break;
- case bfd_link_hash_indirect:
- case bfd_link_hash_warning:
- /* FIXME: What should we do here? */
- break;
- }
+ set_symbol_from_hash (sym, &h->root);
sym->flags |= BSF_GLOBAL;
r->address = link_order->offset;
r->howto = bfd_reloc_type_lookup (abfd, link_order->u.reloc.p->reloc);
- if (r->howto == (const reloc_howto_type *) NULL)
+ if (r->howto == 0)
{
bfd_set_error (bfd_error_bad_value);
return false;
default:
abort ();
case bfd_indirect_link_order:
- return default_indirect_link_order (abfd, info, sec, 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:
/* Default routine to handle a bfd_indirect_link_order. */
static boolean
-default_indirect_link_order (output_bfd, info, output_section, link_order)
+default_indirect_link_order (output_bfd, info, output_section, link_order,
+ generic_linker)
bfd *output_bfd;
struct bfd_link_info *info;
asection *output_section;
struct bfd_link_order *link_order;
+ boolean generic_linker;
{
asection *input_section;
bfd *input_bfd;
abort ();
}
- /* Get the canonical symbols. The generic linker will always have
- retrieved them by this point, but we may be being called by a
- specific linker when linking different types of object files
- together. */
- if (! generic_link_read_symbols (input_bfd))
- return false;
+ if (! generic_linker)
+ {
+ asymbol **sympp;
+ asymbol **symppend;
+
+ /* Get the canonical symbols. The generic linker will always
+ have retrieved them by this point, but we are being called by
+ a specific linker, presumably because we are linking
+ different types of object files together. */
+ if (! generic_link_read_symbols (input_bfd))
+ return false;
+
+ /* Since we have been called by a specific linker, rather than
+ the generic linker, the values of the symbols will not be
+ right. They will be the values as seen in the input file,
+ not the values of the final link. We need to fix them up
+ before we can relocate the section. */
+ sympp = _bfd_generic_link_get_symbols (input_bfd);
+ symppend = sympp + _bfd_generic_link_get_symcount (input_bfd);
+ for (; sympp < symppend; sympp++)
+ {
+ asymbol *sym;
+ struct bfd_link_hash_entry *h;
+
+ sym = *sympp;
+
+ if ((sym->flags & (BSF_INDIRECT
+ | BSF_WARNING
+ | BSF_GLOBAL
+ | BSF_CONSTRUCTOR
+ | BSF_WEAK)) != 0
+ || bfd_is_und_section (bfd_get_section (sym))
+ || bfd_is_com_section (bfd_get_section (sym))
+ || bfd_is_ind_section (bfd_get_section (sym)))
+ {
+ /* sym->udata may have been set by
+ generic_link_add_symbol_list. */
+ if (sym->udata.p != NULL)
+ h = (struct bfd_link_hash_entry *) sym->udata.p;
+ else
+ h = bfd_link_hash_lookup (info->hash,
+ bfd_asymbol_name (sym),
+ false, false, true);
+ 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));
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;
+ asection *sec;
+{
+ return false;
+}