diff options
Diffstat (limited to 'binutils-2.25/bfd/linker.c')
| -rw-r--r-- | binutils-2.25/bfd/linker.c | 604 |
1 files changed, 238 insertions, 366 deletions
diff --git a/binutils-2.25/bfd/linker.c b/binutils-2.25/bfd/linker.c index 190520a5..abdf5b0e 100644 --- a/binutils-2.25/bfd/linker.c +++ b/binutils-2.25/bfd/linker.c @@ -1,7 +1,5 @@ /* linker.c -- BFD linker routines - Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, - 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 - Free Software Foundation, Inc. + Copyright (C) 1993-2014 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. @@ -231,28 +229,16 @@ SUBSUBSECTION @findex _bfd_generic_link_add_archive_symbols In most cases the work of looking through the symbols in the archive should be done by the - <<_bfd_generic_link_add_archive_symbols>> function. This - function builds a hash table from the archive symbol table and - looks through the list of undefined symbols to see which - elements should be included. + <<_bfd_generic_link_add_archive_symbols>> function. <<_bfd_generic_link_add_archive_symbols>> is passed a function to call to make the final decision about adding an archive element to the link and to do the actual work of adding the - symbols to the linker hash table. - - The function passed to - <<_bfd_generic_link_add_archive_symbols>> must read the - symbols of the archive element and decide whether the archive - element should be included in the link. If the element is to + symbols to the linker hash table. If the element is to be included, the <<add_archive_element>> linker callback routine must be called with the element as an argument, and the element's symbols must be added to the linker hash table just as though the element had itself been passed to the - <<_bfd_link_add_symbols>> function. The <<add_archive_element>> - callback has the option to indicate that it would like to - replace the element archive with a substitute BFD, in which - case it is the symbols of that substitute BFD that must be - added to the linker hash table instead. + <<_bfd_link_add_symbols>> function. When the a.out <<_bfd_link_add_symbols>> function receives an archive, it calls <<_bfd_generic_link_add_archive_symbols>> @@ -315,7 +301,7 @@ SUBSUBSECTION The <<input_bfds>> field of the <<bfd_link_info>> structure will point to a list of all the input files included in the - link. These files are linked through the <<link_next>> field + link. These files are linked through the <<link.next>> field of the <<bfd>> structure. Each section in the output file will have a list of @@ -421,11 +407,14 @@ static bfd_boolean generic_link_add_object_symbols static bfd_boolean generic_link_add_symbols (bfd *, struct bfd_link_info *, bfd_boolean); static bfd_boolean generic_link_check_archive_element_no_collect - (bfd *, struct bfd_link_info *, bfd_boolean *); + (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, const char *, + bfd_boolean *); static bfd_boolean generic_link_check_archive_element_collect - (bfd *, struct bfd_link_info *, bfd_boolean *); + (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, const char *, + bfd_boolean *); static bfd_boolean generic_link_check_archive_element - (bfd *, struct bfd_link_info *, bfd_boolean *, bfd_boolean); + (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, const char *, + bfd_boolean *, bfd_boolean); static bfd_boolean generic_link_add_symbol_list (bfd *, struct bfd_link_info *, bfd_size_type count, asymbol **, bfd_boolean); @@ -484,11 +473,22 @@ _bfd_link_hash_table_init const char *), unsigned int entsize) { + bfd_boolean ret; + + BFD_ASSERT (!abfd->is_linker_output && !abfd->link.hash); table->undefs = NULL; table->undefs_tail = NULL; table->type = bfd_link_generic_hash_table; - return bfd_hash_table_init (&table->table, newfunc, entsize); + ret = bfd_hash_table_init (&table->table, newfunc, entsize); + if (ret) + { + /* Arrange for destruction of this hash table on closing ABFD. */ + table->hash_table_free = _bfd_generic_link_hash_table_free; + abfd->link.hash = table; + abfd->is_linker_output = TRUE; + } + return ret; } /* Look up a symbol in a link hash table. If follow is TRUE, we @@ -568,8 +568,6 @@ bfd_wrapped_link_hash_lookup (bfd *abfd, return h; } -#undef WRAP - #undef REAL #define REAL "__real_" @@ -604,6 +602,42 @@ bfd_wrapped_link_hash_lookup (bfd *abfd, return bfd_link_hash_lookup (info->hash, string, create, copy, follow); } +/* If H is a wrapped symbol, ie. the symbol name starts with "__wrap_" + and the remainder is found in wrap_hash, return the real symbol. */ + +struct bfd_link_hash_entry * +unwrap_hash_lookup (struct bfd_link_info *info, + bfd *input_bfd, + struct bfd_link_hash_entry *h) +{ + const char *l = h->root.string; + + if (*l == bfd_get_symbol_leading_char (input_bfd) + || *l == info->wrap_char) + ++l; + + if (CONST_STRNEQ (l, WRAP)) + { + l += sizeof WRAP - 1; + + if (bfd_hash_lookup (info->wrap_hash, l, FALSE, FALSE) != NULL) + { + char save = 0; + if (l - (sizeof WRAP - 1) != h->root.string) + { + --l; + save = *l; + *(char *) l = *h->root.string; + } + h = bfd_link_hash_lookup (info->hash, l, FALSE, FALSE, FALSE); + if (save) + *(char *) l = save; + } + } + return h; +} +#undef WRAP + /* Traverse a generic link hash table. Differs from bfd_hash_traverse in the treatment of warning symbols. When warning symbols are created they replace the real symbol, so you don't get to see the @@ -739,13 +773,16 @@ _bfd_generic_link_hash_table_create (bfd *abfd) } void -_bfd_generic_link_hash_table_free (struct bfd_link_hash_table *hash) +_bfd_generic_link_hash_table_free (bfd *obfd) { - struct generic_link_hash_table *ret - = (struct generic_link_hash_table *) hash; + struct generic_link_hash_table *ret; + BFD_ASSERT (obfd->is_linker_output && obfd->link.hash); + ret = (struct generic_link_hash_table *) obfd->link.hash; bfd_hash_table_free (&ret->root.table); free (ret); + obfd->link.hash = NULL; + obfd->is_linker_output = FALSE; } /* Grab the symbols for an object file when doing a generic link. We @@ -815,14 +852,13 @@ _bfd_generic_link_just_syms (asection *sec, sec->output_offset = sec->vma; } -/* Copy the type of a symbol assiciated with a linker hast table entry. - Override this so that symbols created in linker scripts get their - type from the RHS of the assignment. +/* Copy the symbol type and other attributes for a linker script + assignment from HSRC to HDEST. The default implementation does nothing. */ void _bfd_generic_copy_link_hash_symbol_type (bfd *abfd ATTRIBUTE_UNUSED, - struct bfd_link_hash_entry * hdest ATTRIBUTE_UNUSED, - struct bfd_link_hash_entry * hsrc ATTRIBUTE_UNUSED) + struct bfd_link_hash_entry *hdest ATTRIBUTE_UNUSED, + struct bfd_link_hash_entry *hsrc ATTRIBUTE_UNUSED) { } @@ -872,138 +908,32 @@ generic_link_add_object_symbols (bfd *abfd, return generic_link_add_symbol_list (abfd, info, symcount, outsyms, collect); } -/* We build a hash table of all symbols defined in an archive. */ - -/* An archive symbol may be defined by multiple archive elements. - This linked list is used to hold the elements. */ - -struct archive_list -{ - struct archive_list *next; - unsigned int indx; -}; - -/* An entry in an archive hash table. */ - -struct archive_hash_entry -{ - struct bfd_hash_entry root; - /* Where the symbol is defined. */ - struct archive_list *defs; -}; - -/* An archive hash table itself. */ - -struct archive_hash_table -{ - struct bfd_hash_table table; -}; - -/* Create a new entry for an archive hash table. */ - -static struct bfd_hash_entry * -archive_hash_newfunc (struct bfd_hash_entry *entry, - struct bfd_hash_table *table, - const char *string) -{ - struct archive_hash_entry *ret = (struct archive_hash_entry *) entry; - - /* Allocate the structure if it has not already been allocated by a - subclass. */ - if (ret == NULL) - ret = (struct archive_hash_entry *) - bfd_hash_allocate (table, sizeof (struct archive_hash_entry)); - if (ret == NULL) - return NULL; - - /* Call the allocation method of the superclass. */ - ret = ((struct archive_hash_entry *) - bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string)); - - if (ret) - { - /* Initialize the local fields. */ - ret->defs = NULL; - } - - return &ret->root; -} - -/* Initialize an archive hash table. */ - -static bfd_boolean -archive_hash_table_init - (struct archive_hash_table *table, - struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *, - struct bfd_hash_table *, - const char *), - unsigned int entsize) -{ - return bfd_hash_table_init (&table->table, newfunc, entsize); -} - -/* Look up an entry in an archive hash table. */ - -#define archive_hash_lookup(t, string, create, copy) \ - ((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) - /* Generic function to add symbols from an archive file to the global hash file. This function presumes that the archive symbol table has already been read in (this is normally done by the - bfd_check_format entry point). It looks through the undefined and - common symbols and searches the archive symbol table for them. If - it finds an entry, it includes the associated object file in the - link. - - The old linker looked through the archive symbol table for - undefined symbols. We do it the other way around, looking through - undefined symbols for symbols defined in the archive. The - advantage of the newer scheme is that we only have to look through - the list of undefined symbols once, whereas the old method had to - re-search the symbol table each time a new object file was added. - - The CHECKFN argument is used to see if an object file should be - included. CHECKFN should set *PNEEDED to TRUE if the object file - should be included, and must also call the bfd_link_info - add_archive_element callback function and handle adding the symbols - to the global hash table. CHECKFN must notice if the callback - indicates a substitute BFD, and arrange to add those symbols instead - if it does so. CHECKFN should only return FALSE if some sort of - error occurs. - - For some formats, such as a.out, it is possible to look through an - object file but not actually include it in the link. The - archive_pass field in a BFD is used to avoid checking the symbols - of an object files too many times. When an object is included in - the link, archive_pass is set to -1. If an object is scanned but - not included, archive_pass is set to the pass number. The pass - number is incremented each time a new object file is included. The - pass number is used because when a new object file is included it - may create new undefined symbols which cause a previously examined - object file to be included. */ + bfd_check_format entry point). It looks through the archive symbol + table for symbols that are undefined or common in the linker global + symbol hash table. When one is found, the CHECKFN argument is used + to see if an object file should be included. This allows targets + to customize common symbol behaviour. CHECKFN should set *PNEEDED + to TRUE if the object file should be included, and must also call + the bfd_link_info add_archive_element callback function and handle + adding the symbols to the global hash table. CHECKFN must notice + if the callback indicates a substitute BFD, and arrange to add + those symbols instead if it does so. CHECKFN should only return + FALSE if some sort of error occurs. */ bfd_boolean _bfd_generic_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info, - bfd_boolean (*checkfn) (bfd *, struct bfd_link_info *, bfd_boolean *)) + bfd_boolean (*checkfn) (bfd *, struct bfd_link_info *, + struct bfd_link_hash_entry *, const char *, + bfd_boolean *)) { - carsym *arsyms; - carsym *arsym_end; - register carsym *arsym; - int pass; - struct archive_hash_table arsym_hash; - unsigned int indx; - struct bfd_link_hash_entry **pundef; + bfd_boolean loop; + bfd_size_type amt; + unsigned char *included; if (! bfd_has_map (abfd)) { @@ -1014,148 +944,103 @@ _bfd_generic_link_add_archive_symbols return FALSE; } - arsyms = bfd_ardata (abfd)->symdefs; - arsym_end = arsyms + bfd_ardata (abfd)->symdef_count; - - /* In order to quickly determine whether an symbol is defined in - this archive, we build a hash table of the symbols. */ - if (! archive_hash_table_init (&arsym_hash, archive_hash_newfunc, - sizeof (struct archive_hash_entry))) + amt = bfd_ardata (abfd)->symdef_count; + if (amt == 0) + return TRUE; + amt *= sizeof (*included); + included = (unsigned char *) bfd_zmalloc (amt); + if (included == NULL) return FALSE; - for (arsym = arsyms, indx = 0; arsym < arsym_end; arsym++, indx++) - { - struct archive_hash_entry *arh; - struct archive_list *l, **pp; - - arh = archive_hash_lookup (&arsym_hash, arsym->name, TRUE, FALSE); - if (arh == NULL) - goto error_return; - l = ((struct archive_list *) - archive_hash_allocate (&arsym_hash, sizeof (struct archive_list))); - if (l == NULL) - goto error_return; - l->indx = indx; - for (pp = &arh->defs; *pp != NULL; pp = &(*pp)->next) - ; - *pp = l; - l->next = NULL; - } - - /* 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. */ - pundef = &info->hash->undefs; - while (*pundef != NULL) + do { - struct bfd_link_hash_entry *h; - struct archive_hash_entry *arh; - struct archive_list *l; - - h = *pundef; - - /* When a symbol is defined, it is not necessarily removed from - the list. */ - if (h->type != bfd_link_hash_undefined - && h->type != bfd_link_hash_common) + carsym *arsyms; + carsym *arsym_end; + carsym *arsym; + unsigned int indx; + file_ptr last_ar_offset = -1; + bfd_boolean needed = FALSE; + bfd *element = NULL; + + loop = FALSE; + arsyms = bfd_ardata (abfd)->symdefs; + arsym_end = arsyms + bfd_ardata (abfd)->symdef_count; + for (arsym = arsyms, indx = 0; arsym < arsym_end; arsym++, indx++) { - /* Remove this entry from the list, for general cleanliness - 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 (it would also cause - us to lose track of whether the symbol has been - referenced). */ - if (*pundef != info->hash->undefs_tail) - *pundef = (*pundef)->u.undef.next; - else - pundef = &(*pundef)->u.undef.next; - continue; - } - - /* Look for this symbol in the archive symbol map. */ - arh = archive_hash_lookup (&arsym_hash, h->root.string, FALSE, FALSE); - if (arh == NULL) - { - /* 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; + struct bfd_link_hash_entry *h; + struct bfd_link_hash_entry *undefs_tail; - sprintf (buf, "__imp_%s", h->root.string); - arh = archive_hash_lookup (&arsym_hash, buf, FALSE, FALSE); - free(buf); - } - if (arh == NULL) + if (included[indx]) + continue; + if (needed && arsym->file_offset == last_ar_offset) { - pundef = &(*pundef)->u.undef.next; + included[indx] = 1; continue; } - } - /* Look at all the objects which define this symbol. */ - for (l = arh->defs; l != NULL; l = l->next) - { - bfd *element; - bfd_boolean needed; - - /* If the symbol has gotten defined along the way, quit. */ - if (h->type != bfd_link_hash_undefined - && h->type != bfd_link_hash_common) - break; - element = bfd_get_elt_at_index (abfd, l->indx); - if (element == NULL) - goto error_return; + h = bfd_link_hash_lookup (info->hash, arsym->name, + FALSE, FALSE, TRUE); - /* If we've already included this element, or if we've - already checked it on this pass, continue. */ - if (element->archive_pass == -1 - || element->archive_pass == pass) + if (h == NULL + && info->pei386_auto_import + && CONST_STRNEQ (arsym->name, "__imp_")) + h = bfd_link_hash_lookup (info->hash, arsym->name + 6, + FALSE, FALSE, TRUE); + if (h == NULL) continue; - /* If we can't figure this element out, just ignore it. */ - if (! bfd_check_format (element, bfd_object)) + if (h->type != bfd_link_hash_undefined + && h->type != bfd_link_hash_common) { - element->archive_pass = -1; + if (h->type != bfd_link_hash_undefweak) + /* Symbol must be defined. Don't check it again. */ + included[indx] = 1; continue; } + if (last_ar_offset != arsym->file_offset) + { + last_ar_offset = arsym->file_offset; + element = _bfd_get_elt_at_filepos (abfd, last_ar_offset); + if (element == NULL + || !bfd_check_format (element, bfd_object)) + goto error_return; + } + + undefs_tail = info->hash->undefs_tail; + /* CHECKFN will see if this element should be included, and go ahead and include it if appropriate. */ - if (! (*checkfn) (element, info, &needed)) + if (! (*checkfn) (element, info, h, arsym->name, &needed)) goto error_return; - if (! needed) - element->archive_pass = pass; - else + if (needed) { - element->archive_pass = -1; + unsigned int mark; - /* Increment the pass count to show that we may need to - recheck object files which were already checked. */ - ++pass; + /* Look backward to mark all symbols from this object file + which we have already seen in this pass. */ + mark = indx; + do + { + included[mark] = 1; + if (mark == 0) + break; + --mark; + } + while (arsyms[mark].file_offset == last_ar_offset); + + if (undefs_tail != info->hash->undefs_tail) + loop = TRUE; } } + } while (loop); - pundef = &(*pundef)->u.undef.next; - } - - archive_hash_table_free (&arsym_hash); - - /* Save PASS in case we are called again. */ - abfd->archive_pass = pass; - + free (included); return TRUE; error_return: - archive_hash_table_free (&arsym_hash); + free (included); return FALSE; } @@ -1165,12 +1050,14 @@ _bfd_generic_link_add_archive_symbols for finding them. */ static bfd_boolean -generic_link_check_archive_element_no_collect ( - bfd *abfd, +generic_link_check_archive_element_no_collect (bfd *abfd, struct bfd_link_info *info, + struct bfd_link_hash_entry *h, + const char *name, bfd_boolean *pneeded) { - return generic_link_check_archive_element (abfd, info, pneeded, FALSE); + return generic_link_check_archive_element (abfd, info, h, name, pneeded, + FALSE); } /* See if we should include an archive element. This version is used @@ -1180,9 +1067,12 @@ generic_link_check_archive_element_no_collect ( static bfd_boolean generic_link_check_archive_element_collect (bfd *abfd, struct bfd_link_info *info, + struct bfd_link_hash_entry *h, + const char *name, bfd_boolean *pneeded) { - return generic_link_check_archive_element (abfd, info, pneeded, TRUE); + return generic_link_check_archive_element (abfd, info, h, name, pneeded, + TRUE); } /* See if we should include an archive element. Optionally collect @@ -1191,6 +1081,8 @@ generic_link_check_archive_element_collect (bfd *abfd, static bfd_boolean generic_link_check_archive_element (bfd *abfd, struct bfd_link_info *info, + struct bfd_link_hash_entry *h, + const char *name ATTRIBUTE_UNUSED, bfd_boolean *pneeded, bfd_boolean collect) { @@ -1206,7 +1098,6 @@ generic_link_check_archive_element (bfd *abfd, for (; pp < ppend; pp++) { asymbol *p; - struct bfd_link_hash_entry *h; p = *pp; @@ -1229,29 +1120,21 @@ generic_link_check_archive_element (bfd *abfd, /* P is a symbol we are looking for. */ - if (! bfd_is_com_section (p->section)) + if (! bfd_is_com_section (p->section) + || (h->type == bfd_link_hash_undefined + && h->u.undef.abfd == NULL)) { - bfd_size_type symcount; - asymbol **symbols; - bfd *oldbfd = abfd; - - /* This object file defines this symbol, so pull it in. */ + /* P is not a common symbol, or an undefined reference was + created from outside BFD such as from a linker -u option. + This object file defines the symbol, so pull it in. */ + *pneeded = TRUE; if (!(*info->callbacks ->add_archive_element) (info, abfd, bfd_asymbol_name (p), &abfd)) return FALSE; /* Potentially, the add_archive_element hook may have set a substitute BFD for us. */ - if (abfd != oldbfd - && !bfd_generic_link_read_symbols (abfd)) - return FALSE; - symcount = _bfd_generic_link_get_symcount (abfd); - symbols = _bfd_generic_link_get_symbols (abfd); - if (! generic_link_add_symbol_list (abfd, info, symcount, - symbols, collect)) - return FALSE; - *pneeded = TRUE; - return TRUE; + return generic_link_add_object_symbols (abfd, info, collect); } /* P is a common symbol. */ @@ -1262,23 +1145,6 @@ generic_link_check_archive_element (bfd *abfd, bfd_vma size; unsigned int power; - symbfd = h->u.undef.abfd; - if (symbfd == NULL) - { - /* This symbol was created as undefined from outside - BFD. We assume that we should link in the object - file. This is for the -u option in the linker. */ - if (!(*info->callbacks - ->add_archive_element) (info, abfd, bfd_asymbol_name (p), - &abfd)) - return FALSE; - /* Potentially, the add_archive_element hook may have set a - substitute BFD for us. But no symbols are going to get - registered by anything we're returning to from here. */ - *pneeded = TRUE; - return TRUE; - } - /* Turn the symbol into a common symbol but do not link in the object file. This is how a.out works. Object formats that require different semantics must implement @@ -1286,6 +1152,7 @@ generic_link_check_archive_element (bfd *abfd, undefs list. We add the section to a common section attached to symbfd to ensure that it is in a BFD which will be linked in. */ + symbfd = h->u.undef.abfd; h->type = bfd_link_hash_common; h->u.c.p = (struct bfd_link_hash_common_entry *) bfd_hash_allocate (&info->hash->table, @@ -1475,8 +1342,7 @@ enum link_action 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. */ + WARN, /* 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. */ @@ -1494,7 +1360,7 @@ static const enum link_action link_action[8][8] = /* DEFW_ROW */ {DEFW, DEFW, DEFW, NOACT, NOACT, NOACT, NOACT, CYCLE }, /* 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, NOACT }, + /* WARN_ROW */ {MWARN, WARN, WARN, WARN, WARN, WARN, WARN, NOACT }, /* SET_ROW */ {SET, SET, SET, SET, SET, SET, CYCLE, CYCLE } }; @@ -1576,13 +1442,23 @@ _bfd_generic_link_add_one_symbol (struct bfd_link_info *info, { enum link_row row; struct bfd_link_hash_entry *h; + struct bfd_link_hash_entry *inh = NULL; bfd_boolean cycle; BFD_ASSERT (section != NULL); if (bfd_is_ind_section (section) || (flags & BSF_INDIRECT) != 0) - row = INDR_ROW; + { + row = INDR_ROW; + /* Create the indirect symbol here. This is for the benefit of + the plugin "notice" function. + STRING is the name of the symbol we want to indirect to. */ + inh = bfd_wrapped_link_hash_lookup (abfd, info, string, TRUE, + copy, FALSE); + if (inh == NULL) + return FALSE; + } else if ((flags & BSF_WARNING) != 0) row = WARN_ROW; else if ((flags & BSF_CONSTRUCTOR) != 0) @@ -1597,7 +1473,13 @@ _bfd_generic_link_add_one_symbol (struct bfd_link_info *info, else if ((flags & BSF_WEAK) != 0) row = DEFW_ROW; else if (bfd_is_com_section (section)) - row = COMMON_ROW; + { + row = COMMON_ROW; + if (strcmp (name, "__gnu_lto_slim") == 0) + (*_bfd_error_handler) + (_("%s: plugin needed to handle lto object"), + bfd_get_filename (abfd)); + } else row = DEF_ROW; @@ -1621,8 +1503,8 @@ _bfd_generic_link_add_one_symbol (struct bfd_link_info *info, || (info->notice_hash != NULL && bfd_hash_lookup (info->notice_hash, name, FALSE, FALSE) != NULL)) { - if (! (*info->callbacks->notice) (info, h, - abfd, section, value, flags, string)) + if (! (*info->callbacks->notice) (info, h, inh, + abfd, section, value, flags)) return FALSE; } @@ -1856,44 +1738,40 @@ _bfd_generic_link_add_one_symbol (struct bfd_link_info *info, return FALSE; /* Fall through. */ case IND: - /* Create an indirect symbol. */ - { - struct bfd_link_hash_entry *inh; - - /* STRING is the name of the symbol we want to indirect - to. */ - inh = bfd_wrapped_link_hash_lookup (abfd, info, string, TRUE, - copy, FALSE); - if (inh == NULL) + if (inh->type == bfd_link_hash_indirect + && inh->u.i.link == h) + { + (*_bfd_error_handler) + (_("%B: indirect symbol `%s' to `%s' is a loop"), + abfd, name, string); + bfd_set_error (bfd_error_invalid_operation); return FALSE; - if (inh->type == bfd_link_hash_indirect - && inh->u.i.link == h) - { - (*_bfd_error_handler) - (_("%B: indirect symbol `%s' to `%s' is a loop"), - 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; - inh->u.undef.abfd = abfd; - bfd_link_add_undef (info->hash, inh); - } + } + if (inh->type == bfd_link_hash_new) + { + inh->type = bfd_link_hash_undefined; + 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; - } + /* 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) + { + /* ??? If inh->type == bfd_link_hash_undefweak this + converts inh to bfd_link_hash_undefined. */ + row = UNDEF_ROW; + cycle = TRUE; + } - h->type = bfd_link_hash_indirect; - h->u.i.link = inh; - } + h->type = bfd_link_hash_indirect; + h->u.i.link = inh; + /* Not setting h = h->u.i.link here means that when cycle is + set above we'll always go to REFC, and then cycle again + to the indirected symbol. This means that any successful + change of an existing symbol to indirect counts as a + reference. ??? That may not be correct when the existing + symbol was defweak. */ break; case SET: @@ -1904,8 +1782,10 @@ _bfd_generic_link_add_one_symbol (struct bfd_link_info *info, break; case WARNC: - /* Issue a warning and cycle. */ - if (h->u.i.warning != NULL) + /* Issue a warning and cycle, except when the reference is + in LTO IR. */ + if (h->u.i.warning != NULL + && (abfd->flags & BFD_PLUGIN) == 0) { if (! (*info->callbacks->warning) (info, h->u.i.warning, h->root.string, abfd, @@ -1930,19 +1810,11 @@ _bfd_generic_link_add_one_symbol (struct bfd_link_info *info, break; case WARN: - /* Issue a warning. */ - if (! (*info->callbacks->warning) (info, string, h->root.string, - hash_entry_bfd (h), NULL, 0)) - return FALSE; - break; - - case CWARN: - /* Warn if this symbol has been referenced already, - otherwise add a warning. A symbol has been referenced if - the u.undef.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->u.undef.next != NULL || info->hash->undefs_tail == h) + /* Warn if this symbol has been referenced already from non-IR, + otherwise add a warning. */ + if ((!info->lto_plugin_active + && (h->u.undef.next != NULL || info->hash->undefs_tail == h)) + || h->non_ir_ref) { if (! (*info->callbacks->warning) (info, string, h->root.string, hash_entry_bfd (h), NULL, 0)) @@ -2014,7 +1886,7 @@ _bfd_generic_final_link (bfd *abfd, struct bfd_link_info *info) p->u.indirect.section->linker_mark = TRUE; /* Build the output symbol table. */ - for (sub = info->input_bfds; sub != NULL; sub = sub->link_next) + for (sub = info->input_bfds; sub != NULL; sub = sub->link.next) if (! _bfd_generic_link_output_symbols (abfd, sub, info, &outsymalloc)) return FALSE; |