X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=bfd%2Felflink.c;h=6624864bf540bd1bedc2c14b9950d52a33da9a21;hb=af2d5cd8e9f81832b04af6cd0e51def4065bbf71;hp=f7b867ca7bee3f8ea87b05921cd7076ad2e349e4;hpb=986f078366b193ed9f5bd02af965f3af958ba859;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/elflink.c b/bfd/elflink.c index f7b867ca7b..6624864bf5 100644 --- a/bfd/elflink.c +++ b/bfd/elflink.c @@ -2039,7 +2039,7 @@ _bfd_elf_add_default_symbol (bfd *abfd, /* We also need to define an indirection from the nondefault version of the symbol. */ -nondefault: + nondefault: len = strlen (name); shortname = (char *) bfd_hash_allocate (&info->hash->table, len); if (shortname == NULL) @@ -3323,8 +3323,8 @@ _bfd_elf_tls_setup (bfd *obfd, struct bfd_link_info *info) elf_hash_table (info)->tls_sec = tls; - /* Ensure the alignment of the first section is the largest alignment, - so that the tls segment starts aligned. */ + /* Ensure the alignment of the first section (usually .tdata) is the largest + alignment, so that the tls segment starts aligned. */ if (tls != NULL) tls->alignment_power = align; @@ -3501,23 +3501,119 @@ _bfd_elf_add_dynamic_entry (struct bfd_link_info *info, return TRUE; } -/* Add a DT_NEEDED entry for this dynamic object if DO_IT is true, - otherwise just check whether one already exists. Returns -1 on error, +/* Strip zero-sized dynamic sections. */ + +bfd_boolean +_bfd_elf_strip_zero_sized_dynamic_sections (struct bfd_link_info *info) +{ + struct elf_link_hash_table *hash_table; + const struct elf_backend_data *bed; + asection *s, *sdynamic, **pp; + asection *rela_dyn, *rel_dyn; + Elf_Internal_Dyn dyn; + bfd_byte *extdyn, *next; + void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *); + bfd_boolean strip_zero_sized; + bfd_boolean strip_zero_sized_plt; + + if (bfd_link_relocatable (info)) + return TRUE; + + hash_table = elf_hash_table (info); + if (!is_elf_hash_table (hash_table)) + return FALSE; + + if (!hash_table->dynobj) + return TRUE; + + sdynamic= bfd_get_linker_section (hash_table->dynobj, ".dynamic"); + if (!sdynamic) + return TRUE; + + bed = get_elf_backend_data (hash_table->dynobj); + swap_dyn_in = bed->s->swap_dyn_in; + + strip_zero_sized = FALSE; + strip_zero_sized_plt = FALSE; + + /* Strip zero-sized dynamic sections. */ + rela_dyn = bfd_get_section_by_name (info->output_bfd, ".rela.dyn"); + rel_dyn = bfd_get_section_by_name (info->output_bfd, ".rel.dyn"); + for (pp = &info->output_bfd->sections; (s = *pp) != NULL;) + if (s->size == 0 + && (s == rela_dyn + || s == rel_dyn + || s == hash_table->srelplt->output_section + || s == hash_table->splt->output_section)) + { + *pp = s->next; + info->output_bfd->section_count--; + strip_zero_sized = TRUE; + if (s == rela_dyn) + s = rela_dyn; + if (s == rel_dyn) + s = rel_dyn; + else if (s == hash_table->splt->output_section) + { + s = hash_table->splt; + strip_zero_sized_plt = TRUE; + } + else + s = hash_table->srelplt; + s->flags |= SEC_EXCLUDE; + s->output_section = bfd_abs_section_ptr; + } + else + pp = &s->next; + + if (strip_zero_sized_plt) + for (extdyn = sdynamic->contents; + extdyn < sdynamic->contents + sdynamic->size; + extdyn = next) + { + next = extdyn + bed->s->sizeof_dyn; + swap_dyn_in (hash_table->dynobj, extdyn, &dyn); + switch (dyn.d_tag) + { + default: + break; + case DT_JMPREL: + case DT_PLTRELSZ: + case DT_PLTREL: + /* Strip DT_PLTRELSZ, DT_JMPREL and DT_PLTREL entries if + the procedure linkage table (the .plt section) has been + removed. */ + memmove (extdyn, next, + sdynamic->size - (next - sdynamic->contents)); + next = extdyn; + } + } + + if (strip_zero_sized) + { + /* Regenerate program headers. */ + elf_seg_map (info->output_bfd) = NULL; + return _bfd_elf_map_sections_to_segments (info->output_bfd, info); + } + + return TRUE; +} + +/* Add a DT_NEEDED entry for this dynamic object. Returns -1 on error, 1 if a DT_NEEDED tag already exists, and 0 on success. */ -static int -elf_add_dt_needed_tag (bfd *abfd, - struct bfd_link_info *info, - const char *soname, - bfd_boolean do_it) +int +bfd_elf_add_dt_needed_tag (bfd *abfd, struct bfd_link_info *info) { struct elf_link_hash_table *hash_table; size_t strindex; + const char *soname; if (!_bfd_elf_link_create_dynstrtab (abfd, info)) return -1; hash_table = elf_hash_table (info); + soname = elf_dt_name (abfd); strindex = _bfd_elf_strtab_add (hash_table->dynstr, soname, FALSE); if (strindex == (size_t) -1) return -1; @@ -3547,17 +3643,11 @@ elf_add_dt_needed_tag (bfd *abfd, } } - if (do_it) - { - if (!_bfd_elf_link_create_dynamic_sections (hash_table->dynobj, info)) - return -1; + if (!_bfd_elf_link_create_dynamic_sections (hash_table->dynobj, info)) + return -1; - if (!_bfd_elf_add_dynamic_entry (info, DT_NEEDED, strindex)) - return -1; - } - else - /* We were just checking for existence of the tag. */ - _bfd_elf_strtab_delref (hash_table->dynstr, strindex); + if (!_bfd_elf_add_dynamic_entry (info, DT_NEEDED, strindex)) + return -1; return 0; } @@ -4069,7 +4159,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info) char *audit = NULL; struct bfd_link_needed_list *rpath = NULL, *runpath = NULL; const Elf_Internal_Phdr *phdr; - int ret; + struct elf_link_loaded_list *loaded_lib; /* ld --just-symbols and dynamic objects don't mix very well. ld shouldn't allow it. */ @@ -4097,7 +4187,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info) if (!bfd_malloc_and_get_section (abfd, s, &dynbuf)) { -error_free_dyn: + error_free_dyn: free (dynbuf); goto error_return; } @@ -4226,10 +4316,14 @@ error_free_dyn: if (phdr->p_type == PT_GNU_RELRO) { for (s = abfd->sections; s != NULL; s = s->next) - if ((s->flags & SEC_ALLOC) != 0 - && s->vma >= phdr->p_vaddr - && s->vma + s->size <= phdr->p_vaddr + phdr->p_memsz) - s->flags |= SEC_READONLY; + { + unsigned int opb = bfd_octets_per_byte (abfd, s); + + if ((s->flags & SEC_ALLOC) != 0 + && s->vma * opb >= phdr->p_vaddr + && s->vma * opb + s->size <= phdr->p_vaddr + phdr->p_memsz) + s->flags |= SEC_READONLY; + } break; } @@ -4258,15 +4352,22 @@ error_free_dyn: will need to know it. */ elf_dt_name (abfd) = soname; - ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed); - if (ret < 0) - goto error_return; - /* If we have already included this dynamic object in the link, just ignore it. There is no reason to include a particular dynamic object more than once. */ - if (ret > 0) - return TRUE; + for (loaded_lib = htab->dyn_loaded; + loaded_lib != NULL; + loaded_lib = loaded_lib->next) + { + if (strcmp (elf_dt_name (loaded_lib->abfd), soname) == 0) + return TRUE; + } + + /* Create dynamic sections for backends that require that be done + before setup_gnu_properties. */ + if (add_needed + && !_bfd_elf_link_create_dynamic_sections (abfd, info)) + return FALSE; /* Save the DT_AUDIT entry for the linker emulation code. */ elf_dt_audit (abfd) = audit; @@ -4332,12 +4433,12 @@ error_free_dyn: Elf_Internal_Shdr *versymhdr = &elf_tdata (abfd)->dynversym_hdr; bfd_size_type amt = versymhdr->sh_size; - extversym = (Elf_External_Versym *) bfd_malloc (amt); + if (bfd_seek (abfd, versymhdr->sh_offset, SEEK_SET) != 0) + goto error_free_sym; + extversym = (Elf_External_Versym *) + _bfd_malloc_and_read (abfd, amt, amt); if (extversym == NULL) goto error_free_sym; - if (bfd_seek (abfd, versymhdr->sh_offset, SEEK_SET) != 0 - || bfd_bread (extversym, amt, abfd) != amt) - goto error_free_vers; extversym_end = extversym + amt / sizeof (*extversym); } } @@ -4389,9 +4490,13 @@ error_free_dyn: old_table = htab->root.table.table; old_size = htab->root.table.size; old_count = htab->root.table.count; - old_strtab = _bfd_elf_strtab_save (htab->dynstr); - if (old_strtab == NULL) - goto error_free_vers; + old_strtab = NULL; + if (htab->dynstr != NULL) + { + old_strtab = _bfd_elf_strtab_save (htab->dynstr); + if (old_strtab == NULL) + goto error_free_vers; + } for (i = 0; i < htab->root.table.size; i++) { @@ -5102,7 +5207,6 @@ error_free_dyn: && !on_needed_list (elf_dt_name (abfd), htab->needed, NULL)))) { - int ret; const char *soname = elf_dt_name (abfd); info->callbacks->minfo ("%!", soname, old_bfd, @@ -5127,12 +5231,11 @@ error_free_dyn: elf_dyn_lib_class (abfd) = (enum dynamic_lib_link_class) (elf_dyn_lib_class (abfd) & ~DYN_AS_NEEDED); + /* Create dynamic sections for backends that require + that be done before setup_gnu_properties. */ + if (!_bfd_elf_link_create_dynamic_sections (abfd, info)) + return FALSE; add_needed = TRUE; - ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed); - if (ret < 0) - goto error_free_vers; - - BFD_ASSERT (ret == 0); } } } @@ -5222,7 +5325,8 @@ error_free_dyn: memcpy (htab->root.table.table, old_tab, tabsize); htab->root.undefs = old_undefs; htab->root.undefs_tail = old_undefs_tail; - _bfd_elf_strtab_restore (htab->dynstr, old_strtab); + if (htab->dynstr != NULL) + _bfd_elf_strtab_restore (htab->dynstr, old_strtab); free (old_strtab); old_strtab = NULL; for (i = 0; i < htab->root.table.size; i++) @@ -5550,7 +5654,7 @@ error_free_dyn: } } - if (is_elf_hash_table (htab) && add_needed) + if (dynamic && add_needed) { /* Add this bfd to the loaded list. */ struct elf_link_loaded_list *n; @@ -5559,9 +5663,12 @@ error_free_dyn: if (n == NULL) goto error_return; n->abfd = abfd; - n->next = htab->loaded; - htab->loaded = n; + n->next = htab->dyn_loaded; + htab->dyn_loaded = n; } + if (dynamic && !add_needed + && (elf_dyn_lib_class (abfd) & DYN_DT_NEEDED) != 0) + elf_dyn_lib_class (abfd) |= DYN_NO_NEEDED; return TRUE; @@ -7931,9 +8038,10 @@ elf_create_symbuf (size_t symcount, Elf_Internal_Sym *isymbuf) Elf_Internal_Sym **ind, **indbufend, **indbuf; struct elf_symbuf_symbol *ssym; struct elf_symbuf_head *ssymbuf, *ssymhead; - size_t i, shndx_count, total_size; + size_t i, shndx_count, total_size, amt; - indbuf = (Elf_Internal_Sym **) bfd_malloc2 (symcount, sizeof (*indbuf)); + amt = symcount * sizeof (*indbuf); + indbuf = (Elf_Internal_Sym **) bfd_malloc (amt); if (indbuf == NULL) return NULL; @@ -8203,7 +8311,7 @@ bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2, result = TRUE; -done: + done: if (symtable1) free (symtable1); if (symtable2) @@ -9688,7 +9796,7 @@ elf_link_check_versioned_symbol (struct bfd_link_info *info, } BFD_ASSERT (abfd != NULL); - for (loaded = elf_hash_table (info)->loaded; + for (loaded = elf_hash_table (info)->dyn_loaded; loaded != NULL; loaded = loaded->next) { @@ -9708,7 +9816,6 @@ elf_link_check_versioned_symbol (struct bfd_link_info *info, /* We check each DSO for a possible hidden versioned definition. */ if (input == abfd - || (input->flags & DYNAMIC) == 0 || elf_dynversym (input) == 0) continue; @@ -9736,16 +9843,11 @@ elf_link_check_versioned_symbol (struct bfd_link_info *info, /* Read in any version definitions. */ versymhdr = &elf_tdata (input)->dynversym_hdr; - extversym = (Elf_External_Versym *) bfd_malloc (versymhdr->sh_size); - if (extversym == NULL) - goto error_ret; - if (bfd_seek (input, versymhdr->sh_offset, SEEK_SET) != 0 - || (bfd_bread (extversym, versymhdr->sh_size, input) - != versymhdr->sh_size)) + || (extversym = (Elf_External_Versym *) + _bfd_malloc_and_read (input, versymhdr->sh_size, + versymhdr->sh_size)) == NULL) { - free (extversym); - error_ret: free (isymbuf); return FALSE; } @@ -9882,11 +9984,13 @@ elf_link_output_extsym (struct bfd_hash_entry *bh, void *data) && (!h->ref_regular || flinfo->info->gc_sections) && !elf_link_check_versioned_symbol (flinfo->info, bed, h) && flinfo->info->unresolved_syms_in_shared_libs != RM_IGNORE) - (*flinfo->info->callbacks->undefined_symbol) - (flinfo->info, h->root.root.string, - h->ref_regular ? NULL : h->root.u.undef.abfd, - NULL, 0, - flinfo->info->unresolved_syms_in_shared_libs == RM_GENERATE_ERROR); + { + flinfo->info->callbacks->undefined_symbol + (flinfo->info, h->root.root.string, + h->ref_regular ? NULL : h->root.u.undef.abfd, NULL, 0, + flinfo->info->unresolved_syms_in_shared_libs == RM_DIAGNOSE + && !flinfo->info->warn_unresolved_syms); + } /* Strip a global symbol defined in a discarded section. */ if (h->indx == -3) @@ -10563,6 +10667,18 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd) /* If this symbol is defined in a section which we are discarding, we don't need to keep it. */ + if (isym->st_shndx != SHN_UNDEF + && isym->st_shndx < SHN_LORESERVE + && isec->output_section == NULL + && flinfo->info->non_contiguous_regions + && flinfo->info->non_contiguous_regions_warnings) + { + _bfd_error_handler (_("warning: --enable-non-contiguous-regions " + "discards section `%s' from '%s'\n"), + isec->name, isec->owner->filename); + continue; + } + if (isym->st_shndx != SHN_UNDEF && isym->st_shndx < SHN_LORESERVE && bfd_section_removed_from_list (output_bfd, @@ -11562,8 +11678,8 @@ elf_fixup_link_order (bfd *abfd, asection *o) struct bfd_link_order *p; bfd *sub; struct bfd_link_order **sections; - asection *s, *other_sec, *linkorder_sec; - bfd_vma offset; + asection *other_sec, *linkorder_sec; + bfd_vma offset; /* Octets. */ other_sec = NULL; linkorder_sec = NULL; @@ -11573,7 +11689,7 @@ elf_fixup_link_order (bfd *abfd, asection *o) { if (p->type == bfd_indirect_link_order) { - s = p->u.indirect.section; + asection *s = p->u.indirect.section; sub = s->owner; if ((s->flags & SEC_LINKER_CREATED) == 0 && bfd_get_flavour (sub) == bfd_target_elf_flavour @@ -11628,11 +11744,12 @@ elf_fixup_link_order (bfd *abfd, asection *o) for (n = 0; n < seen_linkorder; n++) { bfd_vma mask; - s = sections[n]->u.indirect.section; - mask = ~(bfd_vma) 0 << s->alignment_power; + asection *s = sections[n]->u.indirect.section; + unsigned int opb = bfd_octets_per_byte (abfd, s); + + mask = ~(bfd_vma) 0 << s->alignment_power * opb; offset = (offset + ~mask) & mask; - s->output_offset = offset / bfd_octets_per_byte (abfd, s); - sections[n]->offset = offset; + sections[n]->offset = s->output_offset = offset / opb; offset += sections[n]->size; } @@ -11657,6 +11774,7 @@ elf_output_implib (bfd *abfd, struct bfd_link_info *info) long symcount; long src_count; elf_symbol_type *osymbuf; + size_t amt; implib_bfd = info->out_implib_bfd; bed = get_elf_backend_data (abfd); @@ -11714,8 +11832,8 @@ elf_output_implib (bfd *abfd, struct bfd_link_info *info) /* Make symbols absolute. */ - osymbuf = (elf_symbol_type *) bfd_alloc2 (implib_bfd, symcount, - sizeof (*osymbuf)); + amt = symcount * sizeof (*osymbuf); + osymbuf = (elf_symbol_type *) bfd_alloc (implib_bfd, amt); if (osymbuf == NULL) goto free_sym_buf; @@ -11744,7 +11862,7 @@ elf_output_implib (bfd *abfd, struct bfd_link_info *info) ret = TRUE; -free_sym_buf: + free_sym_buf: free (sympp); return ret; } @@ -12242,7 +12360,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info) if (htab->tls_sec) { - bfd_vma base, end = 0; + bfd_vma base, end = 0; /* Both bytes. */ asection *sec; for (sec = htab->tls_sec; @@ -12250,6 +12368,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info) sec = sec->next) { bfd_size_type size = sec->size; + unsigned int opb = bfd_octets_per_byte (abfd, sec); if (size == 0 && (sec->flags & SEC_HAS_CONTENTS) == 0) @@ -12257,9 +12376,9 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info) struct bfd_link_order *ord = sec->map_tail.link_order; if (ord != NULL) - size = ord->offset + ord->size; + size = ord->offset * opb + ord->size; } - end = sec->vma + size; + end = sec->vma + size / opb; } base = htab->tls_sec->vma; /* Only align end of TLS section if static TLS doesn't have special @@ -12772,6 +12891,8 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info) if (bed->dtrel_excludes_plt && htab->srelplt != NULL) { + unsigned int opb = bfd_octets_per_byte (abfd, o); + /* Don't count procedure linkage table relocs in the overall reloc count. */ sh_size -= htab->srelplt->size; @@ -12791,7 +12912,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info) /* If .rela.plt is the first .rela section, exclude it from DT_RELA. */ else if (sh_addr == (htab->srelplt->output_section->vma - + htab->srelplt->output_offset)) + + htab->srelplt->output_offset) * opb) sh_addr += htab->srelplt->size; } @@ -14246,7 +14367,7 @@ bfd_elf_discard_info (bfd *output_bfd, struct bfd_link_info *info) { asection *i; int eh_changed = 0; - unsigned int eh_alignment; + unsigned int eh_alignment; /* Octets. */ for (i = o->map_head.s; i != NULL; i = i->map_head.s) { @@ -14273,7 +14394,8 @@ bfd_elf_discard_info (bfd *output_bfd, struct bfd_link_info *info) fini_reloc_cookie_for_section (&cookie, i); } - eh_alignment = 1 << o->alignment_power; + eh_alignment = ((1 << o->alignment_power) + * bfd_octets_per_byte (output_bfd, o)); /* Skip over zero terminator, and prevent empty sections from adding alignment padding at the end. */ for (i = o->map_tail.s; i != NULL; i = i->map_tail.s)