From 99837adc0e45b58e22e106e70df255e768041be4 Mon Sep 17 00:00:00 2001 From: Christophe Lyon Date: Mon, 25 Nov 2019 08:55:37 +0000 Subject: [PATCH 1/4] Add support for non-contiguous memory regions 2020-01-06 Christophe Lyon bfd/ * bfd-in2.h: Regenerate. * section.c (asection): Add already_assigned field. (BFD_FAKE_SECTION): Add default initializer for it. * ecoff.c (bfd_debug_section): Initialize already_assigned field. * elf32-arm.c (arm_build_one_stub): Add support for non_contiguous_regions. * emultempl/armelf.em (elf32_arm_add_stub_section): Add SEC_LINKER_CREATED flag. include/ * bfdlink.h (bfd_link_info): Add non_contiguous_regions field. ld/ * ldlang.c (lang_add_section): Add support for non_contiguous_regions. (size_input_section): Likewise. (lang_size_sections_1): Likewise. * ldlex.h (option_values): Add OPTION_NON_CONTIGUOUS_REGIONS. * lexsup.c (ld_options): Add entry for --enable-non-contiguous-regions. (parse_args): Handle it. * (NEWS): Add --enable-non-contiguous-regions. * ld.texi: Add --enable-non-contiguous-regions documentation. Change-Id: Iac2f395b3a1fbea4b3a732ba5a9b847e10b4b2f0 --- bfd/bfd-in2.h | 9 +++- bfd/ecoff.c | 6 ++- bfd/elf32-arm.c | 11 +++++ bfd/section.c | 9 +++- include/bfdlink.h | 3 ++ ld/NEWS | 1 + ld/emultempl/armelf.em | 3 +- ld/ld.texi | 32 ++++++++++++++ ld/ldlang.c | 116 +++++++++++++++++++++++++++++++++++++++++++++++-- ld/ldlex.h | 1 + ld/lexsup.c | 5 +++ 11 files changed, 187 insertions(+), 9 deletions(-) diff --git a/bfd/bfd-in2.h b/bfd/bfd-in2.h index a00dfa35..0e1126c 100644 --- a/bfd/bfd-in2.h +++ b/bfd/bfd-in2.h @@ -1177,6 +1177,10 @@ typedef struct bfd_section struct bfd_link_order *link_order; struct bfd_section *s; } map_head, map_tail; + /* Points to the output section this section is already assigned to, if any. + This is used when support for non-contiguous memory regions is enabled. */ + struct bfd_section *already_assigned; + } asection; /* Relax table contains information about instructions which can @@ -1358,7 +1362,10 @@ discarded_section (const asection *sec) (struct bfd_symbol *) SYM, &SEC.symbol, \ \ /* map_head, map_tail */ \ - { NULL }, { NULL } \ + { NULL }, { NULL }, \ + \ + /* already_assigned */ \ + NULL \ } /* We use a macro to initialize the static asymbol structures because diff --git a/bfd/ecoff.c b/bfd/ecoff.c index be3d42e..adbf9ca 100644 --- a/bfd/ecoff.c +++ b/bfd/ecoff.c @@ -76,8 +76,10 @@ static asection bfd_debug_section = NULL, /* symbol_ptr_ptr, */ NULL, - /* map_head, map_tail */ - { NULL }, { NULL } + /* map_head, map_tail, */ + { NULL }, { NULL }, + /* already_assigned */ + NULL, }; /* Create an ECOFF object. */ diff --git a/bfd/elf32-arm.c b/bfd/elf32-arm.c index dca208f..7b6b7a6 100644 --- a/bfd/elf32-arm.c +++ b/bfd/elf32-arm.c @@ -5085,6 +5085,17 @@ arm_build_one_stub (struct bfd_hash_entry *gen_entry, stub_bfd = stub_sec->owner; + /* Fail if the target section could not be assigned to an output + section. The user should fix his linker script. */ + if (stub_entry->target_section->output_section == NULL + && info->non_contiguous_regions) + { + _bfd_error_handler (_("No output section assigned to %pA. " + "Retry without --enable-non-contiguous-regions.\n"), + stub_entry->target_section); + abort(); + } + /* This is the address of the stub destination. */ sym_value = (stub_entry->target_value + stub_entry->target_section->output_offset diff --git a/bfd/section.c b/bfd/section.c index 34e08ae..b1f0b71 100644 --- a/bfd/section.c +++ b/bfd/section.c @@ -536,6 +536,10 @@ CODE_FRAGMENT . struct bfd_link_order *link_order; . struct bfd_section *s; . } map_head, map_tail; +. {* Points to the output section this section is already assigned to, if any. +. This is used when support for non-contiguous memory regions is enabled. *} +. struct bfd_section *already_assigned; +. .} asection; . .{* Relax table contains information about instructions which can @@ -717,7 +721,10 @@ CODE_FRAGMENT . (struct bfd_symbol *) SYM, &SEC.symbol, \ . \ . {* map_head, map_tail *} \ -. { NULL }, { NULL } \ +. { NULL }, { NULL }, \ +. \ +. {* already_assigned *} \ +. NULL \ . } . .{* We use a macro to initialize the static asymbol structures because diff --git a/include/bfdlink.h b/include/bfdlink.h index 32d1512..e1e7c1e 100644 --- a/include/bfdlink.h +++ b/include/bfdlink.h @@ -501,6 +501,9 @@ struct bfd_link_info /* TRUE if "-Map map" is passed to linker. */ unsigned int has_map_file : 1; + /* TRUE if "--enable-non-contiguous-regions" is passed to the linker. */ + unsigned int non_contiguous_regions : 1; + /* Char that may appear as the first char of a symbol, but should be skipped (like symbol_leading_char) when looking up symbols in wrap_hash. Used by PowerPC Linux for 'dot' symbols. */ diff --git a/ld/NEWS b/ld/NEWS index bc21c39..97194f6 100644 --- a/ld/NEWS +++ b/ld/NEWS @@ -1,5 +1,6 @@ -*- text -*- +* Add command-line option --enable-non-contiguous-regions. * cr16c support removed. Changes in 2.33: diff --git a/ld/emultempl/armelf.em b/ld/emultempl/armelf.em index 9a1bc9a..445977b 100644 --- a/ld/emultempl/armelf.em +++ b/ld/emultempl/armelf.em @@ -227,7 +227,8 @@ elf32_arm_add_stub_section (const char * stub_sec_name, struct hook_stub_info info; flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE - | SEC_HAS_CONTENTS | SEC_RELOC | SEC_IN_MEMORY | SEC_KEEP); + | SEC_HAS_CONTENTS | SEC_RELOC | SEC_IN_MEMORY | SEC_KEEP + | SEC_LINKER_CREATED); stub_sec = bfd_make_section_anyway_with_flags (stub_file->the_bfd, stub_sec_name, flags); if (stub_sec == NULL) diff --git a/ld/ld.texi b/ld/ld.texi index ed538fb..78977f9 100644 --- a/ld/ld.texi +++ b/ld/ld.texi @@ -459,6 +459,38 @@ will contain a colon separated list of audit interfaces to use. This option is only meaningful on ELF platforms supporting the rtld-audit interface. The -P option is provided for Solaris compatibility. +@kindex --enable-non-contiguous-regions +@item --enable-non-contiguous-regions +This option avoids generating an error if an input section does not +fit a matching output section. The linker tries to allocate the input +section to subseque nt matching output sections, and generates an +error only if no output section is large enough. This is useful when +several non-contiguous memory regions are available and the input +section does not require a particular one. The order in which input +sections are evaluated does not change, for instance: + +@smallexample + MEMORY @{ + MEM1 (rwx) : ORIGIN : 0x1000, LENGTH = 0x14 + MEM2 (rwx) : ORIGIN : 0x1000, LENGTH = 0x40 + MEM3 (rwx) : ORIGIN : 0x2000, LENGTH = 0x40 + @} + SECTIONS @{ + mem1 : @{ *(.data.*); @} > MEM1 + mem2 : @{ *(.data.*); @} > MEM2 + mem3 : @{ *(.data.*); @} > MEM2 + @} + + with input sections: + .data.1: size 8 + .data.2: size 0x10 + .data.3: size 4 + + results in .data.1 affected to mem1, and .data.2 and .data.3 + affected to mem2, even though .data.3 would fit in mem3. +@end smallexample + + @cindex entry point, from command line @kindex -e @var{entry} @kindex --entry=@var{entry} diff --git a/ld/ldlang.c b/ld/ldlang.c index eedcb7f..75dc5b1 100644 --- a/ld/ldlang.c +++ b/ld/ldlang.c @@ -2550,7 +2550,14 @@ lang_add_section (lang_statement_list_type *ptr, } if (section->output_section != NULL) - return; + { + if (!link_info.non_contiguous_regions) + return; + /* SECTION has already been affected to an output section, but + the user allows it to be mapped to another one in case it + overflows. We'll later update the actual output section in + size_input_section as appropriate. */ + } /* We don't copy the SEC_NEVER_LOAD flag from an input section to an output section, because we want to be able to include a @@ -5109,11 +5116,27 @@ size_input_section (lang_statement_union_type **this_ptr, lang_output_section_statement_type *output_section_statement, fill_type *fill, + bfd_boolean *removed, bfd_vma dot) { lang_input_section_type *is = &((*this_ptr)->input_section); asection *i = is->section; asection *o = output_section_statement->bfd_section; + *removed = 0; + + if (link_info.non_contiguous_regions) + { + /* If the input section I has already been successfully assigned + to an output section other than O, don't bother with it and + let the caller remove it from the list. Keep processing in + case we have already handled O, because the repeated passes + have reinitialized its size. */ + if (i->already_assigned && i->already_assigned != o) + { + *removed = 1; + return dot; + } + } if (i->sec_info_type == SEC_INFO_TYPE_JUST_SYMS) i->output_offset = i->vma - o->vma; @@ -5145,6 +5168,43 @@ size_input_section dot += alignment_needed; } + if (link_info.non_contiguous_regions) + { + /* If I would overflow O, let the caller remove I from the + list. */ + if (output_section_statement->region) + { + bfd_vma end = output_section_statement->region->origin + + output_section_statement->region->length; + + if (dot + TO_ADDR (i->size) > end) + { + if (i->flags & SEC_LINKER_CREATED) + { + einfo (_("Output section %s not large enough for the " + "linker-created stubs section %s.\n"), + i->output_section->name, i->name); + abort(); + } + + if (i->rawsize && i->rawsize != i->size) + { + einfo (_("Relaxation not supported with " + "--enable-non-contiguous-regions (section %s " + "would overflow %s after it changed size).\n"), + i->name, i->output_section->name); + abort(); + } + + *removed = 1; + dot = end; + ASSERT (i->already_assigned == NULL); + i->output_section = NULL; + return dot; + } + } + } + /* Remember where in the output section this input section goes. */ i->output_offset = dot - o->vma; @@ -5152,6 +5212,14 @@ size_input_section dot += TO_ADDR (i->size); if (!(o->flags & SEC_FIXED_SIZE)) o->size = TO_SIZE (dot - o->vma); + + if (link_info.non_contiguous_regions) + { + /* Record that I was successfully assigned to O, and update + its actual output section too. */ + i->already_assigned = o; + i->output_section = o; + } } return dot; @@ -5436,10 +5504,14 @@ lang_size_sections_1 bfd_boolean check_regions) { lang_statement_union_type *s; + lang_statement_union_type *prev_s = NULL; + bfd_boolean removed_prev_s = FALSE; /* Size up the sections from their constituent parts. */ - for (s = *prev; s != NULL; s = s->header.next) + for (s = *prev; s != NULL; prev_s = s, s = s->header.next) { + bfd_boolean removed=FALSE; + switch (s->header.type) { case lang_output_section_statement_enum: @@ -5864,7 +5936,7 @@ lang_size_sections_1 *relax = TRUE; } dot = size_input_section (prev, output_section_statement, - fill, dot); + fill, &removed, dot); } break; @@ -5969,7 +6041,43 @@ lang_size_sections_1 FAIL (); break; } - prev = &s->header.next; + + /* If an input section doesn't fit in the current output + section, remove it from the list. Handle the case where we + have to remove an input_section statement here: there is a + special case to remove the first element of the list. */ + if (link_info.non_contiguous_regions && removed) + { + /* If we removed the first element during the previous + iteration, override the loop assignment of prev_s. */ + if (removed_prev_s) + prev_s = NULL; + + if (prev_s) + { + /* If there was a real previous input section, just skip + the current one. */ + prev_s->header.next=s->header.next; + s = prev_s; + removed_prev_s = FALSE; + } + else + { + /* Remove the first input section of the list. */ + *prev = s->header.next; + removed_prev_s = TRUE; + } + + /* Move to next element, unless we removed the head of the + list. */ + if (!removed_prev_s) + prev = &s->header.next; + } + else + { + prev = &s->header.next; + removed_prev_s = FALSE; + } } return dot; } diff --git a/ld/ldlex.h b/ld/ldlex.h index 32a7a64..4e7a419 100644 --- a/ld/ldlex.h +++ b/ld/ldlex.h @@ -150,6 +150,7 @@ enum option_values OPTION_FORCE_GROUP_ALLOCATION, OPTION_PRINT_MAP_DISCARDED, OPTION_NO_PRINT_MAP_DISCARDED, + OPTION_NON_CONTIGUOUS_REGIONS, }; /* The initial parser states. */ diff --git a/ld/lexsup.c b/ld/lexsup.c index d7766c3..13cab6d 100644 --- a/ld/lexsup.c +++ b/ld/lexsup.c @@ -122,6 +122,8 @@ static const struct ld_option ld_options[] = 'E', NULL, N_("Export all dynamic symbols"), TWO_DASHES }, { {"no-export-dynamic", no_argument, NULL, OPTION_NO_EXPORT_DYNAMIC}, '\0', NULL, N_("Undo the effect of --export-dynamic"), TWO_DASHES }, + { {"enable-non-contiguous-regions", no_argument, NULL, OPTION_NON_CONTIGUOUS_REGIONS}, + '\0', NULL, N_("Enable support of non-contiguous memory regions"), TWO_DASHES }, { {"EB", no_argument, NULL, OPTION_EB}, '\0', NULL, N_("Link big-endian objects"), ONE_DASH }, { {"EL", no_argument, NULL, OPTION_EL}, @@ -845,6 +847,9 @@ parse_args (unsigned argc, char **argv) case OPTION_NO_EXPORT_DYNAMIC: link_info.export_dynamic = FALSE; break; + case OPTION_NON_CONTIGUOUS_REGIONS: + link_info.non_contiguous_regions = TRUE; + break; case 'e': lang_add_entry (optarg, TRUE); break; -- 2.7.4