From afd7a018c9e949ee9f1126ae4517567bd9d2dcb1 Mon Sep 17 00:00:00 2001 From: Alan Modra Date: Thu, 14 Oct 2004 12:54:47 +0000 Subject: ld/ PR 63 * ldlang.h (lang_output_section_statement_type): Make "next" a struct lang_output_section_statement_struct *. (struct orphan_save): Move from elf32.em. Add "name" and "flags". (lang_output_section_find_by_flags, lang_insert_orphan): Declare. * ldlang.c (lang_output_section_find_1): Adjust for changed output_section_statement "next". (strip_excluded_output_sections): Likewise. (lang_record_phdrs): Likewise. (lang_output_section_find_by_flags): New function. (output_prev_sec_find): Move from pe.em. Adjust iterator. (lang_insert_orphan): New function. Tail end of elf32.em's place_orphan merged with that from pe.em. Allow bfd_section to be placed first. New heuristic for placing new output section statement in existing script, and accompanying split of __start symbol alignment into a separate assignment to dot. (lang_add_section): Consistently use output->bfd_section rather than an alias, section->output_section. (map_input_to_output_sections): Rename overly long arg. Move initialization of data_statement output section to here.. (lang_check_section_addresses): ..from here. (print_assignment): Correct printing of etree_assert. (print_all_symbols): Don't bomb if userdata is NULL. (IGNORE_SECTION): Rearrange. * emultempl/elf32.em (output_rel_find): Adjust interator. (output_prev_sec_find): Delete. (struct orphan_save): Delete. (gld${EMULATION_NAME}_place_orphan): Cater for zero bfd_section flags without creating a duplicate output section statement. Revise code holding history of various orphan section placements. Allow orphan sections to place before script specified output sections. Call lang_output_section_find_by_flags when placement by name fails. Use lang_insert_orphan. * emultempl/mmo.em (output_prev_sec_find): Delete. (struct orphan_save): Delete. (mmo_place_orphan): Revise code holding history of orphan placement. Allow orphans to place before existing output sections. Use lang_insert_orphan. * emultempl/pe.em (output_prev_sec_find): Delete. (struct orphan_save): Delete. (gld_${EMULATION_NAME}_place_orphan): Revise to suit use of lang_insert_orphan. ld/testsuite/ * ld-scripts/overlay-size.d: Update for changed orphan section placement. * ld-mmix/bpo-18.d: Likewise. --- ld/ldlang.c | 571 ++++++++++++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 480 insertions(+), 91 deletions(-) (limited to 'ld/ldlang.c') diff --git a/ld/ldlang.c b/ld/ldlang.c index e520625..fee5950 100644 --- a/ld/ldlang.c +++ b/ld/ldlang.c @@ -612,13 +612,12 @@ lang_memory_default (asection *section) static lang_output_section_statement_type * lang_output_section_find_1 (const char *const name, int constraint) { - lang_statement_union_type *u; lang_output_section_statement_type *lookup; - for (u = lang_output_section_statement.head; u != NULL; u = lookup->next) + for (lookup = &lang_output_section_statement.head->output_section_statement; + lookup != NULL; + lookup = lookup->next) { - lookup = &u->output_section_statement; - if (strcmp (name, lookup->name) == 0 && lookup->constraint != -1 && (constraint == 0 || constraint == lookup->constraint)) @@ -666,7 +665,7 @@ lang_output_section_statement_lookup_1 (const char *const name, int constraint) lang_statement_append (&lang_output_section_statement, (lang_statement_union_type *) lookup, - &lookup->next); + (lang_statement_union_type **) &lookup->next); } return lookup; } @@ -677,6 +676,389 @@ lang_output_section_statement_lookup (const char *const name) return lang_output_section_statement_lookup_1 (name, 0); } +/* A variant of lang_output_section_find used by place_orphan. + Returns the output statement that should precede a new output + statement for SEC. If an exact match is found on certain flags, + sets *EXACT too. */ + +lang_output_section_statement_type * +lang_output_section_find_by_flags (const asection *sec, + lang_output_section_statement_type **exact) +{ + lang_output_section_statement_type *first, *look, *found; + flagword flags; + + /* We know the first statement on this list is *ABS*. May as well + skip it. */ + first = &lang_output_section_statement.head->output_section_statement; + first = first->next; + + /* First try for an exact match. */ + found = NULL; + for (look = first; look; look = look->next) + { + flags = look->flags; + if (look->bfd_section != NULL) + flags = look->bfd_section->flags; + flags ^= sec->flags; + if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY + | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL))) + found = look; + } + if (found != NULL) + { + *exact = found; + return found; + } + + if (sec->flags & SEC_CODE) + { + /* Try for a rw code section. */ + for (look = first; look; look = look->next) + { + flags = look->flags; + if (look->bfd_section != NULL) + flags = look->bfd_section->flags; + flags ^= sec->flags; + if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD + | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL))) + found = look; + } + return found; + } + + if (sec->flags & (SEC_READONLY | SEC_THREAD_LOCAL)) + { + /* .rodata can go after .text, .sdata2 after .rodata. */ + for (look = first; look; look = look->next) + { + flags = look->flags; + if (look->bfd_section != NULL) + flags = look->bfd_section->flags; + flags ^= sec->flags; + if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD + | SEC_READONLY)) + && !(look->flags & (SEC_SMALL_DATA | SEC_THREAD_LOCAL))) + found = look; + } + return found; + } + + if (sec->flags & SEC_SMALL_DATA) + { + /* .sdata goes after .data, .sbss after .sdata. */ + for (look = first; look; look = look->next) + { + flags = look->flags; + if (look->bfd_section != NULL) + flags = look->bfd_section->flags; + flags ^= sec->flags; + if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD + | SEC_THREAD_LOCAL)) + || ((look->flags & SEC_SMALL_DATA) + && !(sec->flags & SEC_HAS_CONTENTS))) + found = look; + } + return found; + } + + if (sec->flags & SEC_HAS_CONTENTS) + { + /* .data goes after .rodata. */ + for (look = first; look; look = look->next) + { + flags = look->flags; + if (look->bfd_section != NULL) + flags = look->bfd_section->flags; + flags ^= sec->flags; + if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD + | SEC_SMALL_DATA | SEC_THREAD_LOCAL))) + found = look; + } + return found; + } + + /* .bss goes last. */ + for (look = first; look; look = look->next) + { + flags = look->flags; + if (look->bfd_section != NULL) + flags = look->bfd_section->flags; + flags ^= sec->flags; + if (!(flags & SEC_ALLOC)) + found = look; + } + + return found; +} + +/* Find the last output section before given output statement. + Used by place_orphan. */ + +static asection * +output_prev_sec_find (lang_output_section_statement_type *os) +{ + asection *s = (asection *) NULL; + lang_output_section_statement_type *lookup; + + for (lookup = &lang_output_section_statement.head->output_section_statement; + lookup != NULL; + lookup = lookup->next) + { + if (lookup->constraint == -1) + continue; + if (lookup == os) + return s; + + if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL) + s = lookup->bfd_section; + } + + return NULL; +} + +lang_output_section_statement_type * +lang_insert_orphan (lang_input_statement_type *file, + asection *s, + const char *secname, + lang_output_section_statement_type *after, + struct orphan_save *place, + etree_type *address, + lang_statement_list_type *add_child) +{ + lang_statement_list_type *old; + lang_statement_list_type add; + const char *ps; + etree_type *load_base; + lang_output_section_statement_type *os; + lang_output_section_statement_type **os_tail; + + /* Start building a list of statements for this section. + First save the current statement pointer. */ + old = stat_ptr; + + /* If we have found an appropriate place for the output section + statements for this orphan, add them to our own private list, + inserting them later into the global statement list. */ + if (after != NULL) + { + stat_ptr = &add; + lang_list_init (stat_ptr); + } + + ps = NULL; + if (config.build_constructors) + { + /* If the name of the section is representable in C, then create + symbols to mark the start and the end of the section. */ + for (ps = secname; *ps != '\0'; ps++) + if (! ISALNUM ((unsigned char) *ps) && *ps != '_') + break; + if (*ps == '\0') + { + char *symname; + etree_type *e_align; + + symname = (char *) xmalloc (ps - secname + sizeof "__start_" + 1); + symname[0] = bfd_get_symbol_leading_char (output_bfd); + sprintf (symname + (symname[0] != 0), "__start_%s", secname); + e_align = exp_unop (ALIGN_K, + exp_intop ((bfd_vma) 1 << s->alignment_power)); + lang_add_assignment (exp_assop ('=', ".", e_align)); + lang_add_assignment (exp_assop ('=', symname, + exp_nameop (NAME, "."))); + } + } + + if (link_info.relocatable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0) + address = exp_intop (0); + + load_base = NULL; + if (after != NULL && after->load_base != NULL) + { + etree_type *lma_from_vma; + lma_from_vma = exp_binop ('-', after->load_base, + exp_nameop (ADDR, after->name)); + load_base = exp_binop ('+', lma_from_vma, + exp_nameop (ADDR, secname)); + } + + os_tail = ((lang_output_section_statement_type **) + lang_output_section_statement.tail); + os = lang_enter_output_section_statement (secname, address, 0, NULL, NULL, + load_base, 0); + + if (add_child == NULL) + add_child = &os->children; + lang_add_section (add_child, s, os, file); + + lang_leave_output_section_statement (0, "*default*", NULL, NULL); + + if (config.build_constructors && *ps == '\0') + { + char *symname; + + /* lang_leave_ouput_section_statement resets stat_ptr. + Put stat_ptr back where we want it. */ + if (after != NULL) + stat_ptr = &add; + + symname = (char *) xmalloc (ps - secname + sizeof "__stop_" + 1); + symname[0] = bfd_get_symbol_leading_char (output_bfd); + sprintf (symname + (symname[0] != 0), "__stop_%s", secname); + lang_add_assignment (exp_assop ('=', symname, + exp_nameop (NAME, "."))); + } + + /* Restore the global list pointer. */ + if (after != NULL) + stat_ptr = old; + + if (after != NULL && os->bfd_section != NULL) + { + asection *snew, **pps; + + snew = os->bfd_section; + + /* Shuffle the bfd section list to make the output file look + neater. This is really only cosmetic. */ + if (place->section == NULL + && after != (&lang_output_section_statement.head + ->output_section_statement)) + { + asection *bfd_section = after->bfd_section; + + /* If the output statement hasn't been used to place any input + sections (and thus doesn't have an output bfd_section), + look for the closest prior output statement having an + output section. */ + if (bfd_section == NULL) + bfd_section = output_prev_sec_find (after); + + if (bfd_section != NULL && bfd_section != snew) + place->section = &bfd_section->next; + } + + if (place->section == NULL) + place->section = &output_bfd->sections; + + /* Unlink the section. */ + for (pps = &output_bfd->sections; *pps != snew; pps = &(*pps)->next) + continue; + bfd_section_list_remove (output_bfd, pps); + + /* Now tack it back on in the right place. */ + bfd_section_list_insert (output_bfd, place->section, snew); + + /* Save the end of this list. Further ophans of this type will + follow the one we've just added. */ + place->section = &snew->next; + + /* The following is non-cosmetic. We try to put the output + statements in some sort of reasonable order here, because they + determine the final load addresses of the orphan sections. + In addition, placing output statements in the wrong order may + require extra segments. For instance, given a typical + situation of all read-only sections placed in one segment and + following that a segment containing all the read-write + sections, we wouldn't want to place an orphan read/write + section before or amongst the read-only ones. */ + if (add.head != NULL) + { + lang_output_section_statement_type *newly_added_os; + + if (place->stmt == NULL) + { + lang_statement_union_type **where; + lang_statement_union_type **assign = NULL; + + /* Look for a suitable place for the new statement list. + The idea is to skip over anything that might be inside + a SECTIONS {} statement in a script, before we find + another output_section_statement. Assignments to "dot" + before an output section statement are assumed to + belong to it. */ + for (where = &after->header.next; + *where != NULL; + where = &(*where)->header.next) + { + switch ((*where)->header.type) + { + case lang_assignment_statement_enum: + if (assign == NULL) + { + lang_assignment_statement_type *ass; + ass = &(*where)->assignment_statement; + if (ass->exp->type.node_class != etree_assert + && ass->exp->assign.dst[0] == '.' + && ass->exp->assign.dst[1] == 0) + assign = where; + } + continue; + case lang_wild_statement_enum: + case lang_input_section_enum: + case lang_object_symbols_statement_enum: + case lang_fill_statement_enum: + case lang_data_statement_enum: + case lang_reloc_statement_enum: + case lang_padding_statement_enum: + case lang_constructors_statement_enum: + assign = NULL; + continue; + case lang_output_section_statement_enum: + if (assign != NULL) + where = assign; + case lang_input_statement_enum: + case lang_address_statement_enum: + case lang_target_statement_enum: + case lang_output_statement_enum: + case lang_group_statement_enum: + case lang_afile_asection_pair_statement_enum: + break; + } + break; + } + + *add.tail = *where; + *where = add.head; + + place->os_tail = &after->next; + } + else + { + /* Put it after the last orphan statement we added. */ + *add.tail = *place->stmt; + *place->stmt = add.head; + } + + /* Fix the global list pointer if we happened to tack our + new list at the tail. */ + if (*old->tail == add.head) + old->tail = add.tail; + + /* Save the end of this list. */ + place->stmt = add.tail; + + /* Do the same for the list of output section statements. */ + newly_added_os = *os_tail; + *os_tail = NULL; + newly_added_os->next = *place->os_tail; + *place->os_tail = newly_added_os; + place->os_tail = &newly_added_os->next; + + /* Fixing the global list pointer here is a little different. + We added to the list in lang_enter_output_section_statement, + trimmed off the new output_section_statment above when + assigning *os_tail = NULL, but possibly added it back in + the same place when assigning *place->os_tail. */ + if (*os_tail == NULL) + lang_output_section_statement.tail + = (lang_statement_union_type **) os_tail; + } + } + return os; +} + static void lang_map_flags (flagword flag) { @@ -792,7 +1174,7 @@ sort_def_symbol (hash_entry, info) } else if (!ud->map_symbol_def_tail) ud->map_symbol_def_tail = &ud->map_symbol_def_head; - + def = obstack_alloc (&map_obstack, sizeof *def); def->entry = hash_entry; *(ud->map_symbol_def_tail) = def; @@ -867,7 +1249,7 @@ exp_init_os (etree_type *exp) case etree_assert: exp_init_os (exp->assert_s.child); break; - + case etree_unary: exp_init_os (exp->unary.child); break; @@ -991,32 +1373,32 @@ lang_add_section (lang_statement_list_type *ptr, flags &= ~ (SEC_LINK_ONCE | SEC_LINK_DUPLICATES); /* If this is not the first input section, and the SEC_READONLY - flag is not currently set, then don't set it just because the - input section has it set. */ + flag is not currently set, then don't set it just because the + input section has it set. */ - if (! first && (section->output_section->flags & SEC_READONLY) == 0) + if (! first && (output->bfd_section->flags & SEC_READONLY) == 0) flags &= ~ SEC_READONLY; /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */ if (! first - && ((section->output_section->flags & (SEC_MERGE | SEC_STRINGS)) + && ((output->bfd_section->flags & (SEC_MERGE | SEC_STRINGS)) != (flags & (SEC_MERGE | SEC_STRINGS)) || ((flags & SEC_MERGE) - && section->output_section->entsize != section->entsize))) + && output->bfd_section->entsize != section->entsize))) { - section->output_section->flags &= ~ (SEC_MERGE | SEC_STRINGS); + output->bfd_section->flags &= ~ (SEC_MERGE | SEC_STRINGS); flags &= ~ (SEC_MERGE | SEC_STRINGS); } - section->output_section->flags |= flags; + output->bfd_section->flags |= flags; if (flags & SEC_MERGE) - section->output_section->entsize = section->entsize; + output->bfd_section->entsize = section->entsize; /* If SEC_READONLY is not set in the input section, then clear - it from the output section. */ + it from the output section. */ if ((section->flags & SEC_READONLY) == 0) - section->output_section->flags &= ~SEC_READONLY; + output->bfd_section->flags &= ~SEC_READONLY; switch (output->sectype) { @@ -1036,7 +1418,7 @@ lang_add_section (lang_statement_list_type *ptr, /* Copy over SEC_SMALL_DATA. */ if (section->flags & SEC_SMALL_DATA) - section->output_section->flags |= SEC_SMALL_DATA; + output->bfd_section->flags |= SEC_SMALL_DATA; if (section->alignment_power > output->bfd_section->alignment_power) output->bfd_section->alignment_power = section->alignment_power; @@ -1047,7 +1429,7 @@ lang_add_section (lang_statement_list_type *ptr, if (section->flags & SEC_BLOCK) { - section->output_section->flags |= SEC_BLOCK; + output->bfd_section->flags |= SEC_BLOCK; /* FIXME: This value should really be obtained from the bfd... */ output->block_value = 128; } @@ -1122,7 +1504,7 @@ wild_sort (lang_wild_statement_type *wild, ls = &l->input_section; /* Sorting by filename takes precedence over sorting by section - name. */ + name. */ if (wild->filenames_sorted) { @@ -1131,9 +1513,9 @@ wild_sort (lang_wild_statement_type *wild, int i; /* The PE support for the .idata section as generated by - dlltool assumes that files will be sorted by the name of - the archive and then the name of the file within the - archive. */ + dlltool assumes that files will be sorted by the name of + the archive and then the name of the file within the + archive. */ if (file->the_bfd != NULL && bfd_my_archive (file->the_bfd) != NULL) @@ -1181,7 +1563,7 @@ wild_sort (lang_wild_statement_type *wild, } /* Here either the files are not sorted by name, or we are - looking at the sections for this file. */ + looking at the sections for this file. */ if (sec != NULL && sec->spec.sorted != none) { @@ -1832,8 +2214,8 @@ open_input_bfds (lang_statement_union_type *s, bfd_boolean force) s->input_statement.target = current_target; /* If we are being called from within a group, and this - is an archive which has already been searched, then - force it to be researched unless the whole archive + is an archive which has already been searched, then + force it to be researched unless the whole archive has been loaded already. */ if (force && !s->input_statement.whole_archive @@ -2125,19 +2507,19 @@ update_wild_statements (lang_statement_union_type *s) static void map_input_to_output_sections (lang_statement_union_type *s, const char *target, - lang_output_section_statement_type *output_section_statement) + lang_output_section_statement_type *os) { for (; s != NULL; s = s->header.next) { switch (s->header.type) { case lang_wild_statement_enum: - wild (&s->wild_statement, target, output_section_statement); + wild (&s->wild_statement, target, os); break; case lang_constructors_statement_enum: map_input_to_output_sections (constructor_list.head, target, - output_section_statement); + os); break; case lang_output_section_statement_enum: if (s->output_section_statement.constraint) @@ -2169,27 +2551,32 @@ map_input_to_output_sections case lang_group_statement_enum: map_input_to_output_sections (s->group_statement.children.head, target, - output_section_statement); + os); break; case lang_data_statement_enum: /* Make sure that any sections mentioned in the expression are initialized. */ exp_init_os (s->data_statement.exp); - /* FALLTHROUGH */ + if (os != NULL && os->bfd_section == NULL) + init_os (os); + /* The output section gets contents, and then we inspect for + any flags set in the input script which override any ALLOC. */ + os->bfd_section->flags |= SEC_HAS_CONTENTS; + if (!(os->flags & SEC_NEVER_LOAD)) + os->bfd_section->flags |= SEC_ALLOC | SEC_LOAD; + break; case lang_fill_statement_enum: case lang_input_section_enum: case lang_object_symbols_statement_enum: case lang_reloc_statement_enum: case lang_padding_statement_enum: case lang_input_statement_enum: - if (output_section_statement != NULL - && output_section_statement->bfd_section == NULL) - init_os (output_section_statement); + if (os != NULL && os->bfd_section == NULL) + init_os (os); break; case lang_assignment_statement_enum: - if (output_section_statement != NULL - && output_section_statement->bfd_section == NULL) - init_os (output_section_statement); + if (os != NULL && os->bfd_section == NULL) + init_os (os); /* Make sure that any sections mentioned in the assignment are initialized. */ @@ -2201,13 +2588,13 @@ map_input_to_output_sections case lang_address_statement_enum: /* Mark the specified section with the supplied address. */ { - lang_output_section_statement_type *os = - lang_output_section_statement_lookup - (s->address_statement.section_name); + lang_output_section_statement_type *aos + = (lang_output_section_statement_lookup + (s->address_statement.section_name)); - if (os->bfd_section == NULL) - init_os (os); - os->addr_tree = s->address_statement.address; + if (aos->bfd_section == NULL) + init_os (aos); + aos->addr_tree = s->address_statement.address; } break; } @@ -2221,16 +2608,14 @@ map_input_to_output_sections static void strip_excluded_output_sections (void) { - lang_statement_union_type *u; + lang_output_section_statement_type *os; - for (u = lang_output_section_statement.head; - u != NULL; - u = u->output_section_statement.next) + for (os = &lang_output_section_statement.head->output_section_statement; + os != NULL; + os = os->next) { - lang_output_section_statement_type *os; asection *s; - os = &u->output_section_statement; if (os->constraint == -1) continue; s = os->bfd_section; @@ -2302,23 +2687,35 @@ print_assignment (lang_assignment_statement_type *assignment, lang_output_section_statement_type *output_section) { int i; + int is_dot; + etree_type *tree; etree_value_type result; for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++) print_space (); - result = exp_fold_tree (assignment->exp->assign.src, output_section, - lang_final_phase_enum, print_dot, &print_dot); + if (assignment->exp->type.node_class == etree_assert) + { + is_dot = 0; + tree = assignment->exp->assert_s.child; + } + else + { + const char *dst = assignment->exp->assign.dst; + is_dot = dst[0] == '.' && dst[1] == 0; + tree = assignment->exp->assign.src; + } + + result = exp_fold_tree (tree, output_section, lang_final_phase_enum, + print_dot, &print_dot); if (result.valid_p) { - const char *dst; bfd_vma value; value = result.value + result.section->bfd_section->vma; - dst = assignment->exp->assign.dst; minfo ("0x%V", value); - if (dst[0] == '.' && dst[1] == 0) + if (is_dot) print_dot = value; } else @@ -2330,9 +2727,7 @@ print_assignment (lang_assignment_statement_type *assignment, } minfo (" "); - exp_print_tree (assignment->exp); - print_nl (); } @@ -2379,6 +2774,9 @@ print_all_symbols (sec) struct fat_user_section_struct *ud = get_userdata (sec); struct map_symbol_def *def; + if (!ud) + return; + *ud->map_symbol_def_tail = 0; for (def = ud->map_symbol_def_head; def; def = def->next) print_one_symbol (def->entry, sec); @@ -2863,14 +3261,15 @@ size_input_section } #define IGNORE_SECTION(s) \ - (((s->flags & SEC_THREAD_LOCAL) != 0 \ - ? (s->flags & (SEC_LOAD | SEC_NEVER_LOAD)) != SEC_LOAD \ - : (s->flags & (SEC_ALLOC | SEC_NEVER_LOAD)) != SEC_ALLOC) \ + ((s->flags & SEC_NEVER_LOAD) != 0 \ + || (s->flags & SEC_ALLOC) == 0 \ + || ((s->flags & SEC_THREAD_LOCAL) != 0 \ + && (s->flags & SEC_LOAD) == 0) \ || s->size == 0) /* Check to see if any allocated sections overlap with other allocated - sections. This can happen when the linker script specifically specifies - the output section addresses of the two sections. */ + sections. This can happen if a linker script specifies the output + section addresses of the two sections. */ static void lang_check_section_addresses (void) @@ -3090,7 +3489,7 @@ lang_size_sections_1 lang_allocating_phase_enum, dot, &dot); os->processed = 0; - + if (!r.valid_p) einfo (_("%F%S: non constant or forward reference" " address expression for section %s\n"), @@ -3220,14 +3619,6 @@ lang_size_sections_1 size = TO_SIZE ((unsigned) 1); dot += TO_ADDR (size); output_section_statement->bfd_section->size += size; - /* The output section gets contents, and then we inspect for - any flags set in the input script which override any ALLOC. */ - output_section_statement->bfd_section->flags |= SEC_HAS_CONTENTS; - if (!(output_section_statement->flags & SEC_NEVER_LOAD)) - { - output_section_statement->bfd_section->flags |= - SEC_ALLOC | SEC_LOAD; - } } break; @@ -3714,7 +4105,7 @@ lang_finish (void) const char *send; /* We couldn't find the entry symbol. Try parsing it as a - number. */ + number. */ val = bfd_scan_vma (entry_symbol.name, &send, 0); if (*send == '\0') { @@ -3815,10 +4206,10 @@ lang_check (void) bfd_error_handler_type pfn = NULL; /* If we aren't supposed to warn about mismatched input - files, temporarily set the BFD error handler to a - function which will do nothing. We still want to call - bfd_merge_private_bfd_data, since it may set up - information which is needed in the output file. */ + files, temporarily set the BFD error handler to a + function which will do nothing. We still want to call + bfd_merge_private_bfd_data, since it may set up + information which is needed in the output file. */ if (! command_line.warn_mismatch) pfn = bfd_set_error_handler (ignore_bfd_errors); if (! bfd_merge_private_bfd_data (input_bfd, output_bfd)) @@ -3965,7 +4356,7 @@ lang_place_orphans (void) if (s->output_section == NULL) { /* This section of the file is not attached, root - around for a sensible place for it to go. */ + around for a sensible place for it to go. */ if (file->just_syms_flag) abort (); @@ -3984,8 +4375,8 @@ lang_place_orphans (void) { #if 0 /* This message happens when using the - svr3.ifile linker script, so I have - disabled it. */ + svr3.ifile linker script, so I have + disabled it. */ info_msg (_("%P: no [COMMON] command," " defaulting to .bss\n")); #endif @@ -4855,7 +5246,7 @@ lang_record_phdrs (void) asection **secs; lang_output_section_phdr_list *last; struct lang_phdr *l; - lang_statement_union_type *u; + lang_output_section_statement_type *os; alc = 10; secs = xmalloc (alc * sizeof (asection *)); @@ -4867,14 +5258,12 @@ lang_record_phdrs (void) bfd_vma at; c = 0; - for (u = lang_output_section_statement.head; - u != NULL; - u = u->output_section_statement.next) + for (os = &lang_output_section_statement.head->output_section_statement; + os != NULL; + os = os->next) { - lang_output_section_statement_type *os; lang_output_section_phdr_list *pl; - os = &u->output_section_statement; if (os->constraint == -1) continue; @@ -4930,22 +5319,22 @@ lang_record_phdrs (void) free (secs); /* Make sure all the phdr assignments succeeded. */ - for (u = lang_output_section_statement.head; - u != NULL; - u = u->output_section_statement.next) + for (os = &lang_output_section_statement.head->output_section_statement; + os != NULL; + os = os->next) { lang_output_section_phdr_list *pl; - if (u->output_section_statement.constraint == -1 - || u->output_section_statement.bfd_section == NULL) + if (os->constraint == -1 + || os->bfd_section == NULL) continue; - for (pl = u->output_section_statement.phdrs; + for (pl = os->phdrs; pl != NULL; pl = pl->next) if (! pl->used && strcmp (pl->name, "NONE") != 0) einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"), - u->output_section_statement.name, pl->name); + os->name, pl->name); } } -- cgit v1.1