+2017-06-06 Andrew Burgess <andrew.burgess@embecosm.com>
+
+ * elf.c (_bfd_elf_make_section_from_shdr): Don't initially mark
+ SEC_GROUP sections as SEC_EXCLUDE.
+ (bfd_elf_set_group_contents): Replace use of abort with an assert.
+ (assign_section_numbers): Use resolve_section_groups flag instead
+ of relocatable link type.
+ (_bfd_elf_init_private_section_data): Use resolve_section_groups
+ flag instead of checking the final_link flag for part of the
+ checks in here. Fix white space as a result.
+ * elflink.c (elf_link_input_bfd): Use resolve_section_groups flag
+ instead of relocatable link type.
+ (bfd_elf_final_link): Likewise.
+
2017-06-06 Jose E. Marchesi <jose.marchesi@oracle.com>
* elfxx-mips.c (_bfd_mips_elf_relocate_section): Remove unused
if (hdr->sh_type != SHT_NOBITS)
flags |= SEC_HAS_CONTENTS;
if (hdr->sh_type == SHT_GROUP)
- flags |= SEC_GROUP | SEC_EXCLUDE;
+ flags |= SEC_GROUP;
if ((hdr->sh_flags & SHF_ALLOC) != 0)
{
flags |= SEC_ALLOC;
break;
}
- if ((loc -= 4) != sec->contents)
- abort ();
+ loc -= 4;
+ BFD_ASSERT (loc == sec->contents);
H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
}
_bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
/* SHT_GROUP sections are in relocatable files only. */
- if (link_info == NULL || bfd_link_relocatable (link_info))
+ if (link_info == NULL || !link_info->resolve_section_groups)
{
size_t reloc_count = 0;
SHT_GROUP section will have its elf_next_in_group pointing back
to the input group members. Ignore linker created group section.
See elfNN_ia64_object_p in elfxx-ia64.c. */
- if (!final_link)
+ if ((link_info == NULL
+ || !link_info->resolve_section_groups)
+ && (elf_sec_group (isec) == NULL
+ || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0))
{
- if (elf_sec_group (isec) == NULL
- || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0)
- {
- if (elf_section_flags (isec) & SHF_GROUP)
- elf_section_flags (osec) |= SHF_GROUP;
- elf_next_in_group (osec) = elf_next_in_group (isec);
- elf_section_data (osec)->group = elf_section_data (isec)->group;
- }
-
- /* If not decompress, preserve SHF_COMPRESSED. */
- if ((ibfd->flags & BFD_DECOMPRESS) == 0)
- elf_section_flags (osec) |= (elf_section_flags (isec)
- & SHF_COMPRESSED);
+ if (elf_section_flags (isec) & SHF_GROUP)
+ elf_section_flags (osec) |= SHF_GROUP;
+ elf_next_in_group (osec) = elf_next_in_group (isec);
+ elf_section_data (osec)->group = elf_section_data (isec)->group;
}
+ /* If not decompress, preserve SHF_COMPRESSED. */
+ if (!final_link && (ibfd->flags & BFD_DECOMPRESS) == 0)
+ elf_section_flags (osec) |= (elf_section_flags (isec)
+ & SHF_COMPRESSED);
+
ihdr = &elf_section_data (isec)->this_hdr;
/* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
continue;
}
- if (bfd_link_relocatable (flinfo->info)
+ if (!flinfo->info->resolve_section_groups
&& (o->flags & (SEC_LINKER_CREATED | SEC_GROUP)) == SEC_GROUP)
{
/* Deal with the group signature symbol. */
unsigned long symndx = sec_data->this_hdr.sh_info;
asection *osec = o->output_section;
+ BFD_ASSERT (bfd_link_relocatable (flinfo->info));
if (symndx >= locsymcount
|| (elf_bad_symtab (input_bfd)
&& flinfo->sections[symndx] == NULL))
}
}
- if (bfd_link_relocatable (info))
+ if (!info->resolve_section_groups)
{
bfd_boolean failed = FALSE;
+ BFD_ASSERT (bfd_link_relocatable (info));
bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
if (failed)
goto error_return;
+2017-06-06 Andrew Burgess <andrew.burgess@embecosm.com>
+
+ * bfdlink.h (struct bfd_link_info): Add new resolve_section_groups
+ flag.
+
2017-06-01 Alan Modra <amodra@gmail.com>
* elf/ppc64.h (PPC64_OPT_LOCALENTRY): Define.
/* TRUE if all data symbols should be dynamic. */
unsigned int dynamic_data: 1;
+ /* TRUE if section groups should be resolved. */
+ unsigned int resolve_section_groups: 1;
+
/* Which symbols to strip. */
ENUM_BITFIELD (bfd_link_strip) strip : 2;
+2017-06-06 Andrew Burgess <andrew.burgess@embecosm.com>
+
+ * ld.h (struct args_type): Add force_group_allocation field.
+ * ldgram.y: Add support for FORCE_GROUP_ALLOCATION.
+ * ldlex.h: Likewise.
+ * ldlex.l: Likewise.
+ * lexsup.c: Likewise.
+ * ldlang.c (unique_section_p): Check resolve_section_groups flag
+ not the relaxable link flag.
+ (lang_add_section): Discard section groups when we're resolving
+ groups. Clear the SEC_LINK_ONCE flag if we're resolving section
+ groups.
+ * ldmain.c (main): Initialise resolve_section_groups flag in
+ link_info based on command line flags.
+ * testsuite/ld-elf/group11.d: New file.
+ * testsuite/ld-elf/group12.d: New file.
+ * testsuite/ld-elf/group12.ld: New file.
+ * NEWS: Mention new features.
+ * ld.texinfo (Options): Document --force-group-allocation.
+ (Miscellaneous Commands): Document FORCE_GROUP_ALLOCATION.
+
2017-06-05 H.J. Lu <hongjiu.lu@intel.com>
PR ld/21529
* Orphan sections placed after an empty section that has an AT(LMA) will now
take an load memory address starting from LMA.
+* Section groups can now be resolved (the group deleted and the group members
+ placed like normal sections) at partial link time either using the new linker
+ option --force-group-allocation or by placing FORCE_GROUP_ALLOCATION into the
+ linker script.
+
Changes in 2.28:
* The EXCLUDE_FILE linker script construct can now be applied outside of the
/* If set, display the target memory usage (per memory region). */
bfd_boolean print_memory_usage;
+ /* Shold we force section groups to be resolved? Controlled with
+ --force-group-allocation on the command line or FORCE_GROUP_ALLOCATION
+ in the linker script. */
+ bfd_boolean force_group_allocation;
+
/* Big or little endian as set on command line. */
enum endian_enum endian;
duplicate when there are many dynamic modules with specialized search
paths for runtime symbol resolution.
+@cindex group allocation in linker script
+@cindex section groups
+@cindex COMDAT
+@kindex --force-group-allocation
+@item --force-group-allocation
+This option causes the linker to place section group members like
+normal input sections, and to delete the section groups. This is the
+default behaviour for a final link but this option can be used to
+change the behaviour of a relocatable link (@samp{-r}). The script
+command @code{FORCE_GROUP_ALLOCATION} has the same
+effect. @xref{Miscellaneous Commands}.
+
@cindex symbols, from command line
@kindex --defsym=@var{symbol}=@var{exp}
@item --defsym=@var{symbol}=@var{expression}
command-line option: to make @code{ld} omit the assignment of addresses
to common symbols even for a non-relocatable output file.
+@item FORCE_GROUP_ALLOCATION
+@kindex FORCE_GROUP_ALLOCATION
+@cindex group allocation in linker script
+@cindex section groups
+@cindex COMDAT
+This command has the same effect as the
+@samp{--force-group-allocation} command-line option: to make
+@command{ld} place section group members like normal input sections,
+and to delete the section groups even if a relocatable output file is
+specified (@samp{-r}).
+
@item INSERT [ AFTER | BEFORE ] @var{output_section}
@kindex INSERT
@cindex insert user script into default script
%token SORT_BY_INIT_PRIORITY
%token '{' '}'
%token SIZEOF_HEADERS OUTPUT_FORMAT FORCE_COMMON_ALLOCATION OUTPUT_ARCH
-%token INHIBIT_COMMON_ALLOCATION
+%token INHIBIT_COMMON_ALLOCATION FORCE_GROUP_ALLOCATION
%token SEGMENT_START
%token INCLUDE
%token MEMORY
{ ldfile_set_output_arch ($3, bfd_arch_unknown); }
| FORCE_COMMON_ALLOCATION
{ command_line.force_common_definition = TRUE ; }
+ | FORCE_GROUP_ALLOCATION
+ { command_line.force_group_allocation = TRUE ; }
| INHIBIT_COMMON_ALLOCATION
{ command_line.inhibit_common_definition = TRUE ; }
| INPUT '(' input_list ')'
struct unique_sections *unam;
const char *secnam;
- if (bfd_link_relocatable (&link_info)
+ if (!link_info.resolve_section_groups
&& sec->owner != NULL
&& bfd_is_group_section (sec->owner, sec))
return !(os != NULL
if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
discard = TRUE;
+ /* Discard the group descriptor sections when we're finally placing the
+ sections from within the group. */
+ if ((section->flags & SEC_GROUP) == SEC_GROUP
+ && link_info.resolve_section_groups)
+ discard = TRUE;
+
/* Discard debugging sections if we are stripping debugging
information. */
if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
already been processed. One reason to do this is that on pe
format targets, .text$foo sections go into .text and it's odd
to see .text with SEC_LINK_ONCE set. */
-
- if (!bfd_link_relocatable (&link_info))
+ if ((flags & (SEC_LINK_ONCE | SEC_GROUP)) == (SEC_LINK_ONCE | SEC_GROUP))
+ {
+ if (link_info.resolve_section_groups)
+ flags &= ~(SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_RELOC);
+ else
+ flags &= ~(SEC_LINK_DUPLICATES | SEC_RELOC);
+ }
+ else if (!bfd_link_relocatable (&link_info))
flags &= ~(SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_RELOC);
switch (output->sectype)
OPTION_PRINT_MEMORY_USAGE,
OPTION_REQUIRE_DEFINED_SYMBOL,
OPTION_ORPHAN_HANDLING,
+ OPTION_FORCE_GROUP_ALLOCATION,
};
/* The initial parser states. */
<BOTH,SCRIPT>"CREATE_OBJECT_SYMBOLS" { RTOKEN(CREATE_OBJECT_SYMBOLS);}
<BOTH,SCRIPT>"CONSTRUCTORS" { RTOKEN( CONSTRUCTORS);}
<BOTH,SCRIPT>"FORCE_COMMON_ALLOCATION" { RTOKEN(FORCE_COMMON_ALLOCATION);}
+<BOTH,SCRIPT>"FORCE_GROUP_ALLOCATION" { RTOKEN(FORCE_GROUP_ALLOCATION);}
<BOTH,SCRIPT>"INHIBIT_COMMON_ALLOCATION" { RTOKEN(INHIBIT_COMMON_ALLOCATION);}
<BOTH,SCRIPT>"SECTIONS" { RTOKEN(SECTIONS);}
<BOTH,SCRIPT>"INSERT" { RTOKEN(INSERT_K);}
info_msg ("\n==================================================\n");
}
+ if (command_line.force_group_allocation
+ || !bfd_link_relocatable (&link_info))
+ link_info.resolve_section_groups = TRUE;
+ else
+ link_info.resolve_section_groups = FALSE;
+
if (command_line.print_output_format)
info_msg ("%s\n", lang_get_output_target ());
'd', NULL, N_("Force common symbols to be defined"), ONE_DASH },
{ {"dp", no_argument, NULL, 'd'},
'\0', NULL, NULL, ONE_DASH },
+ { {"force-group-allocation", no_argument, NULL,
+ OPTION_FORCE_GROUP_ALLOCATION},
+ '\0', NULL, N_("Force group members out of groups"), TWO_DASHES },
{ {"entry", required_argument, NULL, 'e'},
'e', N_("ADDRESS"), N_("Set start address"), TWO_DASHES },
{ {"export-dynamic", no_argument, NULL, OPTION_EXPORT_DYNAMIC},
case 'd':
command_line.force_common_definition = TRUE;
break;
+ case OPTION_FORCE_GROUP_ALLOCATION:
+ command_line.force_group_allocation = TRUE;
+ break;
case OPTION_DEFSYM:
lex_string = optarg;
lex_redirect (optarg, "--defsym", ++defsym_count);
--- /dev/null
+#source: group1a.s
+#source: group1b.s
+#ld: -r --force-group-allocation
+#readelf: -g
+
+There are no section groups in this file.
--- /dev/null
+#source: group1a.s
+#source: group1b.s
+#ld: -r -T group12.ld
+#readelf: -g
+
+There are no section groups in this file.
--- /dev/null
+FORCE_GROUP_ALLOCATION
+
+PHDRS
+{
+ header PT_PHDR PHDRS ;
+ image PT_LOAD PHDRS;
+}
+
+SECTIONS
+{
+ . = 0x1000;
+ .text : { *(.text) *(.rodata.brlt) } :image :header
+ /DISCARD/ : { *(.dropme) *(.reginfo) *(.MIPS.abiflags) }
+}
projects / deliverable / binutils-gdb.git / commitdiff
