/* ELF linking support for BFD.
- Copyright (C) 1995-2014 Free Software Foundation, Inc.
+ Copyright (C) 1995-2015 Free Software Foundation, Inc.
This file is part of BFD, the Binary File Descriptor library.
}
bh = &h->root;
+ bed = get_elf_backend_data (abfd);
if (!_bfd_generic_link_add_one_symbol (info, abfd, name, BSF_GLOBAL,
- sec, 0, NULL, FALSE,
- get_elf_backend_data (abfd)->collect,
+ sec, 0, NULL, FALSE, bed->collect,
&bh))
return NULL;
h = (struct elf_link_hash_entry *) bh;
h->def_regular = 1;
h->non_elf = 0;
+ h->root.linker_def = 1;
h->type = STT_OBJECT;
if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL)
h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
- bed = get_elf_backend_data (abfd);
(*bed->elf_backend_hide_symbol) (info, h, TRUE);
return h;
}
asection *p)
{
struct elf_link_hash_table *htab;
+ asection *ip;
switch (elf_section_data (p)->this_hdr.sh_type)
{
if (htab->text_index_section != NULL)
return p != htab->text_index_section && p != htab->data_index_section;
- if (strcmp (p->name, ".got") == 0
- || strcmp (p->name, ".got.plt") == 0
- || strcmp (p->name, ".plt") == 0)
- {
- asection *ip;
-
- if (htab->dynobj != NULL
+ return (htab->dynobj != NULL
&& (ip = bfd_get_linker_section (htab->dynobj, p->name)) != NULL
- && ip->output_section == p)
- return TRUE;
- }
- return FALSE;
+ && ip->output_section == p);
/* There shouldn't be section relative relocations
against any other section. */
if (symvis - 1 < hvis - 1)
h->other = symvis | (h->other & ~ELF_ST_VISIBILITY (-1));
}
+ else if (definition && ELF_ST_VISIBILITY (isym->st_other) != STV_DEFAULT)
+ h->protected_def = 1;
}
/* This function is called when we want to merge a new symbol with an
{
struct elf_link_hash_entry **p;
- p = (struct elf_link_hash_entry **)
- bfd_zmalloc (reldata->count * sizeof (struct elf_link_hash_entry *));
+ p = ((struct elf_link_hash_entry **)
+ bfd_zmalloc (reldata->count * sizeof (*p)));
if (p == NULL)
return FALSE;
DYNBSS. */
bfd_boolean
-_bfd_elf_adjust_dynamic_copy (struct elf_link_hash_entry *h,
+_bfd_elf_adjust_dynamic_copy (struct bfd_link_info *info,
+ struct elf_link_hash_entry *h,
asection *dynbss)
{
unsigned int power_of_two;
/* Increment the size of DYNBSS to make room for the symbol. */
dynbss->size += h->size;
+ if (h->protected_def)
+ {
+ info->callbacks->einfo
+ (_("%P: copy reloc against protected `%T' is invalid\n"),
+ h->root.root.string);
+ bfd_set_error (bfd_error_bad_value);
+ return FALSE;
+ }
+
return TRUE;
}
requested we not re-export it, then mark it as hidden. */
if (definition
&& !dynamic
- && (abfd->no_export
- || (abfd->my_archive && abfd->my_archive->no_export))
+ && abfd->no_export
&& ELF_ST_VISIBILITY (isym->st_other) != STV_INTERNAL)
isym->st_other = (STV_HIDDEN
| (isym->st_other & ~ELF_ST_VISIBILITY (-1)));
{
amt = ((isymend - isym + 1)
* sizeof (struct elf_link_hash_entry *));
- nondeflt_vers =
- (struct elf_link_hash_entry **) bfd_malloc (amt);
+ nondeflt_vers
+ = (struct elf_link_hash_entry **) bfd_malloc (amt);
if (!nondeflt_vers)
goto error_free_vers;
}
}
elf_dyn_lib_class (abfd) = (enum dynamic_lib_link_class)
- (elf_dyn_lib_class (abfd) & ~DYN_AS_NEEDED);
+ (elf_dyn_lib_class (abfd) & ~DYN_AS_NEEDED);
add_needed = TRUE;
ret = elf_add_dt_needed_tag (abfd, info, soname, add_needed);
/* Add this bfd to the loaded list. */
struct elf_link_loaded_list *n;
- n = (struct elf_link_loaded_list *)
- bfd_alloc (abfd, sizeof (struct elf_link_loaded_list));
+ n = (struct elf_link_loaded_list *) bfd_alloc (abfd, sizeof (*n));
if (n == NULL)
goto error_return;
n->abfd = abfd;
{
best_chlen = max;
best_size = i;
- no_improvement_count = 0;
+ no_improvement_count = 0;
}
/* PR 11843: Avoid futile long searches for the best bucket size
when there are a large number of symbols. */
if (entry == NULL)
{
entry = (struct bfd_hash_entry *)
- bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry));
+ bfd_hash_allocate (table, sizeof (struct elf_link_hash_entry));
if (entry == NULL)
return entry;
}
if (count1 == 0 || count2 == 0 || count1 != count2)
goto done;
- symtable1 = (struct elf_symbol *)
- bfd_malloc (count1 * sizeof (struct elf_symbol));
- symtable2 = (struct elf_symbol *)
- bfd_malloc (count2 * sizeof (struct elf_symbol));
+ symtable1
+ = (struct elf_symbol *) bfd_malloc (count1 * sizeof (*symtable1));
+ symtable2
+ = (struct elf_symbol *) bfd_malloc (count2 * sizeof (*symtable2));
if (symtable1 == NULL || symtable2 == NULL)
goto done;
{
bfd_boolean failed;
bfd_boolean localsyms;
- bfd_boolean need_second_pass;
- bfd_boolean second_pass;
bfd_boolean file_sym_done;
struct elf_final_link_info *flinfo;
};
struct elf_link_hash_entry *);
const struct elf_backend_data *bed;
+ BFD_ASSERT (elf_onesymtab (flinfo->output_bfd));
+
bed = get_elf_backend_data (flinfo->output_bfd);
output_symbol_hook = bed->elf_backend_link_output_symbol_hook;
if (output_symbol_hook != NULL)
amt = flinfo->shndxbuf_size * sizeof (Elf_External_Sym_Shndx);
destshndx = (Elf_External_Sym_Shndx *) bfd_realloc (destshndx,
- amt * 2);
+ amt * 2);
if (destshndx == NULL)
return 0;
flinfo->symshndxbuf = destshndx;
{
if (!h->forced_local)
return TRUE;
- if (eoinfo->second_pass
- && !((h->root.type == bfd_link_hash_defined
- || h->root.type == bfd_link_hash_defweak)
- && h->root.u.def.section->output_section != NULL))
- return TRUE;
-
- if (!eoinfo->file_sym_done
- && (eoinfo->second_pass ? eoinfo->flinfo->filesym_count == 1
- : eoinfo->flinfo->filesym_count > 1))
- {
- /* Output a FILE symbol so that following locals are not associated
- with the wrong input file. */
- memset (&sym, 0, sizeof (sym));
- sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
- sym.st_shndx = SHN_ABS;
- if (!elf_link_output_sym (eoinfo->flinfo, NULL, &sym,
- bfd_und_section_ptr, NULL))
- return FALSE;
-
- eoinfo->file_sym_done = TRUE;
- }
}
else
{
a regular file, or that we have been told to strip. However, if
h->indx is set to -2, the symbol is used by a reloc and we must
output it. */
+ strip = FALSE;
if (h->indx == -2)
- strip = FALSE;
+ ;
else if ((h->def_dynamic
|| h->ref_dynamic
|| h->root.type == bfd_link_hash_new)
|| h->root.type == bfd_link_hash_defweak)
&& ((flinfo->info->strip_discarded
&& discarded_section (h->root.u.def.section))
- || (h->root.u.def.section->owner != NULL
+ || ((h->root.u.def.section->flags & SEC_LINKER_CREATED) == 0
+ && h->root.u.def.section->owner != NULL
&& (h->root.u.def.section->owner->flags & BFD_PLUGIN) != 0)))
strip = TRUE;
else if ((h->root.type == bfd_link_hash_undefined
&& h->root.u.undef.abfd != NULL
&& (h->root.u.undef.abfd->flags & BFD_PLUGIN) != 0)
strip = TRUE;
- else
- strip = FALSE;
/* If we're stripping it, and it's not a dynamic symbol, there's
- nothing else to do unless it is a forced local symbol or a
- STT_GNU_IFUNC symbol. */
+ nothing else to do. However, if it is a forced local symbol or
+ an ifunc symbol we need to give the backend finish_dynamic_symbol
+ function a chance to make it dynamic. */
if (strip
&& h->dynindx == -1
&& h->type != STT_GNU_IFUNC
input_sec = h->root.u.def.section;
if (input_sec->output_section != NULL)
{
- if (eoinfo->localsyms && flinfo->filesym_count == 1)
- {
- bfd_boolean second_pass_sym
- = (input_sec->owner == flinfo->output_bfd
- || input_sec->owner == NULL
- || (input_sec->flags & SEC_LINKER_CREATED) != 0
- || (input_sec->owner->flags & BFD_LINKER_CREATED) != 0);
-
- eoinfo->need_second_pass |= second_pass_sym;
- if (eoinfo->second_pass != second_pass_sym)
- return TRUE;
- }
-
sym.st_shndx =
_bfd_elf_section_from_bfd_section (flinfo->output_bfd,
input_sec->output_section);
asection *tls_sec = elf_hash_table (flinfo->info)->tls_sec;
if (tls_sec != NULL)
sym.st_value -= tls_sec->vma;
- else
- {
- /* The TLS section may have been garbage collected. */
- BFD_ASSERT (flinfo->info->gc_sections
- && !input_sec->gc_mark);
- }
}
}
}
}
}
- /* If we're stripping it, then it was just a dynamic symbol, and
- there's nothing else to do. */
- if (strip || (input_sec->flags & SEC_EXCLUDE) != 0)
+ /* If the symbol is undefined, and we didn't output it to .dynsym,
+ strip it from .symtab too. Obviously we can't do this for
+ relocatable output or when needed for --emit-relocs. */
+ else if (input_sec == bfd_und_section_ptr
+ && h->indx != -2
+ && !flinfo->info->relocatable)
+ return TRUE;
+ /* Also strip others that we couldn't earlier due to dynamic symbol
+ processing. */
+ if (strip)
+ return TRUE;
+ if ((input_sec->flags & SEC_EXCLUDE) != 0)
return TRUE;
+ /* Output a FILE symbol so that following locals are not associated
+ with the wrong input file. We need one for forced local symbols
+ if we've seen more than one FILE symbol or when we have exactly
+ one FILE symbol but global symbols are present in a file other
+ than the one with the FILE symbol. We also need one if linker
+ defined symbols are present. In practice these conditions are
+ always met, so just emit the FILE symbol unconditionally. */
+ if (eoinfo->localsyms
+ && !eoinfo->file_sym_done
+ && eoinfo->flinfo->filesym_count != 0)
+ {
+ Elf_Internal_Sym fsym;
+
+ memset (&fsym, 0, sizeof (fsym));
+ fsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
+ fsym.st_shndx = SHN_ABS;
+ if (!elf_link_output_sym (eoinfo->flinfo, NULL, &fsym,
+ bfd_und_section_ptr, NULL))
+ return FALSE;
+
+ eoinfo->file_sym_done = TRUE;
+ }
+
indx = bfd_get_symcount (flinfo->output_bfd);
ret = elf_link_output_sym (flinfo, h->root.root.string, &sym, input_sec, h);
if (ret == 0)
*ppsection = isec;
- /* Don't output the first, undefined, symbol. */
- if (ppsection == flinfo->sections)
+ /* Don't output the first, undefined, symbol. In fact, don't
+ output any undefined local symbol. */
+ if (isec == bfd_und_section_ptr)
continue;
if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
if (ELF_ST_TYPE (isym->st_info) == STT_FILE)
{
+ if (input_bfd->lto_output)
+ /* -flto puts a temp file name here. This means builds
+ are not reproducible. Discard the symbol. */
+ continue;
have_file_sym = TRUE;
flinfo->filesym_count += 1;
}
memset (&osym, 0, sizeof (osym));
osym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
osym.st_shndx = SHN_ABS;
- if (!elf_link_output_sym (flinfo, input_bfd->filename, &osym,
- bfd_abs_section_ptr, NULL))
+ if (!elf_link_output_sym (flinfo,
+ (input_bfd->lto_output ? NULL
+ : input_bfd->filename),
+ &osym, bfd_abs_section_ptr, NULL))
return FALSE;
}
s_type = h->type;
+ /* If a plugin symbol is referenced from a non-IR file,
+ mark the symbol as undefined. Note that the
+ linker may attach linker created dynamic sections
+ to the plugin bfd. Symbols defined in linker
+ created sections are not plugin symbols. */
+ if (h->root.non_ir_ref
+ && (h->root.type == bfd_link_hash_defined
+ || h->root.type == bfd_link_hash_defweak)
+ && (h->root.u.def.section->flags
+ & SEC_LINKER_CREATED) == 0
+ && h->root.u.def.section->owner != NULL
+ && (h->root.u.def.section->owner->flags
+ & BFD_PLUGIN) != 0)
+ {
+ h->root.type = bfd_link_hash_undefined;
+ h->root.u.undef.abfd = h->root.u.def.section->owner;
+ }
+
ps = NULL;
if (h->root.type == bfd_link_hash_defined
|| h->root.type == bfd_link_hash_defweak)
size = (bfd_size_type) bfd_get_reloc_size (howto);
buf = (bfd_byte *) bfd_zmalloc (size);
- if (buf == NULL)
+ if (buf == NULL && size != 0)
return FALSE;
rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf);
switch (rstat)
bfd_size_type max_internal_reloc_count;
bfd_size_type max_sym_count;
bfd_size_type max_sym_shndx_count;
- file_ptr off;
Elf_Internal_Sym elfsym;
unsigned int i;
Elf_Internal_Shdr *symtab_hdr;
Elf_Internal_Shdr *symtab_shndx_hdr;
- Elf_Internal_Shdr *symstrtab_hdr;
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
struct elf_outext_info eoinfo;
bfd_boolean merged;
/* Figure out the file positions for everything but the symbol table
and the relocs. We set symcount to force assign_section_numbers
to create a symbol table. */
- bfd_get_symcount (abfd) = info->strip == strip_all ? 0 : 1;
+ bfd_get_symcount (abfd) = info->strip != strip_all || emit_relocs;
BFD_ASSERT (! abfd->output_has_begun);
if (! _bfd_elf_compute_section_file_positions (abfd, info))
goto error_return;
/* sh_offset is set just below. */
symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
- off = elf_next_file_pos (abfd);
- off = _bfd_elf_assign_file_position_for_section (symtab_hdr, off, TRUE);
-
- /* Note that at this point elf_next_file_pos (abfd) is
- incorrect. We do not yet know the size of the .symtab section.
- We correct next_file_pos below, after we do know the size. */
-
/* Allocate a buffer to hold swapped out symbols. This is to avoid
continuously seeking to the right position in the file. */
if (! info->keep_memory || max_sym_count < 20)
goto error_return;
}
- /* Start writing out the symbol table. The first symbol is always a
- dummy symbol. */
- if (info->strip != strip_all
- || emit_relocs)
+ if (info->strip != strip_all || emit_relocs)
{
+ file_ptr off = elf_next_file_pos (abfd);
+
+ _bfd_elf_assign_file_position_for_section (symtab_hdr, off, TRUE);
+
+ /* Note that at this point elf_next_file_pos (abfd) is
+ incorrect. We do not yet know the size of the .symtab section.
+ We correct next_file_pos below, after we do know the size. */
+
+ /* Start writing out the symbol table. The first symbol is always a
+ dummy symbol. */
elfsym.st_value = 0;
elfsym.st_size = 0;
elfsym.st_info = 0;
if (elf_link_output_sym (&flinfo, NULL, &elfsym, bfd_und_section_ptr,
NULL) != 1)
goto error_return;
- }
- /* Output a symbol for each section. We output these even if we are
- discarding local symbols, since they are used for relocs. These
- symbols have no names. We store the index of each one in the
- index field of the section, so that we can find it again when
- outputting relocs. */
- if (info->strip != strip_all
- || emit_relocs)
- {
+ /* Output a symbol for each section. We output these even if we are
+ discarding local symbols, since they are used for relocs. These
+ symbols have no names. We store the index of each one in the
+ index field of the section, so that we can find it again when
+ outputting relocs. */
+
elfsym.st_size = 0;
elfsym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
elfsym.st_other = 0;
eoinfo.failed = FALSE;
eoinfo.flinfo = &flinfo;
eoinfo.localsyms = TRUE;
- eoinfo.need_second_pass = FALSE;
- eoinfo.second_pass = FALSE;
eoinfo.file_sym_done = FALSE;
bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
if (eoinfo.failed)
return FALSE;
- if (eoinfo.need_second_pass)
- {
- eoinfo.second_pass = TRUE;
- bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
- if (eoinfo.failed)
- return FALSE;
- }
-
/* If backend needs to output some local symbols not present in the hash
table, do it now. */
- if (bed->elf_backend_output_arch_local_syms)
+ if (bed->elf_backend_output_arch_local_syms
+ && (info->strip != strip_all || emit_relocs))
{
typedef int (*out_sym_func)
(void *, const char *, Elf_Internal_Sym *, asection *,
/* If backend needs to output some symbols not present in the hash
table, do it now. */
- if (bed->elf_backend_output_arch_syms)
+ if (bed->elf_backend_output_arch_syms
+ && (info->strip != strip_all || emit_relocs))
{
typedef int (*out_sym_func)
(void *, const char *, Elf_Internal_Sym *, asection *,
return FALSE;
/* Now we know the size of the symtab section. */
- off += symtab_hdr->sh_size;
-
- symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
- if (symtab_shndx_hdr->sh_name != 0)
+ if (bfd_get_symcount (abfd) > 0)
{
- symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
- symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
- symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
- amt = bfd_get_symcount (abfd) * sizeof (Elf_External_Sym_Shndx);
- symtab_shndx_hdr->sh_size = amt;
+ /* Finish up and write out the symbol string table (.strtab)
+ section. */
+ Elf_Internal_Shdr *symstrtab_hdr;
+ file_ptr off = symtab_hdr->sh_offset + symtab_hdr->sh_size;
- off = _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr,
- off, TRUE);
+ symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
+ if (symtab_shndx_hdr->sh_name != 0)
+ {
+ symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
+ symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
+ symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
+ amt = bfd_get_symcount (abfd) * sizeof (Elf_External_Sym_Shndx);
+ symtab_shndx_hdr->sh_size = amt;
- if (bfd_seek (abfd, symtab_shndx_hdr->sh_offset, SEEK_SET) != 0
- || (bfd_bwrite (flinfo.symshndxbuf, amt, abfd) != amt))
- return FALSE;
- }
+ off = _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr,
+ off, TRUE);
+ if (bfd_seek (abfd, symtab_shndx_hdr->sh_offset, SEEK_SET) != 0
+ || (bfd_bwrite (flinfo.symshndxbuf, amt, abfd) != amt))
+ return FALSE;
+ }
- /* Finish up and write out the symbol string table (.strtab)
- section. */
- symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
- /* sh_name was set in prep_headers. */
- symstrtab_hdr->sh_type = SHT_STRTAB;
- symstrtab_hdr->sh_flags = 0;
- symstrtab_hdr->sh_addr = 0;
- symstrtab_hdr->sh_size = _bfd_stringtab_size (flinfo.symstrtab);
- symstrtab_hdr->sh_entsize = 0;
- symstrtab_hdr->sh_link = 0;
- symstrtab_hdr->sh_info = 0;
- /* sh_offset is set just below. */
- symstrtab_hdr->sh_addralign = 1;
+ symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
+ /* sh_name was set in prep_headers. */
+ symstrtab_hdr->sh_type = SHT_STRTAB;
+ symstrtab_hdr->sh_flags = 0;
+ symstrtab_hdr->sh_addr = 0;
+ symstrtab_hdr->sh_size = _bfd_stringtab_size (flinfo.symstrtab);
+ symstrtab_hdr->sh_entsize = 0;
+ symstrtab_hdr->sh_link = 0;
+ symstrtab_hdr->sh_info = 0;
+ /* sh_offset is set just below. */
+ symstrtab_hdr->sh_addralign = 1;
- off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr, off, TRUE);
- elf_next_file_pos (abfd) = off;
+ off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr,
+ off, TRUE);
+ elf_next_file_pos (abfd) = off;
- if (bfd_get_symcount (abfd) > 0)
- {
if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
|| ! _bfd_stringtab_emit (abfd, flinfo.symstrtab))
return FALSE;
{
/* The contents of the .dynstr section are actually in a
stringtab. */
+ file_ptr off;
+
off = elf_section_data (o->output_section)->this_hdr.sh_offset;
if (bfd_seek (abfd, off, SEEK_SET) != 0
|| ! _bfd_elf_strtab_emit (abfd,
|| ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
{
h = cookie->sym_hashes[r_symndx - cookie->extsymoff];
+ if (h == NULL)
+ {
+ info->callbacks->einfo (_("%F%P: corrupt input: %B\n"),
+ sec->owner);
+ return NULL;
+ }
while (h->root.type == bfd_link_hash_indirect
|| h->root.type == bfd_link_hash_warning)
h = (struct elf_link_hash_entry *) h->root.u.i.link;
return ret;
}
+/* Scan and mark sections in a special or debug section group. */
+
+static void
+_bfd_elf_gc_mark_debug_special_section_group (asection *grp)
+{
+ /* Point to first section of section group. */
+ asection *ssec;
+ /* Used to iterate the section group. */
+ asection *msec;
+
+ bfd_boolean is_special_grp = TRUE;
+ bfd_boolean is_debug_grp = TRUE;
+
+ /* First scan to see if group contains any section other than debug
+ and special section. */
+ ssec = msec = elf_next_in_group (grp);
+ do
+ {
+ if ((msec->flags & SEC_DEBUGGING) == 0)
+ is_debug_grp = FALSE;
+
+ if ((msec->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) != 0)
+ is_special_grp = FALSE;
+
+ msec = elf_next_in_group (msec);
+ }
+ while (msec != ssec);
+
+ /* If this is a pure debug section group or pure special section group,
+ keep all sections in this group. */
+ if (is_debug_grp || is_special_grp)
+ {
+ do
+ {
+ msec->gc_mark = 1;
+ msec = elf_next_in_group (msec);
+ }
+ while (msec != ssec);
+ }
+}
+
/* Keep debug and special sections. */
bfd_boolean
continue;
/* Keep debug and special sections like .comment when they are
- not part of a group, or when we have single-member groups. */
+ not part of a group. Also keep section groups that contain
+ just debug sections or special sections. */
for (isec = ibfd->sections; isec != NULL; isec = isec->next)
- if ((elf_next_in_group (isec) == NULL
- || elf_next_in_group (isec) == isec)
- && ((isec->flags & SEC_DEBUGGING) != 0
- || (isec->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0))
- isec->gc_mark = 1;
+ {
+ if ((isec->flags & SEC_GROUP) != 0)
+ _bfd_elf_gc_mark_debug_special_section_group (isec);
+ else if (((isec->flags & SEC_DEBUGGING) != 0
+ || (isec->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0)
+ && elf_next_in_group (isec) == NULL)
+ isec->gc_mark = 1;
+ }
if (! debug_frag_seen)
continue;
if (!h->mark
&& (((h->root.type == bfd_link_hash_defined
|| h->root.type == bfd_link_hash_defweak)
- && !(h->def_regular
+ && !((h->def_regular || ELF_COMMON_DEF_P (h))
&& h->root.u.def.section->gc_mark))
|| h->root.type == bfd_link_hash_undefined
|| h->root.type == bfd_link_hash_undefweak))
if ((h->root.type == bfd_link_hash_defined
|| h->root.type == bfd_link_hash_defweak)
&& (h->ref_dynamic
- || (h->def_regular
+ || ((h->def_regular || ELF_COMMON_DEF_P (h))
&& ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
&& ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
&& (!info->executable
win:
if (!child->vtable)
{
- child->vtable = (struct elf_link_virtual_table_entry *)
- bfd_zalloc (abfd, sizeof (*child->vtable));
+ child->vtable = ((struct elf_link_virtual_table_entry *)
+ bfd_zalloc (abfd, sizeof (*child->vtable)));
if (!child->vtable)
return FALSE;
}
if (!h->vtable)
{
- h->vtable = (struct elf_link_virtual_table_entry *)
- bfd_zalloc (abfd, sizeof (*h->vtable));
+ h->vtable = ((struct elf_link_virtual_table_entry *)
+ bfd_zalloc (abfd, sizeof (*h->vtable)));
if (!h->vtable)
return FALSE;
}
string table associated with ABFD. */
asection *
-_bfd_elf_make_dynamic_reloc_section (asection * sec,
- bfd * dynobj,
- unsigned int alignment,
- bfd * abfd,
- bfd_boolean is_rela)
+_bfd_elf_make_dynamic_reloc_section (asection *sec,
+ bfd *dynobj,
+ unsigned int alignment,
+ bfd *abfd,
+ bfd_boolean is_rela)
{
asection * reloc_sec = elf_section_data (sec)->sreloc;