X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=ld%2Fplugin.c;h=e253e1aea4261b8a0a5a7fef877b6f709fda723b;hb=831bd6aa3b2d5e36c94b89756f58bb99f35026ca;hp=ea1a7f70645d339d8346b365f4b2a20f2686519d;hpb=827041555ac443bd57340060f3e034fd7b199dd8;p=deliverable%2Fbinutils-gdb.git diff --git a/ld/plugin.c b/ld/plugin.c index ea1a7f7064..e253e1aea4 100644 --- a/ld/plugin.c +++ b/ld/plugin.c @@ -23,6 +23,7 @@ #include "bfd.h" #include "bfdlink.h" #include "bfdver.h" +#include "ctf-api.h" #include "ld.h" #include "ldmain.h" #include "ldmisc.h" @@ -403,12 +404,6 @@ asymbol_from_plugin_symbol (bfd *abfd, asymbol *asym, flags = BSF_GLOBAL; section = bfd_com_section_ptr; asym->value = ldsym->size; - /* For ELF targets, set alignment of common symbol to 1. */ - if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) - { - ((elf_symbol_type *) asym)->internal_elf_sym.st_shndx = SHN_COMMON; - ((elf_symbol_type *) asym)->internal_elf_sym.st_value = 1; - } break; default: @@ -417,7 +412,6 @@ asymbol_from_plugin_symbol (bfd *abfd, asymbol *asym, asym->flags = flags; asym->section = section; - /* Visibility only applies on ELF targets. */ if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) { elf_symbol_type *elfsym = elf_symbol_from (abfd, asym); @@ -425,6 +419,13 @@ asymbol_from_plugin_symbol (bfd *abfd, asymbol *asym, if (!elfsym) einfo (_("%F%P: %s: non-ELF symbol in ELF BFD!\n"), asym->name); + + if (ldsym->def == LDPK_COMMON) + { + elfsym->internal_elf_sym.st_shndx = SHN_COMMON; + elfsym->internal_elf_sym.st_value = 1; + } + switch (ldsym->visibility) { default: @@ -445,9 +446,7 @@ asymbol_from_plugin_symbol (bfd *abfd, asymbol *asym, visibility = STV_HIDDEN; break; } - elfsym->internal_elf_sym.st_other - = (visibility | (elfsym->internal_elf_sym.st_other - & ~ELF_ST_VISIBILITY (-1))); + elfsym->internal_elf_sym.st_other |= visibility; } return LDPS_OK; @@ -659,6 +658,73 @@ is_visible_from_outside (struct ld_plugin_symbol *lsym, return FALSE; } +/* Return LTO kind string name that corresponds to IDX enum value. */ +static const char * +get_lto_kind (unsigned int idx) +{ + static char buffer[64]; + const char *lto_kind_str[5] = + { + "DEF", + "WEAKDEF", + "UNDEF", + "WEAKUNDEF", + "COMMON" + }; + + if (idx < ARRAY_SIZE (lto_kind_str)) + return lto_kind_str [idx]; + + sprintf (buffer, _("unknown LTO kind value %x"), idx); + return buffer; +} + +/* Return LTO resolution string name that corresponds to IDX enum value. */ +static const char * +get_lto_resolution (unsigned int idx) +{ + static char buffer[64]; + static const char *lto_resolution_str[10] = + { + "UNKNOWN", + "UNDEF", + "PREVAILING_DEF", + "PREVAILING_DEF_IRONLY", + "PREEMPTED_REG", + "PREEMPTED_IR", + "RESOLVED_IR", + "RESOLVED_EXEC", + "RESOLVED_DYN", + "PREVAILING_DEF_IRONLY_EXP", + }; + + if (idx < ARRAY_SIZE (lto_resolution_str)) + return lto_resolution_str [idx]; + + sprintf (buffer, _("unknown LTO resolution value %x"), idx); + return buffer; +} + +/* Return LTO visibility string name that corresponds to IDX enum value. */ +static const char * +get_lto_visibility (unsigned int idx) +{ + static char buffer[64]; + const char *lto_visibility_str[4] = + { + "DEFAULT", + "PROTECTED", + "INTERNAL", + "HIDDEN" + }; + + if (idx < ARRAY_SIZE (lto_visibility_str)) + return lto_visibility_str [idx]; + + sprintf (buffer, _("unknown LTO visibility value %x"), idx); + return buffer; +} + /* Get the symbol resolution info for a plugin-claimed input file. */ static enum ld_plugin_status get_symbols (const void *handle, int nsyms, struct ld_plugin_symbol *syms, @@ -674,13 +740,32 @@ get_symbols (const void *handle, int nsyms, struct ld_plugin_symbol *syms, struct bfd_link_hash_entry *blhe; asection *owner_sec; int res; + struct bfd_link_hash_entry *h + = bfd_link_hash_lookup (link_info.hash, syms[n].name, + FALSE, FALSE, TRUE); + enum { wrap_none, wrapper, wrapped } wrap_status = wrap_none; - if (syms[n].def != LDPK_UNDEF) - blhe = bfd_link_hash_lookup (link_info.hash, syms[n].name, - FALSE, FALSE, TRUE); + if (syms[n].def != LDPK_UNDEF && syms[n].def != LDPK_WEAKUNDEF) + { + blhe = h; + if (blhe && link_info.wrap_hash != NULL) + { + /* Check if a symbol is a wrapper symbol. */ + struct bfd_link_hash_entry *unwrap + = unwrap_hash_lookup (&link_info, (bfd *) abfd, blhe); + if (unwrap && unwrap != h) + wrap_status = wrapper; + } + } else - blhe = bfd_wrapped_link_hash_lookup (link_info.output_bfd, &link_info, - syms[n].name, FALSE, FALSE, TRUE); + { + blhe = bfd_wrapped_link_hash_lookup (link_info.output_bfd, + &link_info, syms[n].name, + FALSE, FALSE, TRUE); + /* Check if a symbol is a wrapped symbol. */ + if (blhe && blhe != h) + wrap_status = wrapped; + } if (!blhe) { /* The plugin is called to claim symbols in an archive element @@ -766,9 +851,11 @@ get_symbols (const void *handle, int nsyms, struct ld_plugin_symbol *syms, /* We need to know if the sym is referenced from non-IR files. Or even potentially-referenced, perhaps in a future final link if this is a partial one, perhaps dynamically at load-time if the - symbol is externally visible. */ - if (blhe->non_ir_ref_regular) + symbol is externally visible. Also check for wrapper symbol. */ + if (blhe->non_ir_ref_regular || wrap_status == wrapper) res = LDPR_PREVAILING_DEF; + else if (wrap_status == wrapped) + res = LDPR_RESOLVED_IR; else if (is_visible_from_outside (&syms[n], blhe)) res = def_ironly_exp; } @@ -777,9 +864,11 @@ get_symbols (const void *handle, int nsyms, struct ld_plugin_symbol *syms, syms[n].resolution = res; if (report_plugin_symbols) einfo (_("%P: %pB: symbol `%s' " - "definition: %d, visibility: %d, resolution: %d\n"), + "definition: %s, visibility: %s, resolution: %s\n"), abfd, syms[n].name, - syms[n].def, syms[n].visibility, res); + get_lto_kind (syms[n].def), + get_lto_visibility (syms[n].visibility), + get_lto_resolution (res)); } return LDPS_OK; } @@ -1316,30 +1405,36 @@ plugin_notice (struct bfd_link_info *info, ref = TRUE; } - /* Otherwise, it must be a new def. */ - else + + /* A common symbol should be merged with other commons or + defs with the same name. In particular, a common ought + to be overridden by a def in a -flto object. In that + sense a common is also a ref. */ + else if (bfd_is_com_section (section)) { - /* Ensure any symbol defined in an IR dummy BFD takes on a - new value from a real BFD. Weak symbols are not normally - overridden by a new weak definition, and strong symbols - will normally cause multiple definition errors. Avoid - this by making the symbol appear to be undefined. */ - if (((h->type == bfd_link_hash_defweak - || h->type == bfd_link_hash_defined) - && is_ir_dummy_bfd (sym_bfd = h->u.def.section->owner)) - || (h->type == bfd_link_hash_common - && is_ir_dummy_bfd (sym_bfd = h->u.c.p->section->owner))) + if (h->type == bfd_link_hash_common + && is_ir_dummy_bfd (sym_bfd = h->u.c.p->section->owner)) { h->type = bfd_link_hash_undefweak; h->u.undef.abfd = sym_bfd; } + ref = TRUE; + } - /* A common symbol should be merged with other commons or - defs with the same name. In particular, a common ought - to be overridden by a def in a -flto object. In that - sense a common is also a ref. */ - if (bfd_is_com_section (section)) - ref = TRUE; + /* Otherwise, it must be a new def. + Ensure any symbol defined in an IR dummy BFD takes on a + new value from a real BFD. Weak symbols are not normally + overridden by a new weak definition, and strong symbols + will normally cause multiple definition errors. Avoid + this by making the symbol appear to be undefined. */ + else if (((h->type == bfd_link_hash_defweak + || h->type == bfd_link_hash_defined) + && is_ir_dummy_bfd (sym_bfd = h->u.def.section->owner)) + || (h->type == bfd_link_hash_common + && is_ir_dummy_bfd (sym_bfd = h->u.c.p->section->owner))) + { + h->type = bfd_link_hash_undefweak; + h->u.undef.abfd = sym_bfd; } if (ref)