diff -rupN binutils-2.30/ld/ChangeLog binutils-2.30-new/ld/ChangeLog --- binutils-2.30/ld/ChangeLog 2018-01-27 16:08:54.000000000 +0100 +++ binutils-2.30-new/ld/ChangeLog 2018-06-14 16:31:29.314219791 +0200 @@ -1,3 +1,17 @@ +2018-02-05 Nick Clifton <nickc@redhat.com> + + Import from mainline: + + 2018-02-03 Nick Clifton <nickc@redhat.com> + + PR 22762 + * scripttempl/pe.sc: Remove PROVIDE()s from __CTOR_LIST__ and + __DTOR_LIST__ symbols. Add a comment explaining why this is + necessary. + * scripttemp/pep.sc: Likewise. + * ld.texinfo (PROVIDE): Add a note about the effect of common + symbols. + 2018-01-27 Nick Clifton <nickc@redhat.com> This is the 2.30 release: diff -rupN binutils-2.30/ld/ChangeLog.orig binutils-2.30-new/ld/ChangeLog.orig --- binutils-2.30/ld/ChangeLog.orig 2018-01-27 15:04:49.000000000 +0100 +++ binutils-2.30-new/ld/ChangeLog.orig 1970-01-01 01:00:00.000000000 +0100 @@ -1,285 +0,0 @@ -2018-01-25 Eric Botcazou <ebotcazou@adacore.com> - - * testsuite/ld-sparc/sparc.exp (32-bit: Helper shared library): - Link with a version script. - (32-bit: TLS -fpie): New test. - (64-bit: Helper shared library): Link with a version script. - (64-bit: TLS -fpie): New test. - (64-bit: GOTDATA relocations): Pass -Av9 to the assembler. - * testsuite/ld-sparc/tlslib.ver: New file. - * testsuite/ld-sparc/tlspie32.dd: Likewise. - * testsuite/ld-sparc/tlspie32.s: Likewise. - * testsuite/ld-sparc/tlspie64.dd: Likewise. - * testsuite/ld-sparc/tlspie64.s: Likewise. - * testsuite/ld-sparc/tlssunbin32.dd: Adjust for versioned symbol. - * testsuite/ld-sparc/tlssunbin32.rd: Likewise. - * testsuite/ld-sparc/tlssunbin32.sd: Likewise. - * testsuite/ld-sparc/tlssunbin64.dd: Likewise. - * testsuite/ld-sparc/tlssunbin64.rd: Likewise. - * testsuite/ld-sparc/tlssunbin64.sd: Likewise. - -2018-01-23 Nick Clifton <nickc@redhat.com> - - * configure: Regenerate. - -2018-01-20 H.J. Lu <hongjiu.lu@intel.com> - - PR ld/22721 - * testsuite/ld-plugin/lto.exp: Run PR ld/22721 tests. - * testsuite/ld-plugin/pr22721.t: New file. - * testsuite/ld-plugin/pr22721a.s: Likewise. - * testsuite/ld-plugin/pr22721b.c: Likewise. - -2018-01-18 Alan Modra <amodra@gmail.com> - - * emultempl/ppc32elf.em: Support optional --plt-align arg. - * emultempl/ppc64elf.em: Support negative --plt-align arg. - -2018-01-18 Alan Modra <amodra@gmail.com> - - * emultempl/ppc32elf.em (params): Init new field. - (OPTION_SPECULATE_INDIRECT_JUMPS): Define. - (OPTION_NO_SPECULATE_INDIRECT_JUMPS): Define. - (PARSE_AND_LIST_LONGOPTS): Handle new options. - (PARSE_AND_LIST_ARGS_CASES): Likewise. - (PARSE_AND_LIST_OPTIONS): Likewise. - * emultempl/ppc64elf.em (params): Init new field. - (OPTION_SPECULATE_INDIRECT_JUMPS): Define. - (OPTION_NO_SPECULATE_INDIRECT_JUMPS): Define. - (PARSE_AND_LIST_LONGOPTS): Handle --speculate-indirect-jumps. - (PARSE_AND_LIST_OPTIONS): Likewise. - (PARSE_AND_LIST_ARGS_CASES): Likewise. - * ld.texinfo (--no-plt-thread-safe): Correct itemx. - (--speculate-indirect-jumps): Document. - * testsuite/ld-powerpc/elfv2exe.d, - * testsuite/ld-powerpc/elfv2so.d, - * testsuite/ld-powerpc/relbrlt.d, - * testsuite/ld-powerpc/powerpc.exp: Disable plt alignment and - speculation barriers on various tests. - -2018-01-18 Alan Modra <amodra@gmail.com> - - * emultempl/ppc32elf.em (params): Init new field. - (enum ppc32_opt): New enum to define OPTION_* values. Add - OPTION_PLT_ALIGN and OPTION_NO_PLT_ALIGN. - (PARSE_AND_LIST_LONGOPTS): Handle new options. - (PARSE_AND_LIST_ARGS_CASES): Likewise. - (PARSE_AND_LIST_OPTIONS): Likewise. Break up help output. - * emultempl/ppc64elf.em (ppc_add_stub_section): Init alignment - correctly for negative --plt-stub-align. - * testsuite/ld-powerpc/elfv2exe.d, - * testsuite/ld-powerpc/elfv2so.d, - * testsuite/ld-powerpc/relbrlt.d, - * testsuite/ld-powerpc/relbrlt.s, - * testsuite/ld-powerpc/tlsexe.d, - * testsuite/ld-powerpc/tlsexe.r, - * testsuite/ld-powerpc/tlsexe32.d, - * testsuite/ld-powerpc/tlsexe32.g, - * testsuite/ld-powerpc/tlsexe32.r, - * testsuite/ld-powerpc/tlsexetoc.d, - * testsuite/ld-powerpc/tlsexetoc.r, - * testsuite/ld-powerpc/tlsopt5_32.d, - * testsuite/ld-powerpc/tlsso.d, - * testsuite/ld-powerpc/tlstocso.d: Update for changed stub order. - -2018-01-16 Nick Clifton <nickc@redhat.com> - - * po/pt_BR.po: Updated Brazilian Portugese translation. - -2018-01-15 Nick Clifton <nickc@redhat.com> - - * po/uk.po: Updated Ukranian translation. - -2018-01-13 Nick Clifton <nickc@redhat.com> - - * po/ld.pot: Regenerate. - * configure: Regenerate. - -2018-01-13 Nick Clifton <nickc@redhat.com> - - 2.30 branch created. - * NEWS: Add marker for 2.30. - -2018-01-12 Alan Modra <amodra@gmail.com> - - * testsuite/ld-elf/elf.exp: xfail "pr22374 function pointer - initialization" for currently failing targets. - -2018-01-12 Alan Modra <amodra@gmail.com> - - PR ld/22649 - * testsuite/ld-elf/pr22649.msg: Allow other messages. - * testsuite/ld-elf/shared.exp: Check that --gc-sections is - supported before running ld/22649 tests. - -2018-01-12 Nick Clifton <nickc@redhat.com> - - * emultempl/elf32.em (_handle_option): Add support for "-z undefs" - as the opposite of "-z defs". - * ld.texinfo: Document the new option. Update the description of - the -z defs option to make it clear that it does generate an error - if an undefined symbol reference is found in an object file whilst - creating a shared library. - * NEWS: Document this new feature. - -2018-01-11 H.J. Lu <hongjiu.lu@intel.com> - - * testsuite/ld-elf/pr22393-2a.rd: Replace "-z textonly" with - "-z separate-code". - * testsuite/ld-elf/pr22393-2b.rd: Likewise. - * testsuite/ld-x86-64/pr22393-3a.rd: Likewise. - * testsuite/ld-x86-64/pr22393-3b.rd: Likewise. - -2018-01-11 H.J. Lu <hongjiu.lu@intel.com> - - PR ld/22393 - * testsuite/ld-x86-64/pr22393-3a.c: New file. - * testsuite/ld-x86-64/pr22393-3a.rd: Likewise. - * testsuite/ld-x86-64/pr22393-3b.c: Likewise. - * testsuite/ld-x86-64/pr22393-3b.rd: Likewise. - * testsuite/ld-x86-64/x86-64.exp: Run tests for -z separate-code - -z max-page-size=0x1000. - -2018-01-11 H.J. Lu <hongjiu.lu@intel.com> - - PR ld/22393 - * testsuite/ld-elf/pr16322.d: Add -z noseparate-code. - * testsuite/ld-elf/pr22393-1.s: New file. - * testsuite/ld-elf/pr22393-1a.d: Likewise. - * testsuite/ld-elf/pr22393-1b.d: Likewise. - * testsuite/ld-elf/pr22393-1c.d: Likewise. - * testsuite/ld-elf/pr22393-1d.d: Likewise. - * testsuite/ld-elf/pr22393-1e.d: Likewise. - * testsuite/ld-elf/pr22393-1f.d: Likewise. - * testsuite/ld-elf/pr22393-2a.c: Likewise. - * testsuite/ld-elf/pr22393-2a.rd: Likewise. - * testsuite/ld-elf/pr22393-2b.c: Likewise. - * testsuite/ld-elf/pr22393-2b.rd: Likewise. - * testsuite/ld-elf/shared.exp: Run tests for -z separate-code. - -2018-01-11 H.J. Lu <hongjiu.lu@intel.com> - - PR ld/22393 - * NEWS: Mention "-z separate-code". - * emultempl/elf32.em (gld${EMULATION_NAME}_get_script): Get - builtin linker scripts and return linker scripts from disk for - "-z separate-code". - (gld${EMULATION_NAME}_handle_option): Handle "-z separate-code" - and "-z noseparate-code". - * genscripts.sh: Generate linker scripts for "-z separate-code". - (LD_FLAG): Set to *textonly for "-z separate-code". - * ld.texinfo: Document "-z separate-code". - * lexsup.c (elf_shlib_list_options): Add linker help messsages - for "-z separate-code" and "-z noseparate-code". - * scripttempl/elf.sc (SEPARATE_TEXT): New - (TEXT_SEGMENT_ALIGN): Likewise. - Use ${TEXT_SEGMENT_ALIGN} to align and pad text segment to - ${MAXPAGESIZE}. - -2018-01-11 H.J. Lu <hongjiu.lu@intel.com> - - PR ld/22649 - * testsuite/ld-elf/pr22649-1.s: New file. - * testsuite/ld-elf/pr22649-2a.s: Likewise. - * testsuite/ld-elf/pr22649-2b.s: Likewise. - * testsuite/ld-elf/pr22649.msg: Likewise. - * testsuite/ld-elf/shared.exp: Run ld/22649 tests. - -2018-01-11 H.J. Lu <hongjiu.lu@intel.com> - - PR ld/22677 - * scripttempl/elf.sc (PREINIT_ARRAY): New. - Don't add .preinit_array for ld -r. - * testsuite/ld-elf/pr22677.d: New file. - * testsuite/ld-elf/pr22677.s: Likewise. - -2018-01-11 Andrew Burgess <andrew.burgess@embecosm.com> - - * ldexp.h (union etree_union): Remove defsym field. - * ldexp.c (exp_assop): Remove defsym parameter, and use of defsym - parameter. - (exp_assign): Remove passing of defsym parameter. - (exp_defsym): Likewise. - (exp_provide): Likewise. - -2018-01-11 Andrew Burgess <andrew.burgess@embecosm.com> - - * ldexp.c (exp_fold_tree_1): Rework condition underwhich provide - nodes are ignored in the tree walk, and move the location at which - we change provide nodes into provided nodes. - (exp_init_os): Add etree_provided. - * testsuite/ld-scripts/provide-6.d: New file. - * testsuite/ld-scripts/provide-6.t: New file. - * testsuite/ld-scripts/provide-7.d: New file. - * testsuite/ld-scripts/provide-7.t: New file. - * testsuite/ld-scripts/provide-8.d: New file. - * testsuite/ld-scripts/provide-8.t: New file. - -2018-01-11 Andrew Burgess <andrew.burgess@embecosm.com> - - * testsuite/ld-scripts/provide-3.d: Add xfail directive. - * testsuite/ld-scripts/provide-4.d: Use new map file name. - * testsuite/ld-scripts/provide-5.d: Use new map file name. - * testsuite/ld-scripts/provide-4-map.d: Renamed to... - * testsuite/ld-scripts/provide-4.map: ...this. - * testsuite/ld-scripts/provide-5-map.d: Renamed to... - * testsuite/ld-scripts/provide-5.map: ...this. - * testsuite/ld-scripts/provide.exp: Move xfail into provide-3.d - file, and run tests in a loop. - -2018-01-11 Andrew Burgess <andrew.burgess@embecosm.com> - - * ldexp.c (exp_print_tree): Use '=' instead of ',' when printing - PROVIDE statements. - * testsuite/ld-scripts/provide-4.map: Update expected output. - * testsuite/ld-scripts/provide-5.map: Likewise. - -2018-01-11 H.J. Lu <hongjiu.lu@intel.com> - - PR ld/22696 - * scripttempl/elf.sc: Fix the order of SHLIB_RODATA_ADDR. - -2018-01-09 Jim Wilson <jimw@sifive.com> - - * testsuite/ld-elf/eh-frame-hdr.d (#xfail): Delete - (#alltargets): Renamed from #target. Add shared. - * testsuite/lib/ld-lib.exp (run_dump_test): Document shared target. - Document alltargets option. Add support for alltargets option. - (istarget): Add support for shared target. - -2018-01-08 Jim Wilson <jimw@sifive.com> - - * testsuite/ld-riscv-elf/c-lui.d: Don't use -shared. Check for _start - instead of .text. - * testsuite/ld-riscv-elf/c-lui.s: Add _start label. - * testsuite/ld-riscv-elf/ld-riscv-elf.exp: Before __global_pointer$ - tests, add call to check_shared_lib_support. - -2018-01-05 Jim Wilson <jimw@sifive.com> - - * testsuite/ld-riscv-elf/disas-jalr.d: New. - * testsuite/ld-riscv-elf/disas-jalr.s: New. - * testsuite/ld-riscv-elf/ld-riscv-elf.exp: Run new testcase. - - * emulparams/elf32lriscv-defs.sh (GENERATE_SHLIB_SCRIPT): Move inside - case on $target, and don't set for riscv*-elf targets. - (GENERATE_PIE_SCRIPT): Likewise. - -2018-01-03 Alan Modra <amodra@gmail.com> - - Update year range in copyright notice of all files. - -For older changes see ChangeLog-2017 - -Copyright (C) 2018 Free Software Foundation, Inc. - -Copying and distribution of this file, with or without modification, -are permitted in any medium without royalty provided the copyright -notice and this notice are preserved. - -Local Variables: -mode: change-log -left-margin: 8 -fill-column: 74 -version-control: never -End: diff -rupN binutils-2.30/ld/ldlang.c.orig binutils-2.30-new/ld/ldlang.c.orig --- binutils-2.30/ld/ldlang.c.orig 2018-01-13 14:31:16.000000000 +0100 +++ binutils-2.30-new/ld/ldlang.c.orig 1970-01-01 01:00:00.000000000 +0100 @@ -1,8782 +0,0 @@ -/* Linker command language support. - Copyright (C) 1991-2018 Free Software Foundation, Inc. - - This file is part of the GNU Binutils. - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, - MA 02110-1301, USA. */ - -#include "sysdep.h" -#include "bfd.h" -#include "libiberty.h" -#include "filenames.h" -#include "safe-ctype.h" -#include "obstack.h" -#include "bfdlink.h" - -#include "ld.h" -#include "ldmain.h" -#include "ldexp.h" -#include "ldlang.h" -#include <ldgram.h> -#include "ldlex.h" -#include "ldmisc.h" -#include "ldctor.h" -#include "ldfile.h" -#include "ldemul.h" -#include "fnmatch.h" -#include "demangle.h" -#include "hashtab.h" -#include "elf-bfd.h" -#ifdef ENABLE_PLUGINS -#include "plugin.h" -#endif /* ENABLE_PLUGINS */ - -#ifndef offsetof -#define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER)) -#endif - -/* Convert between addresses in bytes and sizes in octets. - For currently supported targets, octets_per_byte is always a power - of two, so we can use shifts. */ -#define TO_ADDR(X) ((X) >> opb_shift) -#define TO_SIZE(X) ((X) << opb_shift) - -/* Local variables. */ -static struct obstack stat_obstack; -static struct obstack map_obstack; - -#define obstack_chunk_alloc xmalloc -#define obstack_chunk_free free -static const char *entry_symbol_default = "start"; -static bfd_boolean map_head_is_link_order = FALSE; -static lang_output_section_statement_type *default_common_section; -static bfd_boolean map_option_f; -static bfd_vma print_dot; -static lang_input_statement_type *first_file; -static const char *current_target; -static lang_statement_list_type statement_list; -static lang_statement_list_type *stat_save[10]; -static lang_statement_list_type **stat_save_ptr = &stat_save[0]; -static struct unique_sections *unique_section_list; -static struct asneeded_minfo *asneeded_list_head; -static unsigned int opb_shift = 0; - -/* Forward declarations. */ -static void exp_init_os (etree_type *); -static lang_input_statement_type *lookup_name (const char *); -static void insert_undefined (const char *); -static bfd_boolean sort_def_symbol (struct bfd_link_hash_entry *, void *); -static void print_statement (lang_statement_union_type *, - lang_output_section_statement_type *); -static void print_statement_list (lang_statement_union_type *, - lang_output_section_statement_type *); -static void print_statements (void); -static void print_input_section (asection *, bfd_boolean); -static bfd_boolean lang_one_common (struct bfd_link_hash_entry *, void *); -static void lang_record_phdrs (void); -static void lang_do_version_exports_section (void); -static void lang_finalize_version_expr_head - (struct bfd_elf_version_expr_head *); -static void lang_do_memory_regions (void); - -/* Exported variables. */ -const char *output_target; -lang_output_section_statement_type *abs_output_section; -lang_statement_list_type lang_output_section_statement; -lang_statement_list_type *stat_ptr = &statement_list; -lang_statement_list_type file_chain = { NULL, NULL }; -lang_statement_list_type input_file_chain; -struct bfd_sym_chain entry_symbol = { NULL, NULL }; -const char *entry_section = ".text"; -struct lang_input_statement_flags input_flags; -bfd_boolean entry_from_cmdline; -bfd_boolean undef_from_cmdline; -bfd_boolean lang_has_input_file = FALSE; -bfd_boolean had_output_filename = FALSE; -bfd_boolean lang_float_flag = FALSE; -bfd_boolean delete_output_file_on_failure = FALSE; -struct lang_phdr *lang_phdr_list; -struct lang_nocrossrefs *nocrossref_list; -struct asneeded_minfo **asneeded_list_tail; - - /* Functions that traverse the linker script and might evaluate - DEFINED() need to increment this at the start of the traversal. */ -int lang_statement_iteration = 0; - -/* Return TRUE if the PATTERN argument is a wildcard pattern. - Although backslashes are treated specially if a pattern contains - wildcards, we do not consider the mere presence of a backslash to - be enough to cause the pattern to be treated as a wildcard. - That lets us handle DOS filenames more naturally. */ -#define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL) - -#define new_stat(x, y) \ - (x##_type *) new_statement (x##_enum, sizeof (x##_type), y) - -#define outside_section_address(q) \ - ((q)->output_offset + (q)->output_section->vma) - -#define outside_symbol_address(q) \ - ((q)->value + outside_section_address (q->section)) - -#define SECTION_NAME_MAP_LENGTH (16) - -void * -stat_alloc (size_t size) -{ - return obstack_alloc (&stat_obstack, size); -} - -static int -name_match (const char *pattern, const char *name) -{ - if (wildcardp (pattern)) - return fnmatch (pattern, name, 0); - return strcmp (pattern, name); -} - -/* If PATTERN is of the form archive:file, return a pointer to the - separator. If not, return NULL. */ - -static char * -archive_path (const char *pattern) -{ - char *p = NULL; - - if (link_info.path_separator == 0) - return p; - - p = strchr (pattern, link_info.path_separator); -#ifdef HAVE_DOS_BASED_FILE_SYSTEM - if (p == NULL || link_info.path_separator != ':') - return p; - - /* Assume a match on the second char is part of drive specifier, - as in "c:\silly.dos". */ - if (p == pattern + 1 && ISALPHA (*pattern)) - p = strchr (p + 1, link_info.path_separator); -#endif - return p; -} - -/* Given that FILE_SPEC results in a non-NULL SEP result from archive_path, - return whether F matches FILE_SPEC. */ - -static bfd_boolean -input_statement_is_archive_path (const char *file_spec, char *sep, - lang_input_statement_type *f) -{ - bfd_boolean match = FALSE; - - if ((*(sep + 1) == 0 - || name_match (sep + 1, f->filename) == 0) - && ((sep != file_spec) - == (f->the_bfd != NULL && f->the_bfd->my_archive != NULL))) - { - match = TRUE; - - if (sep != file_spec) - { - const char *aname = f->the_bfd->my_archive->filename; - *sep = 0; - match = name_match (file_spec, aname) == 0; - *sep = link_info.path_separator; - } - } - return match; -} - -static bfd_boolean -unique_section_p (const asection *sec, - const lang_output_section_statement_type *os) -{ - struct unique_sections *unam; - const char *secnam; - - if (!link_info.resolve_section_groups - && sec->owner != NULL - && bfd_is_group_section (sec->owner, sec)) - return !(os != NULL - && strcmp (os->name, DISCARD_SECTION_NAME) == 0); - - secnam = sec->name; - for (unam = unique_section_list; unam; unam = unam->next) - if (name_match (unam->name, secnam) == 0) - return TRUE; - - return FALSE; -} - -/* Generic traversal routines for finding matching sections. */ - -/* Return true if FILE matches a pattern in EXCLUDE_LIST, otherwise return - false. */ - -static bfd_boolean -walk_wild_file_in_exclude_list (struct name_list *exclude_list, - lang_input_statement_type *file) -{ - struct name_list *list_tmp; - - for (list_tmp = exclude_list; - list_tmp; - list_tmp = list_tmp->next) - { - char *p = archive_path (list_tmp->name); - - if (p != NULL) - { - if (input_statement_is_archive_path (list_tmp->name, p, file)) - return TRUE; - } - - else if (name_match (list_tmp->name, file->filename) == 0) - return TRUE; - - /* FIXME: Perhaps remove the following at some stage? Matching - unadorned archives like this was never documented and has - been superceded by the archive:path syntax. */ - else if (file->the_bfd != NULL - && file->the_bfd->my_archive != NULL - && name_match (list_tmp->name, - file->the_bfd->my_archive->filename) == 0) - return TRUE; - } - - return FALSE; -} - -/* Try processing a section against a wildcard. This just calls - the callback unless the filename exclusion list is present - and excludes the file. It's hardly ever present so this - function is very fast. */ - -static void -walk_wild_consider_section (lang_wild_statement_type *ptr, - lang_input_statement_type *file, - asection *s, - struct wildcard_list *sec, - callback_t callback, - void *data) -{ - /* Don't process sections from files which were excluded. */ - if (walk_wild_file_in_exclude_list (sec->spec.exclude_name_list, file)) - return; - - (*callback) (ptr, sec, s, ptr->section_flag_list, file, data); -} - -/* Lowest common denominator routine that can handle everything correctly, - but slowly. */ - -static void -walk_wild_section_general (lang_wild_statement_type *ptr, - lang_input_statement_type *file, - callback_t callback, - void *data) -{ - asection *s; - struct wildcard_list *sec; - - for (s = file->the_bfd->sections; s != NULL; s = s->next) - { - sec = ptr->section_list; - if (sec == NULL) - (*callback) (ptr, sec, s, ptr->section_flag_list, file, data); - - while (sec != NULL) - { - bfd_boolean skip = FALSE; - - if (sec->spec.name != NULL) - { - const char *sname = bfd_get_section_name (file->the_bfd, s); - - skip = name_match (sec->spec.name, sname) != 0; - } - - if (!skip) - walk_wild_consider_section (ptr, file, s, sec, callback, data); - - sec = sec->next; - } - } -} - -/* Routines to find a single section given its name. If there's more - than one section with that name, we report that. */ - -typedef struct -{ - asection *found_section; - bfd_boolean multiple_sections_found; -} section_iterator_callback_data; - -static bfd_boolean -section_iterator_callback (bfd *abfd ATTRIBUTE_UNUSED, asection *s, void *data) -{ - section_iterator_callback_data *d = (section_iterator_callback_data *) data; - - if (d->found_section != NULL) - { - d->multiple_sections_found = TRUE; - return TRUE; - } - - d->found_section = s; - return FALSE; -} - -static asection * -find_section (lang_input_statement_type *file, - struct wildcard_list *sec, - bfd_boolean *multiple_sections_found) -{ - section_iterator_callback_data cb_data = { NULL, FALSE }; - - bfd_get_section_by_name_if (file->the_bfd, sec->spec.name, - section_iterator_callback, &cb_data); - *multiple_sections_found = cb_data.multiple_sections_found; - return cb_data.found_section; -} - -/* Code for handling simple wildcards without going through fnmatch, - which can be expensive because of charset translations etc. */ - -/* A simple wild is a literal string followed by a single '*', - where the literal part is at least 4 characters long. */ - -static bfd_boolean -is_simple_wild (const char *name) -{ - size_t len = strcspn (name, "*?["); - return len >= 4 && name[len] == '*' && name[len + 1] == '\0'; -} - -static bfd_boolean -match_simple_wild (const char *pattern, const char *name) -{ - /* The first four characters of the pattern are guaranteed valid - non-wildcard characters. So we can go faster. */ - if (pattern[0] != name[0] || pattern[1] != name[1] - || pattern[2] != name[2] || pattern[3] != name[3]) - return FALSE; - - pattern += 4; - name += 4; - while (*pattern != '*') - if (*name++ != *pattern++) - return FALSE; - - return TRUE; -} - -/* Return the numerical value of the init_priority attribute from - section name NAME. */ - -static unsigned long -get_init_priority (const char *name) -{ - char *end; - unsigned long init_priority; - - /* GCC uses the following section names for the init_priority - attribute with numerical values 101 and 65535 inclusive. A - lower value means a higher priority. - - 1: .init_array.NNNN/.fini_array.NNNN: Where NNNN is the - decimal numerical value of the init_priority attribute. - The order of execution in .init_array is forward and - .fini_array is backward. - 2: .ctors.NNNN/.dtors.NNNN: Where NNNN is 65535 minus the - decimal numerical value of the init_priority attribute. - The order of execution in .ctors is backward and .dtors - is forward. - */ - if (strncmp (name, ".init_array.", 12) == 0 - || strncmp (name, ".fini_array.", 12) == 0) - { - init_priority = strtoul (name + 12, &end, 10); - return *end ? 0 : init_priority; - } - else if (strncmp (name, ".ctors.", 7) == 0 - || strncmp (name, ".dtors.", 7) == 0) - { - init_priority = strtoul (name + 7, &end, 10); - return *end ? 0 : 65535 - init_priority; - } - - return 0; -} - -/* Compare sections ASEC and BSEC according to SORT. */ - -static int -compare_section (sort_type sort, asection *asec, asection *bsec) -{ - int ret; - unsigned long ainit_priority, binit_priority; - - switch (sort) - { - default: - abort (); - - case by_init_priority: - ainit_priority - = get_init_priority (bfd_get_section_name (asec->owner, asec)); - binit_priority - = get_init_priority (bfd_get_section_name (bsec->owner, bsec)); - if (ainit_priority == 0 || binit_priority == 0) - goto sort_by_name; - ret = ainit_priority - binit_priority; - if (ret) - break; - else - goto sort_by_name; - - case by_alignment_name: - ret = (bfd_section_alignment (bsec->owner, bsec) - - bfd_section_alignment (asec->owner, asec)); - if (ret) - break; - /* Fall through. */ - - case by_name: -sort_by_name: - ret = strcmp (bfd_get_section_name (asec->owner, asec), - bfd_get_section_name (bsec->owner, bsec)); - break; - - case by_name_alignment: - ret = strcmp (bfd_get_section_name (asec->owner, asec), - bfd_get_section_name (bsec->owner, bsec)); - if (ret) - break; - /* Fall through. */ - - case by_alignment: - ret = (bfd_section_alignment (bsec->owner, bsec) - - bfd_section_alignment (asec->owner, asec)); - break; - } - - return ret; -} - -/* Build a Binary Search Tree to sort sections, unlike insertion sort - used in wild_sort(). BST is considerably faster if the number of - of sections are large. */ - -static lang_section_bst_type ** -wild_sort_fast (lang_wild_statement_type *wild, - struct wildcard_list *sec, - lang_input_statement_type *file ATTRIBUTE_UNUSED, - asection *section) -{ - lang_section_bst_type **tree; - - tree = &wild->tree; - if (!wild->filenames_sorted - && (sec == NULL || sec->spec.sorted == none)) - { - /* Append at the right end of tree. */ - while (*tree) - tree = &((*tree)->right); - return tree; - } - - while (*tree) - { - /* Find the correct node to append this section. */ - if (compare_section (sec->spec.sorted, section, (*tree)->section) < 0) - tree = &((*tree)->left); - else - tree = &((*tree)->right); - } - - return tree; -} - -/* Use wild_sort_fast to build a BST to sort sections. */ - -static void -output_section_callback_fast (lang_wild_statement_type *ptr, - struct wildcard_list *sec, - asection *section, - struct flag_info *sflag_list ATTRIBUTE_UNUSED, - lang_input_statement_type *file, - void *output) -{ - lang_section_bst_type *node; - lang_section_bst_type **tree; - lang_output_section_statement_type *os; - - os = (lang_output_section_statement_type *) output; - - if (unique_section_p (section, os)) - return; - - node = (lang_section_bst_type *) xmalloc (sizeof (lang_section_bst_type)); - node->left = 0; - node->right = 0; - node->section = section; - - tree = wild_sort_fast (ptr, sec, file, section); - if (tree != NULL) - *tree = node; -} - -/* Convert a sorted sections' BST back to list form. */ - -static void -output_section_callback_tree_to_list (lang_wild_statement_type *ptr, - lang_section_bst_type *tree, - void *output) -{ - if (tree->left) - output_section_callback_tree_to_list (ptr, tree->left, output); - - lang_add_section (&ptr->children, tree->section, NULL, - (lang_output_section_statement_type *) output); - - if (tree->right) - output_section_callback_tree_to_list (ptr, tree->right, output); - - free (tree); -} - -/* Specialized, optimized routines for handling different kinds of - wildcards */ - -static void -walk_wild_section_specs1_wild0 (lang_wild_statement_type *ptr, - lang_input_statement_type *file, - callback_t callback, - void *data) -{ - /* We can just do a hash lookup for the section with the right name. - But if that lookup discovers more than one section with the name - (should be rare), we fall back to the general algorithm because - we would otherwise have to sort the sections to make sure they - get processed in the bfd's order. */ - bfd_boolean multiple_sections_found; - struct wildcard_list *sec0 = ptr->handler_data[0]; - asection *s0 = find_section (file, sec0, &multiple_sections_found); - - if (multiple_sections_found) - walk_wild_section_general (ptr, file, callback, data); - else if (s0) - walk_wild_consider_section (ptr, file, s0, sec0, callback, data); -} - -static void -walk_wild_section_specs1_wild1 (lang_wild_statement_type *ptr, - lang_input_statement_type *file, - callback_t callback, - void *data) -{ - asection *s; - struct wildcard_list *wildsec0 = ptr->handler_data[0]; - - for (s = file->the_bfd->sections; s != NULL; s = s->next) - { - const char *sname = bfd_get_section_name (file->the_bfd, s); - bfd_boolean skip = !match_simple_wild (wildsec0->spec.name, sname); - - if (!skip) - walk_wild_consider_section (ptr, file, s, wildsec0, callback, data); - } -} - -static void -walk_wild_section_specs2_wild1 (lang_wild_statement_type *ptr, - lang_input_statement_type *file, - callback_t callback, - void *data) -{ - asection *s; - struct wildcard_list *sec0 = ptr->handler_data[0]; - struct wildcard_list *wildsec1 = ptr->handler_data[1]; - bfd_boolean multiple_sections_found; - asection *s0 = find_section (file, sec0, &multiple_sections_found); - - if (multiple_sections_found) - { - walk_wild_section_general (ptr, file, callback, data); - return; - } - - /* Note that if the section was not found, s0 is NULL and - we'll simply never succeed the s == s0 test below. */ - for (s = file->the_bfd->sections; s != NULL; s = s->next) - { - /* Recall that in this code path, a section cannot satisfy more - than one spec, so if s == s0 then it cannot match - wildspec1. */ - if (s == s0) - walk_wild_consider_section (ptr, file, s, sec0, callback, data); - else - { - const char *sname = bfd_get_section_name (file->the_bfd, s); - bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname); - - if (!skip) - walk_wild_consider_section (ptr, file, s, wildsec1, callback, - data); - } - } -} - -static void -walk_wild_section_specs3_wild2 (lang_wild_statement_type *ptr, - lang_input_statement_type *file, - callback_t callback, - void *data) -{ - asection *s; - struct wildcard_list *sec0 = ptr->handler_data[0]; - struct wildcard_list *wildsec1 = ptr->handler_data[1]; - struct wildcard_list *wildsec2 = ptr->handler_data[2]; - bfd_boolean multiple_sections_found; - asection *s0 = find_section (file, sec0, &multiple_sections_found); - - if (multiple_sections_found) - { - walk_wild_section_general (ptr, file, callback, data); - return; - } - - for (s = file->the_bfd->sections; s != NULL; s = s->next) - { - if (s == s0) - walk_wild_consider_section (ptr, file, s, sec0, callback, data); - else - { - const char *sname = bfd_get_section_name (file->the_bfd, s); - bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname); - - if (!skip) - walk_wild_consider_section (ptr, file, s, wildsec1, callback, data); - else - { - skip = !match_simple_wild (wildsec2->spec.name, sname); - if (!skip) - walk_wild_consider_section (ptr, file, s, wildsec2, callback, - data); - } - } - } -} - -static void -walk_wild_section_specs4_wild2 (lang_wild_statement_type *ptr, - lang_input_statement_type *file, - callback_t callback, - void *data) -{ - asection *s; - struct wildcard_list *sec0 = ptr->handler_data[0]; - struct wildcard_list *sec1 = ptr->handler_data[1]; - struct wildcard_list *wildsec2 = ptr->handler_data[2]; - struct wildcard_list *wildsec3 = ptr->handler_data[3]; - bfd_boolean multiple_sections_found; - asection *s0 = find_section (file, sec0, &multiple_sections_found), *s1; - - if (multiple_sections_found) - { - walk_wild_section_general (ptr, file, callback, data); - return; - } - - s1 = find_section (file, sec1, &multiple_sections_found); - if (multiple_sections_found) - { - walk_wild_section_general (ptr, file, callback, data); - return; - } - - for (s = file->the_bfd->sections; s != NULL; s = s->next) - { - if (s == s0) - walk_wild_consider_section (ptr, file, s, sec0, callback, data); - else - if (s == s1) - walk_wild_consider_section (ptr, file, s, sec1, callback, data); - else - { - const char *sname = bfd_get_section_name (file->the_bfd, s); - bfd_boolean skip = !match_simple_wild (wildsec2->spec.name, - sname); - - if (!skip) - walk_wild_consider_section (ptr, file, s, wildsec2, callback, - data); - else - { - skip = !match_simple_wild (wildsec3->spec.name, sname); - if (!skip) - walk_wild_consider_section (ptr, file, s, wildsec3, - callback, data); - } - } - } -} - -static void -walk_wild_section (lang_wild_statement_type *ptr, - lang_input_statement_type *file, - callback_t callback, - void *data) -{ - if (file->flags.just_syms) - return; - - (*ptr->walk_wild_section_handler) (ptr, file, callback, data); -} - -/* Returns TRUE when name1 is a wildcard spec that might match - something name2 can match. We're conservative: we return FALSE - only if the prefixes of name1 and name2 are different up to the - first wildcard character. */ - -static bfd_boolean -wild_spec_can_overlap (const char *name1, const char *name2) -{ - size_t prefix1_len = strcspn (name1, "?*["); - size_t prefix2_len = strcspn (name2, "?*["); - size_t min_prefix_len; - - /* Note that if there is no wildcard character, then we treat the - terminating 0 as part of the prefix. Thus ".text" won't match - ".text." or ".text.*", for example. */ - if (name1[prefix1_len] == '\0') - prefix1_len++; - if (name2[prefix2_len] == '\0') - prefix2_len++; - - min_prefix_len = prefix1_len < prefix2_len ? prefix1_len : prefix2_len; - - return memcmp (name1, name2, min_prefix_len) == 0; -} - -/* Select specialized code to handle various kinds of wildcard - statements. */ - -static void -analyze_walk_wild_section_handler (lang_wild_statement_type *ptr) -{ - int sec_count = 0; - int wild_name_count = 0; - struct wildcard_list *sec; - int signature; - int data_counter; - - ptr->walk_wild_section_handler = walk_wild_section_general; - ptr->handler_data[0] = NULL; - ptr->handler_data[1] = NULL; - ptr->handler_data[2] = NULL; - ptr->handler_data[3] = NULL; - ptr->tree = NULL; - - /* Count how many wildcard_specs there are, and how many of those - actually use wildcards in the name. Also, bail out if any of the - wildcard names are NULL. (Can this actually happen? - walk_wild_section used to test for it.) And bail out if any - of the wildcards are more complex than a simple string - ending in a single '*'. */ - for (sec = ptr->section_list; sec != NULL; sec = sec->next) - { - ++sec_count; - if (sec->spec.name == NULL) - return; - if (wildcardp (sec->spec.name)) - { - ++wild_name_count; - if (!is_simple_wild (sec->spec.name)) - return; - } - } - - /* The zero-spec case would be easy to optimize but it doesn't - happen in practice. Likewise, more than 4 specs doesn't - happen in practice. */ - if (sec_count == 0 || sec_count > 4) - return; - - /* Check that no two specs can match the same section. */ - for (sec = ptr->section_list; sec != NULL; sec = sec->next) - { - struct wildcard_list *sec2; - for (sec2 = sec->next; sec2 != NULL; sec2 = sec2->next) - { - if (wild_spec_can_overlap (sec->spec.name, sec2->spec.name)) - return; - } - } - - signature = (sec_count << 8) + wild_name_count; - switch (signature) - { - case 0x0100: - ptr->walk_wild_section_handler = walk_wild_section_specs1_wild0; - break; - case 0x0101: - ptr->walk_wild_section_handler = walk_wild_section_specs1_wild1; - break; - case 0x0201: - ptr->walk_wild_section_handler = walk_wild_section_specs2_wild1; - break; - case 0x0302: - ptr->walk_wild_section_handler = walk_wild_section_specs3_wild2; - break; - case 0x0402: - ptr->walk_wild_section_handler = walk_wild_section_specs4_wild2; - break; - default: - return; - } - - /* Now fill the data array with pointers to the specs, first the - specs with non-wildcard names, then the specs with wildcard - names. It's OK to process the specs in different order from the - given order, because we've already determined that no section - will match more than one spec. */ - data_counter = 0; - for (sec = ptr->section_list; sec != NULL; sec = sec->next) - if (!wildcardp (sec->spec.name)) - ptr->handler_data[data_counter++] = sec; - for (sec = ptr->section_list; sec != NULL; sec = sec->next) - if (wildcardp (sec->spec.name)) - ptr->handler_data[data_counter++] = sec; -} - -/* Handle a wild statement for a single file F. */ - -static void -walk_wild_file (lang_wild_statement_type *s, - lang_input_statement_type *f, - callback_t callback, - void *data) -{ - if (walk_wild_file_in_exclude_list (s->exclude_name_list, f)) - return; - - if (f->the_bfd == NULL - || !bfd_check_format (f->the_bfd, bfd_archive)) - walk_wild_section (s, f, callback, data); - else - { - bfd *member; - - /* This is an archive file. We must map each member of the - archive separately. */ - member = bfd_openr_next_archived_file (f->the_bfd, NULL); - while (member != NULL) - { - /* When lookup_name is called, it will call the add_symbols - entry point for the archive. For each element of the - archive which is included, BFD will call ldlang_add_file, - which will set the usrdata field of the member to the - lang_input_statement. */ - if (member->usrdata != NULL) - { - walk_wild_section (s, - (lang_input_statement_type *) member->usrdata, - callback, data); - } - - member = bfd_openr_next_archived_file (f->the_bfd, member); - } - } -} - -static void -walk_wild (lang_wild_statement_type *s, callback_t callback, void *data) -{ - const char *file_spec = s->filename; - char *p; - - if (file_spec == NULL) - { - /* Perform the iteration over all files in the list. */ - LANG_FOR_EACH_INPUT_STATEMENT (f) - { - walk_wild_file (s, f, callback, data); - } - } - else if ((p = archive_path (file_spec)) != NULL) - { - LANG_FOR_EACH_INPUT_STATEMENT (f) - { - if (input_statement_is_archive_path (file_spec, p, f)) - walk_wild_file (s, f, callback, data); - } - } - else if (wildcardp (file_spec)) - { - LANG_FOR_EACH_INPUT_STATEMENT (f) - { - if (fnmatch (file_spec, f->filename, 0) == 0) - walk_wild_file (s, f, callback, data); - } - } - else - { - lang_input_statement_type *f; - - /* Perform the iteration over a single file. */ - f = lookup_name (file_spec); - if (f) - walk_wild_file (s, f, callback, data); - } -} - -/* lang_for_each_statement walks the parse tree and calls the provided - function for each node, except those inside output section statements - with constraint set to -1. */ - -void -lang_for_each_statement_worker (void (*func) (lang_statement_union_type *), - lang_statement_union_type *s) -{ - for (; s != NULL; s = s->header.next) - { - func (s); - - switch (s->header.type) - { - case lang_constructors_statement_enum: - lang_for_each_statement_worker (func, constructor_list.head); - break; - case lang_output_section_statement_enum: - if (s->output_section_statement.constraint != -1) - lang_for_each_statement_worker - (func, s->output_section_statement.children.head); - break; - case lang_wild_statement_enum: - lang_for_each_statement_worker (func, - s->wild_statement.children.head); - break; - case lang_group_statement_enum: - lang_for_each_statement_worker (func, - s->group_statement.children.head); - break; - case lang_data_statement_enum: - case lang_reloc_statement_enum: - case lang_object_symbols_statement_enum: - case lang_output_statement_enum: - case lang_target_statement_enum: - case lang_input_section_enum: - case lang_input_statement_enum: - case lang_assignment_statement_enum: - case lang_padding_statement_enum: - case lang_address_statement_enum: - case lang_fill_statement_enum: - case lang_insert_statement_enum: - break; - default: - FAIL (); - break; - } - } -} - -void -lang_for_each_statement (void (*func) (lang_statement_union_type *)) -{ - lang_for_each_statement_worker (func, statement_list.head); -} - -/*----------------------------------------------------------------------*/ - -void -lang_list_init (lang_statement_list_type *list) -{ - list->head = NULL; - list->tail = &list->head; -} - -void -push_stat_ptr (lang_statement_list_type *new_ptr) -{ - if (stat_save_ptr >= stat_save + sizeof (stat_save) / sizeof (stat_save[0])) - abort (); - *stat_save_ptr++ = stat_ptr; - stat_ptr = new_ptr; -} - -void -pop_stat_ptr (void) -{ - if (stat_save_ptr <= stat_save) - abort (); - stat_ptr = *--stat_save_ptr; -} - -/* Build a new statement node for the parse tree. */ - -static lang_statement_union_type * -new_statement (enum statement_enum type, - size_t size, - lang_statement_list_type *list) -{ - lang_statement_union_type *new_stmt; - - new_stmt = (lang_statement_union_type *) stat_alloc (size); - new_stmt->header.type = type; - new_stmt->header.next = NULL; - lang_statement_append (list, new_stmt, &new_stmt->header.next); - return new_stmt; -} - -/* Build a new input file node for the language. There are several - ways in which we treat an input file, eg, we only look at symbols, - or prefix it with a -l etc. - - We can be supplied with requests for input files more than once; - they may, for example be split over several lines like foo.o(.text) - foo.o(.data) etc, so when asked for a file we check that we haven't - got it already so we don't duplicate the bfd. */ - -static lang_input_statement_type * -new_afile (const char *name, - lang_input_file_enum_type file_type, - const char *target, - bfd_boolean add_to_list) -{ - lang_input_statement_type *p; - - lang_has_input_file = TRUE; - - if (add_to_list) - p = (lang_input_statement_type *) new_stat (lang_input_statement, stat_ptr); - else - { - p = (lang_input_statement_type *) - stat_alloc (sizeof (lang_input_statement_type)); - p->header.type = lang_input_statement_enum; - p->header.next = NULL; - } - - memset (&p->the_bfd, 0, - sizeof (*p) - offsetof (lang_input_statement_type, the_bfd)); - p->target = target; - p->flags.dynamic = input_flags.dynamic; - p->flags.add_DT_NEEDED_for_dynamic = input_flags.add_DT_NEEDED_for_dynamic; - p->flags.add_DT_NEEDED_for_regular = input_flags.add_DT_NEEDED_for_regular; - p->flags.whole_archive = input_flags.whole_archive; - p->flags.sysrooted = input_flags.sysrooted; - - switch (file_type) - { - case lang_input_file_is_symbols_only_enum: - p->filename = name; - p->local_sym_name = name; - p->flags.real = TRUE; - p->flags.just_syms = TRUE; - break; - case lang_input_file_is_fake_enum: - p->filename = name; - p->local_sym_name = name; - break; - case lang_input_file_is_l_enum: - if (name[0] == ':' && name[1] != '\0') - { - p->filename = name + 1; - p->flags.full_name_provided = TRUE; - } - else - p->filename = name; - p->local_sym_name = concat ("-l", name, (const char *) NULL); - p->flags.maybe_archive = TRUE; - p->flags.real = TRUE; - p->flags.search_dirs = TRUE; - break; - case lang_input_file_is_marker_enum: - p->filename = name; - p->local_sym_name = name; - p->flags.search_dirs = TRUE; - break; - case lang_input_file_is_search_file_enum: - p->filename = name; - p->local_sym_name = name; - p->flags.real = TRUE; - p->flags.search_dirs = TRUE; - break; - case lang_input_file_is_file_enum: - p->filename = name; - p->local_sym_name = name; - p->flags.real = TRUE; - break; - default: - FAIL (); - } - - lang_statement_append (&input_file_chain, - (lang_statement_union_type *) p, - &p->next_real_file); - return p; -} - -lang_input_statement_type * -lang_add_input_file (const char *name, - lang_input_file_enum_type file_type, - const char *target) -{ - if (name != NULL - && (*name == '=' || CONST_STRNEQ (name, "$SYSROOT"))) - { - lang_input_statement_type *ret; - char *sysrooted_name - = concat (ld_sysroot, - name + (*name == '=' ? 1 : strlen ("$SYSROOT")), - (const char *) NULL); - - /* We've now forcibly prepended the sysroot, making the input - file independent of the context. Therefore, temporarily - force a non-sysrooted context for this statement, so it won't - get the sysroot prepended again when opened. (N.B. if it's a - script, any child nodes with input files starting with "/" - will be handled as "sysrooted" as they'll be found to be - within the sysroot subdirectory.) */ - unsigned int outer_sysrooted = input_flags.sysrooted; - input_flags.sysrooted = 0; - ret = new_afile (sysrooted_name, file_type, target, TRUE); - input_flags.sysrooted = outer_sysrooted; - return ret; - } - - return new_afile (name, file_type, target, TRUE); -} - -struct out_section_hash_entry -{ - struct bfd_hash_entry root; - lang_statement_union_type s; -}; - -/* The hash table. */ - -static struct bfd_hash_table output_section_statement_table; - -/* Support routines for the hash table used by lang_output_section_find, - initialize the table, fill in an entry and remove the table. */ - -static struct bfd_hash_entry * -output_section_statement_newfunc (struct bfd_hash_entry *entry, - struct bfd_hash_table *table, - const char *string) -{ - lang_output_section_statement_type **nextp; - struct out_section_hash_entry *ret; - - if (entry == NULL) - { - entry = (struct bfd_hash_entry *) bfd_hash_allocate (table, - sizeof (*ret)); - if (entry == NULL) - return entry; - } - - entry = bfd_hash_newfunc (entry, table, string); - if (entry == NULL) - return entry; - - ret = (struct out_section_hash_entry *) entry; - memset (&ret->s, 0, sizeof (ret->s)); - ret->s.header.type = lang_output_section_statement_enum; - ret->s.output_section_statement.subsection_alignment = -1; - ret->s.output_section_statement.section_alignment = -1; - ret->s.output_section_statement.block_value = 1; - lang_list_init (&ret->s.output_section_statement.children); - lang_statement_append (stat_ptr, &ret->s, &ret->s.header.next); - - /* For every output section statement added to the list, except the - first one, lang_output_section_statement.tail points to the "next" - field of the last element of the list. */ - if (lang_output_section_statement.head != NULL) - ret->s.output_section_statement.prev - = ((lang_output_section_statement_type *) - ((char *) lang_output_section_statement.tail - - offsetof (lang_output_section_statement_type, next))); - - /* GCC's strict aliasing rules prevent us from just casting the - address, so we store the pointer in a variable and cast that - instead. */ - nextp = &ret->s.output_section_statement.next; - lang_statement_append (&lang_output_section_statement, - &ret->s, - (lang_statement_union_type **) nextp); - return &ret->root; -} - -static void -output_section_statement_table_init (void) -{ - if (!bfd_hash_table_init_n (&output_section_statement_table, - output_section_statement_newfunc, - sizeof (struct out_section_hash_entry), - 61)) - einfo (_("%P%F: can not create hash table: %E\n")); -} - -static void -output_section_statement_table_free (void) -{ - bfd_hash_table_free (&output_section_statement_table); -} - -/* Build enough state so that the parser can build its tree. */ - -void -lang_init (void) -{ - obstack_begin (&stat_obstack, 1000); - - stat_ptr = &statement_list; - - output_section_statement_table_init (); - - lang_list_init (stat_ptr); - - lang_list_init (&input_file_chain); - lang_list_init (&lang_output_section_statement); - lang_list_init (&file_chain); - first_file = lang_add_input_file (NULL, lang_input_file_is_marker_enum, - NULL); - abs_output_section = - lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME, 0, TRUE); - - abs_output_section->bfd_section = bfd_abs_section_ptr; - - asneeded_list_head = NULL; - asneeded_list_tail = &asneeded_list_head; -} - -void -lang_finish (void) -{ - output_section_statement_table_free (); -} - -/*---------------------------------------------------------------------- - A region is an area of memory declared with the - MEMORY { name:org=exp, len=exp ... } - syntax. - - We maintain a list of all the regions here. - - If no regions are specified in the script, then the default is used - which is created when looked up to be the entire data space. - - If create is true we are creating a region inside a MEMORY block. - In this case it is probably an error to create a region that has - already been created. If we are not inside a MEMORY block it is - dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION) - and so we issue a warning. - - Each region has at least one name. The first name is either - DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add - alias names to an existing region within a script with - REGION_ALIAS (alias, region_name). Each name corresponds to at most one - region. */ - -static lang_memory_region_type *lang_memory_region_list; -static lang_memory_region_type **lang_memory_region_list_tail - = &lang_memory_region_list; - -lang_memory_region_type * -lang_memory_region_lookup (const char *const name, bfd_boolean create) -{ - lang_memory_region_name *n; - lang_memory_region_type *r; - lang_memory_region_type *new_region; - - /* NAME is NULL for LMA memspecs if no region was specified. */ - if (name == NULL) - return NULL; - - for (r = lang_memory_region_list; r != NULL; r = r->next) - for (n = &r->name_list; n != NULL; n = n->next) - if (strcmp (n->name, name) == 0) - { - if (create) - einfo (_("%P:%S: warning: redeclaration of memory region `%s'\n"), - NULL, name); - return r; - } - - if (!create && strcmp (name, DEFAULT_MEMORY_REGION)) - einfo (_("%P:%S: warning: memory region `%s' not declared\n"), - NULL, name); - - new_region = (lang_memory_region_type *) - stat_alloc (sizeof (lang_memory_region_type)); - - new_region->name_list.name = xstrdup (name); - new_region->name_list.next = NULL; - new_region->next = NULL; - new_region->origin_exp = NULL; - new_region->origin = 0; - new_region->length_exp = NULL; - new_region->length = ~(bfd_size_type) 0; - new_region->current = 0; - new_region->last_os = NULL; - new_region->flags = 0; - new_region->not_flags = 0; - new_region->had_full_message = FALSE; - - *lang_memory_region_list_tail = new_region; - lang_memory_region_list_tail = &new_region->next; - - return new_region; -} - -void -lang_memory_region_alias (const char *alias, const char *region_name) -{ - lang_memory_region_name *n; - lang_memory_region_type *r; - lang_memory_region_type *region; - - /* The default region must be unique. This ensures that it is not necessary - to iterate through the name list if someone wants the check if a region is - the default memory region. */ - if (strcmp (region_name, DEFAULT_MEMORY_REGION) == 0 - || strcmp (alias, DEFAULT_MEMORY_REGION) == 0) - einfo (_("%F%P:%S: error: alias for default memory region\n"), NULL); - - /* Look for the target region and check if the alias is not already - in use. */ - region = NULL; - for (r = lang_memory_region_list; r != NULL; r = r->next) - for (n = &r->name_list; n != NULL; n = n->next) - { - if (region == NULL && strcmp (n->name, region_name) == 0) - region = r; - if (strcmp (n->name, alias) == 0) - einfo (_("%F%P:%S: error: redefinition of memory region " - "alias `%s'\n"), - NULL, alias); - } - - /* Check if the target region exists. */ - if (region == NULL) - einfo (_("%F%P:%S: error: memory region `%s' " - "for alias `%s' does not exist\n"), - NULL, region_name, alias); - - /* Add alias to region name list. */ - n = (lang_memory_region_name *) stat_alloc (sizeof (lang_memory_region_name)); - n->name = xstrdup (alias); - n->next = region->name_list.next; - region->name_list.next = n; -} - -static lang_memory_region_type * -lang_memory_default (asection *section) -{ - lang_memory_region_type *p; - - flagword sec_flags = section->flags; - - /* Override SEC_DATA to mean a writable section. */ - if ((sec_flags & (SEC_ALLOC | SEC_READONLY | SEC_CODE)) == SEC_ALLOC) - sec_flags |= SEC_DATA; - - for (p = lang_memory_region_list; p != NULL; p = p->next) - { - if ((p->flags & sec_flags) != 0 - && (p->not_flags & sec_flags) == 0) - { - return p; - } - } - return lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE); -} - -/* Get the output section statement directly from the userdata. */ - -lang_output_section_statement_type * -lang_output_section_get (const asection *output_section) -{ - return get_userdata (output_section); -} - -/* Find or create an output_section_statement with the given NAME. - If CONSTRAINT is non-zero match one with that constraint, otherwise - match any non-negative constraint. If CREATE, always make a - new output_section_statement for SPECIAL CONSTRAINT. */ - -lang_output_section_statement_type * -lang_output_section_statement_lookup (const char *name, - int constraint, - bfd_boolean create) -{ - struct out_section_hash_entry *entry; - - entry = ((struct out_section_hash_entry *) - bfd_hash_lookup (&output_section_statement_table, name, - create, FALSE)); - if (entry == NULL) - { - if (create) - einfo (_("%P%F: failed creating section `%s': %E\n"), name); - return NULL; - } - - if (entry->s.output_section_statement.name != NULL) - { - /* We have a section of this name, but it might not have the correct - constraint. */ - struct out_section_hash_entry *last_ent; - - name = entry->s.output_section_statement.name; - if (create && constraint == SPECIAL) - /* Not traversing to the end reverses the order of the second - and subsequent SPECIAL sections in the hash table chain, - but that shouldn't matter. */ - last_ent = entry; - else - do - { - if (constraint == entry->s.output_section_statement.constraint - || (constraint == 0 - && entry->s.output_section_statement.constraint >= 0)) - return &entry->s.output_section_statement; - last_ent = entry; - entry = (struct out_section_hash_entry *) entry->root.next; - } - while (entry != NULL - && name == entry->s.output_section_statement.name); - - if (!create) - return NULL; - - entry - = ((struct out_section_hash_entry *) - output_section_statement_newfunc (NULL, - &output_section_statement_table, - name)); - if (entry == NULL) - { - einfo (_("%P%F: failed creating section `%s': %E\n"), name); - return NULL; - } - entry->root = last_ent->root; - last_ent->root.next = &entry->root; - } - - entry->s.output_section_statement.name = name; - entry->s.output_section_statement.constraint = constraint; - return &entry->s.output_section_statement; -} - -/* Find the next output_section_statement with the same name as OS. - If CONSTRAINT is non-zero, find one with that constraint otherwise - match any non-negative constraint. */ - -lang_output_section_statement_type * -next_matching_output_section_statement (lang_output_section_statement_type *os, - int constraint) -{ - /* All output_section_statements are actually part of a - struct out_section_hash_entry. */ - struct out_section_hash_entry *entry = (struct out_section_hash_entry *) - ((char *) os - - offsetof (struct out_section_hash_entry, s.output_section_statement)); - const char *name = os->name; - - ASSERT (name == entry->root.string); - do - { - entry = (struct out_section_hash_entry *) entry->root.next; - if (entry == NULL - || name != entry->s.output_section_statement.name) - return NULL; - } - while (constraint != entry->s.output_section_statement.constraint - && (constraint != 0 - || entry->s.output_section_statement.constraint < 0)); - - return &entry->s.output_section_statement; -} - -/* 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, - flagword sec_flags, - lang_output_section_statement_type **exact, - lang_match_sec_type_func match_type) -{ - lang_output_section_statement_type *first, *look, *found; - flagword look_flags, differ; - - /* 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) - { - look_flags = look->flags; - if (look->bfd_section != NULL) - { - look_flags = look->bfd_section->flags; - if (match_type && !match_type (link_info.output_bfd, - look->bfd_section, - sec->owner, sec)) - continue; - } - differ = look_flags ^ sec_flags; - if (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY - | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL))) - found = look; - } - if (found != NULL) - { - if (exact != NULL) - *exact = found; - return found; - } - - if ((sec_flags & SEC_CODE) != 0 - && (sec_flags & SEC_ALLOC) != 0) - { - /* Try for a rw code section. */ - for (look = first; look; look = look->next) - { - look_flags = look->flags; - if (look->bfd_section != NULL) - { - look_flags = look->bfd_section->flags; - if (match_type && !match_type (link_info.output_bfd, - look->bfd_section, - sec->owner, sec)) - continue; - } - differ = look_flags ^ sec_flags; - if (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD - | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL))) - found = look; - } - } - else if ((sec_flags & SEC_READONLY) != 0 - && (sec_flags & SEC_ALLOC) != 0) - { - /* .rodata can go after .text, .sdata2 after .rodata. */ - for (look = first; look; look = look->next) - { - look_flags = look->flags; - if (look->bfd_section != NULL) - { - look_flags = look->bfd_section->flags; - if (match_type && !match_type (link_info.output_bfd, - look->bfd_section, - sec->owner, sec)) - continue; - } - differ = look_flags ^ sec_flags; - if (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD - | SEC_READONLY | SEC_SMALL_DATA)) - || (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD - | SEC_READONLY)) - && !(look_flags & SEC_SMALL_DATA))) - found = look; - } - } - else if ((sec_flags & SEC_THREAD_LOCAL) != 0 - && (sec_flags & SEC_ALLOC) != 0) - { - /* .tdata can go after .data, .tbss after .tdata. Treat .tbss - as if it were a loaded section, and don't use match_type. */ - bfd_boolean seen_thread_local = FALSE; - - match_type = NULL; - for (look = first; look; look = look->next) - { - look_flags = look->flags; - if (look->bfd_section != NULL) - look_flags = look->bfd_section->flags; - - differ = look_flags ^ (sec_flags | SEC_LOAD | SEC_HAS_CONTENTS); - if (!(differ & (SEC_THREAD_LOCAL | SEC_ALLOC))) - { - /* .tdata and .tbss must be adjacent and in that order. */ - if (!(look_flags & SEC_LOAD) - && (sec_flags & SEC_LOAD)) - /* ..so if we're at a .tbss section and we're placing - a .tdata section stop looking and return the - previous section. */ - break; - found = look; - seen_thread_local = TRUE; - } - else if (seen_thread_local) - break; - else if (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD))) - found = look; - } - } - else if ((sec_flags & SEC_SMALL_DATA) != 0 - && (sec_flags & SEC_ALLOC) != 0) - { - /* .sdata goes after .data, .sbss after .sdata. */ - for (look = first; look; look = look->next) - { - look_flags = look->flags; - if (look->bfd_section != NULL) - { - look_flags = look->bfd_section->flags; - if (match_type && !match_type (link_info.output_bfd, - look->bfd_section, - sec->owner, sec)) - continue; - } - differ = look_flags ^ sec_flags; - if (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD - | SEC_THREAD_LOCAL)) - || ((look_flags & SEC_SMALL_DATA) - && !(sec_flags & SEC_HAS_CONTENTS))) - found = look; - } - } - else if ((sec_flags & SEC_HAS_CONTENTS) != 0 - && (sec_flags & SEC_ALLOC) != 0) - { - /* .data goes after .rodata. */ - for (look = first; look; look = look->next) - { - look_flags = look->flags; - if (look->bfd_section != NULL) - { - look_flags = look->bfd_section->flags; - if (match_type && !match_type (link_info.output_bfd, - look->bfd_section, - sec->owner, sec)) - continue; - } - differ = look_flags ^ sec_flags; - if (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD - | SEC_SMALL_DATA | SEC_THREAD_LOCAL))) - found = look; - } - } - else if ((sec_flags & SEC_ALLOC) != 0) - { - /* .bss goes after any other alloc section. */ - for (look = first; look; look = look->next) - { - look_flags = look->flags; - if (look->bfd_section != NULL) - { - look_flags = look->bfd_section->flags; - if (match_type && !match_type (link_info.output_bfd, - look->bfd_section, - sec->owner, sec)) - continue; - } - differ = look_flags ^ sec_flags; - if (!(differ & SEC_ALLOC)) - found = look; - } - } - else - { - /* non-alloc go last. */ - for (look = first; look; look = look->next) - { - look_flags = look->flags; - if (look->bfd_section != NULL) - look_flags = look->bfd_section->flags; - differ = look_flags ^ sec_flags; - if (!(differ & SEC_DEBUGGING)) - found = look; - } - return found; - } - - if (found || !match_type) - return found; - - return lang_output_section_find_by_flags (sec, sec_flags, NULL, NULL); -} - -/* 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) -{ - lang_output_section_statement_type *lookup; - - for (lookup = os->prev; lookup != NULL; lookup = lookup->prev) - { - if (lookup->constraint < 0) - continue; - - if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL) - return lookup->bfd_section; - } - - return NULL; -} - -/* Look for a suitable place for a new output section statement. 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, except in two cases; The first - assignment to dot, and assignments before non-alloc sections. - Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or - similar assignments that set the initial address, or we might - insert non-alloc note sections among assignments setting end of - image symbols. */ - -static lang_statement_union_type ** -insert_os_after (lang_output_section_statement_type *after) -{ - lang_statement_union_type **where; - lang_statement_union_type **assign = NULL; - bfd_boolean ignore_first; - - ignore_first - = after == &lang_output_section_statement.head->output_section_statement; - - 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 - && !ignore_first) - assign = where; - } - ignore_first = FALSE; - 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) - { - asection *s = (*where)->output_section_statement.bfd_section; - - if (s == NULL - || s->map_head.s == NULL - || (s->flags & SEC_ALLOC) != 0) - where = assign; - } - break; - 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_insert_statement_enum: - continue; - } - break; - } - - return where; -} - -lang_output_section_statement_type * -lang_insert_orphan (asection *s, - const char *secname, - int constraint, - lang_output_section_statement_type *after, - struct orphan_save *place, - etree_type *address, - lang_statement_list_type *add_child) -{ - lang_statement_list_type add; - lang_output_section_statement_type *os; - lang_output_section_statement_type **os_tail; - - /* 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) - { - lang_list_init (&add); - push_stat_ptr (&add); - } - - if (bfd_link_relocatable (&link_info) - || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0) - address = exp_intop (0); - - os_tail = ((lang_output_section_statement_type **) - lang_output_section_statement.tail); - os = lang_enter_output_section_statement (secname, address, normal_section, - NULL, NULL, NULL, constraint, 0); - - if (add_child == NULL) - add_child = &os->children; - lang_add_section (add_child, s, NULL, os); - - if (after && (s->flags & (SEC_LOAD | SEC_ALLOC)) != 0) - { - const char *region = (after->region - ? after->region->name_list.name - : DEFAULT_MEMORY_REGION); - const char *lma_region = (after->lma_region - ? after->lma_region->name_list.name - : NULL); - lang_leave_output_section_statement (NULL, region, after->phdrs, - lma_region); - } - else - lang_leave_output_section_statement (NULL, DEFAULT_MEMORY_REGION, NULL, - NULL); - - /* Restore the global list pointer. */ - if (after != NULL) - pop_stat_ptr (); - - if (after != NULL && os->bfd_section != NULL) - { - asection *snew, *as; - - 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 = &link_info.output_bfd->sections; - - as = *place->section; - - if (!as) - { - /* Put the section at the end of the list. */ - - /* Unlink the section. */ - bfd_section_list_remove (link_info.output_bfd, snew); - - /* Now tack it back on in the right place. */ - bfd_section_list_append (link_info.output_bfd, snew); - } - else if (as != snew && as->prev != snew) - { - /* Unlink the section. */ - bfd_section_list_remove (link_info.output_bfd, snew); - - /* Now tack it back on in the right place. */ - bfd_section_list_insert_before (link_info.output_bfd, as, 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 = insert_os_after (after); - - *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 (*stat_ptr->tail == add.head) - stat_ptr->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->prev = (lang_output_section_statement_type *) - ((char *) place->os_tail - - offsetof (lang_output_section_statement_type, next)); - newly_added_os->next = *place->os_tail; - if (newly_added_os->next != NULL) - newly_added_os->next->prev = newly_added_os; - *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_print_asneeded (void) -{ - struct asneeded_minfo *m; - - if (asneeded_list_head == NULL) - return; - - minfo (_("\nAs-needed library included to satisfy reference by file (symbol)\n\n")); - - for (m = asneeded_list_head; m != NULL; m = m->next) - { - size_t len; - - minfo ("%s", m->soname); - len = strlen (m->soname); - - if (len >= 29) - { - print_nl (); - len = 0; - } - while (len < 30) - { - print_space (); - ++len; - } - - if (m->ref != NULL) - minfo ("%B ", m->ref); - minfo ("(%T)\n", m->name); - } -} - -static void -lang_map_flags (flagword flag) -{ - if (flag & SEC_ALLOC) - minfo ("a"); - - if (flag & SEC_CODE) - minfo ("x"); - - if (flag & SEC_READONLY) - minfo ("r"); - - if (flag & SEC_DATA) - minfo ("w"); - - if (flag & SEC_LOAD) - minfo ("l"); -} - -void -lang_map (void) -{ - lang_memory_region_type *m; - bfd_boolean dis_header_printed = FALSE; - - LANG_FOR_EACH_INPUT_STATEMENT (file) - { - asection *s; - - if ((file->the_bfd->flags & (BFD_LINKER_CREATED | DYNAMIC)) != 0 - || file->flags.just_syms) - continue; - - for (s = file->the_bfd->sections; s != NULL; s = s->next) - if ((s->output_section == NULL - || s->output_section->owner != link_info.output_bfd) - && (s->flags & (SEC_LINKER_CREATED | SEC_KEEP)) == 0) - { - if (!dis_header_printed) - { - fprintf (config.map_file, _("\nDiscarded input sections\n\n")); - dis_header_printed = TRUE; - } - - print_input_section (s, TRUE); - } - } - - minfo (_("\nMemory Configuration\n\n")); - fprintf (config.map_file, "%-16s %-18s %-18s %s\n", - _("Name"), _("Origin"), _("Length"), _("Attributes")); - - for (m = lang_memory_region_list; m != NULL; m = m->next) - { - char buf[100]; - int len; - - fprintf (config.map_file, "%-16s ", m->name_list.name); - - sprintf_vma (buf, m->origin); - minfo ("0x%s ", buf); - len = strlen (buf); - while (len < 16) - { - print_space (); - ++len; - } - - minfo ("0x%V", m->length); - if (m->flags || m->not_flags) - { -#ifndef BFD64 - minfo (" "); -#endif - if (m->flags) - { - print_space (); - lang_map_flags (m->flags); - } - - if (m->not_flags) - { - minfo (" !"); - lang_map_flags (m->not_flags); - } - } - - print_nl (); - } - - fprintf (config.map_file, _("\nLinker script and memory map\n\n")); - - if (!link_info.reduce_memory_overheads) - { - obstack_begin (&map_obstack, 1000); - bfd_link_hash_traverse (link_info.hash, sort_def_symbol, 0); - } - lang_statement_iteration++; - print_statements (); - - ldemul_extra_map_file_text (link_info.output_bfd, &link_info, - config.map_file); -} - -static bfd_boolean -sort_def_symbol (struct bfd_link_hash_entry *hash_entry, - void *info ATTRIBUTE_UNUSED) -{ - if ((hash_entry->type == bfd_link_hash_defined - || hash_entry->type == bfd_link_hash_defweak) - && hash_entry->u.def.section->owner != link_info.output_bfd - && hash_entry->u.def.section->owner != NULL) - { - input_section_userdata_type *ud; - struct map_symbol_def *def; - - ud = ((input_section_userdata_type *) - get_userdata (hash_entry->u.def.section)); - if (!ud) - { - ud = (input_section_userdata_type *) stat_alloc (sizeof (*ud)); - get_userdata (hash_entry->u.def.section) = ud; - ud->map_symbol_def_tail = &ud->map_symbol_def_head; - ud->map_symbol_def_count = 0; - } - else if (!ud->map_symbol_def_tail) - ud->map_symbol_def_tail = &ud->map_symbol_def_head; - - def = (struct map_symbol_def *) obstack_alloc (&map_obstack, sizeof *def); - def->entry = hash_entry; - *(ud->map_symbol_def_tail) = def; - ud->map_symbol_def_tail = &def->next; - ud->map_symbol_def_count++; - } - return TRUE; -} - -/* Initialize an output section. */ - -static void -init_os (lang_output_section_statement_type *s, flagword flags) -{ - if (strcmp (s->name, DISCARD_SECTION_NAME) == 0) - einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME); - - if (s->constraint != SPECIAL) - s->bfd_section = bfd_get_section_by_name (link_info.output_bfd, s->name); - if (s->bfd_section == NULL) - s->bfd_section = bfd_make_section_anyway_with_flags (link_info.output_bfd, - s->name, flags); - if (s->bfd_section == NULL) - { - einfo (_("%P%F: output format %s cannot represent section" - " called %s: %E\n"), - link_info.output_bfd->xvec->name, s->name); - } - s->bfd_section->output_section = s->bfd_section; - s->bfd_section->output_offset = 0; - - /* Set the userdata of the output section to the output section - statement to avoid lookup. */ - get_userdata (s->bfd_section) = s; - - /* If there is a base address, make sure that any sections it might - mention are initialized. */ - if (s->addr_tree != NULL) - exp_init_os (s->addr_tree); - - if (s->load_base != NULL) - exp_init_os (s->load_base); - - /* If supplied an alignment, set it. */ - if (s->section_alignment != -1) - s->bfd_section->alignment_power = s->section_alignment; -} - -/* Make sure that all output sections mentioned in an expression are - initialized. */ - -static void -exp_init_os (etree_type *exp) -{ - switch (exp->type.node_class) - { - case etree_assign: - case etree_provide: - case etree_provided: - exp_init_os (exp->assign.src); - break; - - case etree_binary: - exp_init_os (exp->binary.lhs); - exp_init_os (exp->binary.rhs); - break; - - case etree_trinary: - exp_init_os (exp->trinary.cond); - exp_init_os (exp->trinary.lhs); - exp_init_os (exp->trinary.rhs); - break; - - case etree_assert: - exp_init_os (exp->assert_s.child); - break; - - case etree_unary: - exp_init_os (exp->unary.child); - break; - - case etree_name: - switch (exp->type.node_code) - { - case ADDR: - case LOADADDR: - case SIZEOF: - { - lang_output_section_statement_type *os; - - os = lang_output_section_find (exp->name.name); - if (os != NULL && os->bfd_section == NULL) - init_os (os, 0); - } - } - break; - - default: - break; - } -} - -static void -section_already_linked (bfd *abfd, asection *sec, void *data) -{ - lang_input_statement_type *entry = (lang_input_statement_type *) data; - - /* If we are only reading symbols from this object, then we want to - discard all sections. */ - if (entry->flags.just_syms) - { - bfd_link_just_syms (abfd, sec, &link_info); - return; - } - - /* Deal with SHF_EXCLUDE ELF sections. */ - if (!bfd_link_relocatable (&link_info) - && (abfd->flags & BFD_PLUGIN) == 0 - && (sec->flags & (SEC_GROUP | SEC_KEEP | SEC_EXCLUDE)) == SEC_EXCLUDE) - sec->output_section = bfd_abs_section_ptr; - - if (!(abfd->flags & DYNAMIC)) - bfd_section_already_linked (abfd, sec, &link_info); -} - - -/* Returns true if SECTION is one we know will be discarded based on its - section flags, otherwise returns false. */ - -static bfd_boolean -lang_discard_section_p (asection *section) -{ - bfd_boolean discard; - flagword flags = section->flags; - - /* Discard sections marked with SEC_EXCLUDE. */ - discard = (flags & SEC_EXCLUDE) != 0; - - /* Discard the group descriptor sections when we're finally placing the - sections from within the group. */ - if ((flags & SEC_GROUP) != 0 - && 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) - && (flags & SEC_DEBUGGING) != 0) - discard = TRUE; - - return discard; -} - -/* The wild routines. - - These expand statements like *(.text) and foo.o to a list of - explicit actions, like foo.o(.text), bar.o(.text) and - foo.o(.text, .data). */ - -/* Add SECTION to the output section OUTPUT. Do this by creating a - lang_input_section statement which is placed at PTR. */ - -void -lang_add_section (lang_statement_list_type *ptr, - asection *section, - struct flag_info *sflag_info, - lang_output_section_statement_type *output) -{ - flagword flags = section->flags; - - bfd_boolean discard; - lang_input_section_type *new_section; - bfd *abfd = link_info.output_bfd; - - /* Is this section one we know should be discarded? */ - discard = lang_discard_section_p (section); - - /* Discard input sections which are assigned to a section named - DISCARD_SECTION_NAME. */ - if (strcmp (output->name, DISCARD_SECTION_NAME) == 0) - discard = TRUE; - - if (discard) - { - if (section->output_section == NULL) - { - /* This prevents future calls from assigning this section. */ - section->output_section = bfd_abs_section_ptr; - } - return; - } - - if (sflag_info) - { - bfd_boolean keep; - - keep = bfd_lookup_section_flags (&link_info, sflag_info, section); - if (!keep) - return; - } - - if (section->output_section != NULL) - return; - - /* 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 - SEC_NEVER_LOAD section in the middle of an otherwise loaded - section (I don't know why we want to do this, but we do). - build_link_order in ldwrite.c handles this case by turning - the embedded SEC_NEVER_LOAD section into a fill. */ - flags &= ~ SEC_NEVER_LOAD; - - /* If final link, don't copy the SEC_LINK_ONCE flags, they've - 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 ((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) - { - case normal_section: - case overlay_section: - break; - case noalloc_section: - flags &= ~SEC_ALLOC; - break; - case noload_section: - flags &= ~SEC_LOAD; - flags |= SEC_NEVER_LOAD; - /* Unfortunately GNU ld has managed to evolve two different - meanings to NOLOAD in scripts. ELF gets a .bss style noload, - alloc, no contents section. All others get a noload, noalloc - section. */ - if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour) - flags &= ~SEC_HAS_CONTENTS; - else - flags &= ~SEC_ALLOC; - break; - } - - if (output->bfd_section == NULL) - init_os (output, flags); - - /* If SEC_READONLY is not set in the input section, then clear - it from the output section. */ - output->bfd_section->flags &= flags | ~SEC_READONLY; - - if (output->bfd_section->linker_has_input) - { - /* Only set SEC_READONLY flag on the first input section. */ - flags &= ~ SEC_READONLY; - - /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */ - if ((output->bfd_section->flags & (SEC_MERGE | SEC_STRINGS)) - != (flags & (SEC_MERGE | SEC_STRINGS)) - || ((flags & SEC_MERGE) != 0 - && output->bfd_section->entsize != section->entsize)) - { - output->bfd_section->flags &= ~ (SEC_MERGE | SEC_STRINGS); - flags &= ~ (SEC_MERGE | SEC_STRINGS); - } - } - output->bfd_section->flags |= flags; - - if (!output->bfd_section->linker_has_input) - { - output->bfd_section->linker_has_input = 1; - /* This must happen after flags have been updated. The output - section may have been created before we saw its first input - section, eg. for a data statement. */ - bfd_init_private_section_data (section->owner, section, - link_info.output_bfd, - output->bfd_section, - &link_info); - if ((flags & SEC_MERGE) != 0) - output->bfd_section->entsize = section->entsize; - } - - if ((flags & SEC_TIC54X_BLOCK) != 0 - && bfd_get_arch (section->owner) == bfd_arch_tic54x) - { - /* FIXME: This value should really be obtained from the bfd... */ - output->block_value = 128; - } - - if (section->alignment_power > output->bfd_section->alignment_power) - output->bfd_section->alignment_power = section->alignment_power; - - section->output_section = output->bfd_section; - - if (!map_head_is_link_order) - { - asection *s = output->bfd_section->map_tail.s; - output->bfd_section->map_tail.s = section; - section->map_head.s = NULL; - section->map_tail.s = s; - if (s != NULL) - s->map_head.s = section; - else - output->bfd_section->map_head.s = section; - } - - /* Add a section reference to the list. */ - new_section = new_stat (lang_input_section, ptr); - new_section->section = section; -} - -/* Handle wildcard sorting. This returns the lang_input_section which - should follow the one we are going to create for SECTION and FILE, - based on the sorting requirements of WILD. It returns NULL if the - new section should just go at the end of the current list. */ - -static lang_statement_union_type * -wild_sort (lang_wild_statement_type *wild, - struct wildcard_list *sec, - lang_input_statement_type *file, - asection *section) -{ - lang_statement_union_type *l; - - if (!wild->filenames_sorted - && (sec == NULL || sec->spec.sorted == none)) - return NULL; - - for (l = wild->children.head; l != NULL; l = l->header.next) - { - lang_input_section_type *ls; - - if (l->header.type != lang_input_section_enum) - continue; - ls = &l->input_section; - - /* Sorting by filename takes precedence over sorting by section - name. */ - - if (wild->filenames_sorted) - { - const char *fn, *ln; - bfd_boolean fa, la; - 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. */ - - if (file->the_bfd != NULL - && file->the_bfd->my_archive != NULL) - { - fn = bfd_get_filename (file->the_bfd->my_archive); - fa = TRUE; - } - else - { - fn = file->filename; - fa = FALSE; - } - - if (ls->section->owner->my_archive != NULL) - { - ln = bfd_get_filename (ls->section->owner->my_archive); - la = TRUE; - } - else - { - ln = ls->section->owner->filename; - la = FALSE; - } - - i = filename_cmp (fn, ln); - if (i > 0) - continue; - else if (i < 0) - break; - - if (fa || la) - { - if (fa) - fn = file->filename; - if (la) - ln = ls->section->owner->filename; - - i = filename_cmp (fn, ln); - if (i > 0) - continue; - else if (i < 0) - break; - } - } - - /* Here either the files are not sorted by name, or we are - looking at the sections for this file. */ - - if (sec != NULL - && sec->spec.sorted != none - && sec->spec.sorted != by_none) - if (compare_section (sec->spec.sorted, section, ls->section) < 0) - break; - } - - return l; -} - -/* Expand a wild statement for a particular FILE. SECTION may be - NULL, in which case it is a wild card. */ - -static void -output_section_callback (lang_wild_statement_type *ptr, - struct wildcard_list *sec, - asection *section, - struct flag_info *sflag_info, - lang_input_statement_type *file, - void *output) -{ - lang_statement_union_type *before; - lang_output_section_statement_type *os; - - os = (lang_output_section_statement_type *) output; - - /* Exclude sections that match UNIQUE_SECTION_LIST. */ - if (unique_section_p (section, os)) - return; - - before = wild_sort (ptr, sec, file, section); - - /* Here BEFORE points to the lang_input_section which - should follow the one we are about to add. If BEFORE - is NULL, then the section should just go at the end - of the current list. */ - - if (before == NULL) - lang_add_section (&ptr->children, section, sflag_info, os); - else - { - lang_statement_list_type list; - lang_statement_union_type **pp; - - lang_list_init (&list); - lang_add_section (&list, section, sflag_info, os); - - /* If we are discarding the section, LIST.HEAD will - be NULL. */ - if (list.head != NULL) - { - ASSERT (list.head->header.next == NULL); - - for (pp = &ptr->children.head; - *pp != before; - pp = &(*pp)->header.next) - ASSERT (*pp != NULL); - - list.head->header.next = *pp; - *pp = list.head; - } - } -} - -/* Check if all sections in a wild statement for a particular FILE - are readonly. */ - -static void -check_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED, - struct wildcard_list *sec ATTRIBUTE_UNUSED, - asection *section, - struct flag_info *sflag_info ATTRIBUTE_UNUSED, - lang_input_statement_type *file ATTRIBUTE_UNUSED, - void *output) -{ - lang_output_section_statement_type *os; - - os = (lang_output_section_statement_type *) output; - - /* Exclude sections that match UNIQUE_SECTION_LIST. */ - if (unique_section_p (section, os)) - return; - - if (section->output_section == NULL && (section->flags & SEC_READONLY) == 0) - os->all_input_readonly = FALSE; -} - -/* This is passed a file name which must have been seen already and - added to the statement tree. We will see if it has been opened - already and had its symbols read. If not then we'll read it. */ - -static lang_input_statement_type * -lookup_name (const char *name) -{ - lang_input_statement_type *search; - - for (search = (lang_input_statement_type *) input_file_chain.head; - search != NULL; - search = (lang_input_statement_type *) search->next_real_file) - { - /* Use the local_sym_name as the name of the file that has - already been loaded as filename might have been transformed - via the search directory lookup mechanism. */ - const char *filename = search->local_sym_name; - - if (filename != NULL - && filename_cmp (filename, name) == 0) - break; - } - - if (search == NULL) - search = new_afile (name, lang_input_file_is_search_file_enum, - default_target, FALSE); - - /* If we have already added this file, or this file is not real - don't add this file. */ - if (search->flags.loaded || !search->flags.real) - return search; - - if (!load_symbols (search, NULL)) - return NULL; - - return search; -} - -/* Save LIST as a list of libraries whose symbols should not be exported. */ - -struct excluded_lib -{ - char *name; - struct excluded_lib *next; -}; -static struct excluded_lib *excluded_libs; - -void -add_excluded_libs (const char *list) -{ - const char *p = list, *end; - - while (*p != '\0') - { - struct excluded_lib *entry; - end = strpbrk (p, ",:"); - if (end == NULL) - end = p + strlen (p); - entry = (struct excluded_lib *) xmalloc (sizeof (*entry)); - entry->next = excluded_libs; - entry->name = (char *) xmalloc (end - p + 1); - memcpy (entry->name, p, end - p); - entry->name[end - p] = '\0'; - excluded_libs = entry; - if (*end == '\0') - break; - p = end + 1; - } -} - -static void -check_excluded_libs (bfd *abfd) -{ - struct excluded_lib *lib = excluded_libs; - - while (lib) - { - int len = strlen (lib->name); - const char *filename = lbasename (abfd->filename); - - if (strcmp (lib->name, "ALL") == 0) - { - abfd->no_export = TRUE; - return; - } - - if (filename_ncmp (lib->name, filename, len) == 0 - && (filename[len] == '\0' - || (filename[len] == '.' && filename[len + 1] == 'a' - && filename[len + 2] == '\0'))) - { - abfd->no_export = TRUE; - return; - } - - lib = lib->next; - } -} - -/* Get the symbols for an input file. */ - -bfd_boolean -load_symbols (lang_input_statement_type *entry, - lang_statement_list_type *place) -{ - char **matching; - - if (entry->flags.loaded) - return TRUE; - - ldfile_open_file (entry); - - /* Do not process further if the file was missing. */ - if (entry->flags.missing_file) - return TRUE; - - if (!bfd_check_format (entry->the_bfd, bfd_archive) - && !bfd_check_format_matches (entry->the_bfd, bfd_object, &matching)) - { - bfd_error_type err; - struct lang_input_statement_flags save_flags; - extern FILE *yyin; - - err = bfd_get_error (); - - /* See if the emulation has some special knowledge. */ - if (ldemul_unrecognized_file (entry)) - return TRUE; - - if (err == bfd_error_file_ambiguously_recognized) - { - char **p; - - einfo (_("%B: file not recognized: %E\n"), entry->the_bfd); - einfo (_("%B: matching formats:"), entry->the_bfd); - for (p = matching; *p != NULL; p++) - einfo (" %s", *p); - einfo ("%F\n"); - } - else if (err != bfd_error_file_not_recognized - || place == NULL) - einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd); - - bfd_close (entry->the_bfd); - entry->the_bfd = NULL; - - /* Try to interpret the file as a linker script. */ - save_flags = input_flags; - ldfile_open_command_file (entry->filename); - - push_stat_ptr (place); - input_flags.add_DT_NEEDED_for_regular - = entry->flags.add_DT_NEEDED_for_regular; - input_flags.add_DT_NEEDED_for_dynamic - = entry->flags.add_DT_NEEDED_for_dynamic; - input_flags.whole_archive = entry->flags.whole_archive; - input_flags.dynamic = entry->flags.dynamic; - - ldfile_assumed_script = TRUE; - parser_input = input_script; - yyparse (); - ldfile_assumed_script = FALSE; - - /* missing_file is sticky. sysrooted will already have been - restored when seeing EOF in yyparse, but no harm to restore - again. */ - save_flags.missing_file |= input_flags.missing_file; - input_flags = save_flags; - pop_stat_ptr (); - fclose (yyin); - yyin = NULL; - entry->flags.loaded = TRUE; - - return TRUE; - } - - if (ldemul_recognized_file (entry)) - return TRUE; - - /* We don't call ldlang_add_file for an archive. Instead, the - add_symbols entry point will call ldlang_add_file, via the - add_archive_element callback, for each element of the archive - which is used. */ - switch (bfd_get_format (entry->the_bfd)) - { - default: - break; - - case bfd_object: - if (!entry->flags.reload) - ldlang_add_file (entry); - if (trace_files || verbose) - info_msg ("%I\n", entry); - break; - - case bfd_archive: - check_excluded_libs (entry->the_bfd); - - entry->the_bfd->usrdata = entry; - if (entry->flags.whole_archive) - { - bfd *member = NULL; - bfd_boolean loaded = TRUE; - - for (;;) - { - bfd *subsbfd; - member = bfd_openr_next_archived_file (entry->the_bfd, member); - - if (member == NULL) - break; - - if (!bfd_check_format (member, bfd_object)) - { - einfo (_("%F%B: member %B in archive is not an object\n"), - entry->the_bfd, member); - loaded = FALSE; - } - - subsbfd = member; - if (!(*link_info.callbacks - ->add_archive_element) (&link_info, member, - "--whole-archive", &subsbfd)) - abort (); - - /* Potentially, the add_archive_element hook may have set a - substitute BFD for us. */ - if (!bfd_link_add_symbols (subsbfd, &link_info)) - { - einfo (_("%F%B: error adding symbols: %E\n"), member); - loaded = FALSE; - } - } - - entry->flags.loaded = loaded; - return loaded; - } - break; - } - - if (bfd_link_add_symbols (entry->the_bfd, &link_info)) - entry->flags.loaded = TRUE; - else - einfo (_("%F%B: error adding symbols: %E\n"), entry->the_bfd); - - return entry->flags.loaded; -} - -/* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both - may be NULL, indicating that it is a wildcard. Separate - lang_input_section statements are created for each part of the - expansion; they are added after the wild statement S. OUTPUT is - the output section. */ - -static void -wild (lang_wild_statement_type *s, - const char *target ATTRIBUTE_UNUSED, - lang_output_section_statement_type *output) -{ - struct wildcard_list *sec; - - if (s->handler_data[0] - && s->handler_data[0]->spec.sorted == by_name - && !s->filenames_sorted) - { - lang_section_bst_type *tree; - - walk_wild (s, output_section_callback_fast, output); - - tree = s->tree; - if (tree) - { - output_section_callback_tree_to_list (s, tree, output); - s->tree = NULL; - } - } - else - walk_wild (s, output_section_callback, output); - - if (default_common_section == NULL) - for (sec = s->section_list; sec != NULL; sec = sec->next) - if (sec->spec.name != NULL && strcmp (sec->spec.name, "COMMON") == 0) - { - /* Remember the section that common is going to in case we - later get something which doesn't know where to put it. */ - default_common_section = output; - break; - } -} - -/* Return TRUE iff target is the sought target. */ - -static int -get_target (const bfd_target *target, void *data) -{ - const char *sought = (const char *) data; - - return strcmp (target->name, sought) == 0; -} - -/* Like strcpy() but convert to lower case as well. */ - -static void -stricpy (char *dest, char *src) -{ - char c; - - while ((c = *src++) != 0) - *dest++ = TOLOWER (c); - - *dest = 0; -} - -/* Remove the first occurrence of needle (if any) in haystack - from haystack. */ - -static void -strcut (char *haystack, char *needle) -{ - haystack = strstr (haystack, needle); - - if (haystack) - { - char *src; - - for (src = haystack + strlen (needle); *src;) - *haystack++ = *src++; - - *haystack = 0; - } -} - -/* Compare two target format name strings. - Return a value indicating how "similar" they are. */ - -static int -name_compare (char *first, char *second) -{ - char *copy1; - char *copy2; - int result; - - copy1 = (char *) xmalloc (strlen (first) + 1); - copy2 = (char *) xmalloc (strlen (second) + 1); - - /* Convert the names to lower case. */ - stricpy (copy1, first); - stricpy (copy2, second); - - /* Remove size and endian strings from the name. */ - strcut (copy1, "big"); - strcut (copy1, "little"); - strcut (copy2, "big"); - strcut (copy2, "little"); - - /* Return a value based on how many characters match, - starting from the beginning. If both strings are - the same then return 10 * their length. */ - for (result = 0; copy1[result] == copy2[result]; result++) - if (copy1[result] == 0) - { - result *= 10; - break; - } - - free (copy1); - free (copy2); - - return result; -} - -/* Set by closest_target_match() below. */ -static const bfd_target *winner; - -/* Scan all the valid bfd targets looking for one that has the endianness - requirement that was specified on the command line, and is the nearest - match to the original output target. */ - -static int -closest_target_match (const bfd_target *target, void *data) -{ - const bfd_target *original = (const bfd_target *) data; - - if (command_line.endian == ENDIAN_BIG - && target->byteorder != BFD_ENDIAN_BIG) - return 0; - - if (command_line.endian == ENDIAN_LITTLE - && target->byteorder != BFD_ENDIAN_LITTLE) - return 0; - - /* Must be the same flavour. */ - if (target->flavour != original->flavour) - return 0; - - /* Ignore generic big and little endian elf vectors. */ - if (strcmp (target->name, "elf32-big") == 0 - || strcmp (target->name, "elf64-big") == 0 - || strcmp (target->name, "elf32-little") == 0 - || strcmp (target->name, "elf64-little") == 0) - return 0; - - /* If we have not found a potential winner yet, then record this one. */ - if (winner == NULL) - { - winner = target; - return 0; - } - - /* Oh dear, we now have two potential candidates for a successful match. - Compare their names and choose the better one. */ - if (name_compare (target->name, original->name) - > name_compare (winner->name, original->name)) - winner = target; - - /* Keep on searching until wqe have checked them all. */ - return 0; -} - -/* Return the BFD target format of the first input file. */ - -static char * -get_first_input_target (void) -{ - char *target = NULL; - - LANG_FOR_EACH_INPUT_STATEMENT (s) - { - if (s->header.type == lang_input_statement_enum - && s->flags.real) - { - ldfile_open_file (s); - - if (s->the_bfd != NULL - && bfd_check_format (s->the_bfd, bfd_object)) - { - target = bfd_get_target (s->the_bfd); - - if (target != NULL) - break; - } - } - } - - return target; -} - -const char * -lang_get_output_target (void) -{ - const char *target; - - /* Has the user told us which output format to use? */ - if (output_target != NULL) - return output_target; - - /* No - has the current target been set to something other than - the default? */ - if (current_target != default_target && current_target != NULL) - return current_target; - - /* No - can we determine the format of the first input file? */ - target = get_first_input_target (); - if (target != NULL) - return target; - - /* Failed - use the default output target. */ - return default_target; -} - -/* Open the output file. */ - -static void -open_output (const char *name) -{ - output_target = lang_get_output_target (); - - /* Has the user requested a particular endianness on the command - line? */ - if (command_line.endian != ENDIAN_UNSET) - { - /* Get the chosen target. */ - const bfd_target *target - = bfd_iterate_over_targets (get_target, (void *) output_target); - - /* If the target is not supported, we cannot do anything. */ - if (target != NULL) - { - enum bfd_endian desired_endian; - - if (command_line.endian == ENDIAN_BIG) - desired_endian = BFD_ENDIAN_BIG; - else - desired_endian = BFD_ENDIAN_LITTLE; - - /* See if the target has the wrong endianness. This should - not happen if the linker script has provided big and - little endian alternatives, but some scrips don't do - this. */ - if (target->byteorder != desired_endian) - { - /* If it does, then see if the target provides - an alternative with the correct endianness. */ - if (target->alternative_target != NULL - && (target->alternative_target->byteorder == desired_endian)) - output_target = target->alternative_target->name; - else - { - /* Try to find a target as similar as possible to - the default target, but which has the desired - endian characteristic. */ - bfd_iterate_over_targets (closest_target_match, - (void *) target); - - /* Oh dear - we could not find any targets that - satisfy our requirements. */ - if (winner == NULL) - einfo (_("%P: warning: could not find any targets" - " that match endianness requirement\n")); - else - output_target = winner->name; - } - } - } - } - - link_info.output_bfd = bfd_openw (name, output_target); - - if (link_info.output_bfd == NULL) - { - if (bfd_get_error () == bfd_error_invalid_target) - einfo (_("%P%F: target %s not found\n"), output_target); - - einfo (_("%P%F: cannot open output file %s: %E\n"), name); - } - - delete_output_file_on_failure = TRUE; - - if (!bfd_set_format (link_info.output_bfd, bfd_object)) - einfo (_("%P%F:%s: can not make object file: %E\n"), name); - if (!bfd_set_arch_mach (link_info.output_bfd, - ldfile_output_architecture, - ldfile_output_machine)) - einfo (_("%P%F:%s: can not set architecture: %E\n"), name); - - link_info.hash = bfd_link_hash_table_create (link_info.output_bfd); - if (link_info.hash == NULL) - einfo (_("%P%F: can not create hash table: %E\n")); - - bfd_set_gp_size (link_info.output_bfd, g_switch_value); -} - -static void -ldlang_open_output (lang_statement_union_type *statement) -{ - switch (statement->header.type) - { - case lang_output_statement_enum: - ASSERT (link_info.output_bfd == NULL); - open_output (statement->output_statement.name); - ldemul_set_output_arch (); - if (config.magic_demand_paged - && !bfd_link_relocatable (&link_info)) - link_info.output_bfd->flags |= D_PAGED; - else - link_info.output_bfd->flags &= ~D_PAGED; - if (config.text_read_only) - link_info.output_bfd->flags |= WP_TEXT; - else - link_info.output_bfd->flags &= ~WP_TEXT; - if (link_info.traditional_format) - link_info.output_bfd->flags |= BFD_TRADITIONAL_FORMAT; - else - link_info.output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT; - break; - - case lang_target_statement_enum: - current_target = statement->target_statement.target; - break; - default: - break; - } -} - -static void -init_opb (void) -{ - unsigned x = bfd_arch_mach_octets_per_byte (ldfile_output_architecture, - ldfile_output_machine); - opb_shift = 0; - if (x > 1) - while ((x & 1) == 0) - { - x >>= 1; - ++opb_shift; - } - ASSERT (x == 1); -} - -/* Open all the input files. */ - -enum open_bfd_mode - { - OPEN_BFD_NORMAL = 0, - OPEN_BFD_FORCE = 1, - OPEN_BFD_RESCAN = 2 - }; -#ifdef ENABLE_PLUGINS -static lang_input_statement_type *plugin_insert = NULL; -#endif - -static void -open_input_bfds (lang_statement_union_type *s, enum open_bfd_mode mode) -{ - for (; s != NULL; s = s->header.next) - { - switch (s->header.type) - { - case lang_constructors_statement_enum: - open_input_bfds (constructor_list.head, mode); - break; - case lang_output_section_statement_enum: - open_input_bfds (s->output_section_statement.children.head, mode); - break; - case lang_wild_statement_enum: - /* Maybe we should load the file's symbols. */ - if ((mode & OPEN_BFD_RESCAN) == 0 - && s->wild_statement.filename - && !wildcardp (s->wild_statement.filename) - && !archive_path (s->wild_statement.filename)) - lookup_name (s->wild_statement.filename); - open_input_bfds (s->wild_statement.children.head, mode); - break; - case lang_group_statement_enum: - { - struct bfd_link_hash_entry *undefs; - - /* We must continually search the entries in the group - until no new symbols are added to the list of undefined - symbols. */ - - do - { - undefs = link_info.hash->undefs_tail; - open_input_bfds (s->group_statement.children.head, - mode | OPEN_BFD_FORCE); - } - while (undefs != link_info.hash->undefs_tail); - } - break; - case lang_target_statement_enum: - current_target = s->target_statement.target; - break; - case lang_input_statement_enum: - if (s->input_statement.flags.real) - { - lang_statement_union_type **os_tail; - lang_statement_list_type add; - bfd *abfd; - - 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 - has been loaded already. Do the same for a rescan. - Likewise reload --as-needed shared libs. */ - if (mode != OPEN_BFD_NORMAL -#ifdef ENABLE_PLUGINS - && ((mode & OPEN_BFD_RESCAN) == 0 - || plugin_insert == NULL) -#endif - && s->input_statement.flags.loaded - && (abfd = s->input_statement.the_bfd) != NULL - && ((bfd_get_format (abfd) == bfd_archive - && !s->input_statement.flags.whole_archive) - || (bfd_get_format (abfd) == bfd_object - && ((abfd->flags) & DYNAMIC) != 0 - && s->input_statement.flags.add_DT_NEEDED_for_regular - && bfd_get_flavour (abfd) == bfd_target_elf_flavour - && (elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0))) - { - s->input_statement.flags.loaded = FALSE; - s->input_statement.flags.reload = TRUE; - } - - os_tail = lang_output_section_statement.tail; - lang_list_init (&add); - - if (!load_symbols (&s->input_statement, &add)) - config.make_executable = FALSE; - - if (add.head != NULL) - { - /* If this was a script with output sections then - tack any added statements on to the end of the - list. This avoids having to reorder the output - section statement list. Very likely the user - forgot -T, and whatever we do here will not meet - naive user expectations. */ - if (os_tail != lang_output_section_statement.tail) - { - einfo (_("%P: warning: %s contains output sections;" - " did you forget -T?\n"), - s->input_statement.filename); - *stat_ptr->tail = add.head; - stat_ptr->tail = add.tail; - } - else - { - *add.tail = s->header.next; - s->header.next = add.head; - } - } - } -#ifdef ENABLE_PLUGINS - /* If we have found the point at which a plugin added new - files, clear plugin_insert to enable archive rescan. */ - if (&s->input_statement == plugin_insert) - plugin_insert = NULL; -#endif - break; - case lang_assignment_statement_enum: - if (s->assignment_statement.exp->type.node_class != etree_assert) - exp_fold_tree_no_dot (s->assignment_statement.exp); - break; - default: - break; - } - } - - /* Exit if any of the files were missing. */ - if (input_flags.missing_file) - einfo ("%F"); -} - -/* Add the supplied name to the symbol table as an undefined reference. - This is a two step process as the symbol table doesn't even exist at - the time the ld command line is processed. First we put the name - on a list, then, once the output file has been opened, transfer the - name to the symbol table. */ - -typedef struct bfd_sym_chain ldlang_undef_chain_list_type; - -#define ldlang_undef_chain_list_head entry_symbol.next - -void -ldlang_add_undef (const char *const name, bfd_boolean cmdline) -{ - ldlang_undef_chain_list_type *new_undef; - - undef_from_cmdline = undef_from_cmdline || cmdline; - new_undef = (ldlang_undef_chain_list_type *) stat_alloc (sizeof (*new_undef)); - new_undef->next = ldlang_undef_chain_list_head; - ldlang_undef_chain_list_head = new_undef; - - new_undef->name = xstrdup (name); - - if (link_info.output_bfd != NULL) - insert_undefined (new_undef->name); -} - -/* Insert NAME as undefined in the symbol table. */ - -static void -insert_undefined (const char *name) -{ - struct bfd_link_hash_entry *h; - - h = bfd_link_hash_lookup (link_info.hash, name, TRUE, FALSE, TRUE); - if (h == NULL) - einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n")); - if (h->type == bfd_link_hash_new) - { - h->type = bfd_link_hash_undefined; - h->u.undef.abfd = NULL; - if (is_elf_hash_table (link_info.hash)) - ((struct elf_link_hash_entry *) h)->mark = 1; - bfd_link_add_undef (link_info.hash, h); - } -} - -/* Run through the list of undefineds created above and place them - into the linker hash table as undefined symbols belonging to the - script file. */ - -static void -lang_place_undefineds (void) -{ - ldlang_undef_chain_list_type *ptr; - - for (ptr = ldlang_undef_chain_list_head; ptr != NULL; ptr = ptr->next) - insert_undefined (ptr->name); -} - -/* Structure used to build the list of symbols that the user has required - be defined. */ - -struct require_defined_symbol -{ - const char *name; - struct require_defined_symbol *next; -}; - -/* The list of symbols that the user has required be defined. */ - -static struct require_defined_symbol *require_defined_symbol_list; - -/* Add a new symbol NAME to the list of symbols that are required to be - defined. */ - -void -ldlang_add_require_defined (const char *const name) -{ - struct require_defined_symbol *ptr; - - ldlang_add_undef (name, TRUE); - ptr = (struct require_defined_symbol *) stat_alloc (sizeof (*ptr)); - ptr->next = require_defined_symbol_list; - ptr->name = strdup (name); - require_defined_symbol_list = ptr; -} - -/* Check that all symbols the user required to be defined, are defined, - raise an error if we find a symbol that is not defined. */ - -static void -ldlang_check_require_defined_symbols (void) -{ - struct require_defined_symbol *ptr; - - for (ptr = require_defined_symbol_list; ptr != NULL; ptr = ptr->next) - { - struct bfd_link_hash_entry *h; - - h = bfd_link_hash_lookup (link_info.hash, ptr->name, - FALSE, FALSE, TRUE); - if (h == NULL - || (h->type != bfd_link_hash_defined - && h->type != bfd_link_hash_defweak)) - einfo(_("%P%X: required symbol `%s' not defined\n"), ptr->name); - } -} - -/* Check for all readonly or some readwrite sections. */ - -static void -check_input_sections - (lang_statement_union_type *s, - lang_output_section_statement_type *output_section_statement) -{ - for (; s != (lang_statement_union_type *) NULL; s = s->header.next) - { - switch (s->header.type) - { - case lang_wild_statement_enum: - walk_wild (&s->wild_statement, check_section_callback, - output_section_statement); - if (!output_section_statement->all_input_readonly) - return; - break; - case lang_constructors_statement_enum: - check_input_sections (constructor_list.head, - output_section_statement); - if (!output_section_statement->all_input_readonly) - return; - break; - case lang_group_statement_enum: - check_input_sections (s->group_statement.children.head, - output_section_statement); - if (!output_section_statement->all_input_readonly) - return; - break; - default: - break; - } - } -} - -/* Update wildcard statements if needed. */ - -static void -update_wild_statements (lang_statement_union_type *s) -{ - struct wildcard_list *sec; - - switch (sort_section) - { - default: - FAIL (); - - case none: - break; - - case by_name: - case by_alignment: - for (; s != NULL; s = s->header.next) - { - switch (s->header.type) - { - default: - break; - - case lang_wild_statement_enum: - for (sec = s->wild_statement.section_list; sec != NULL; - sec = sec->next) - { - switch (sec->spec.sorted) - { - case none: - sec->spec.sorted = sort_section; - break; - case by_name: - if (sort_section == by_alignment) - sec->spec.sorted = by_name_alignment; - break; - case by_alignment: - if (sort_section == by_name) - sec->spec.sorted = by_alignment_name; - break; - default: - break; - } - } - break; - - case lang_constructors_statement_enum: - update_wild_statements (constructor_list.head); - break; - - case lang_output_section_statement_enum: - /* Don't sort .init/.fini sections. */ - if (strcmp (s->output_section_statement.name, ".init") != 0 - && strcmp (s->output_section_statement.name, ".fini") != 0) - update_wild_statements - (s->output_section_statement.children.head); - break; - - case lang_group_statement_enum: - update_wild_statements (s->group_statement.children.head); - break; - } - } - break; - } -} - -/* Open input files and attach to output sections. */ - -static void -map_input_to_output_sections - (lang_statement_union_type *s, const char *target, - lang_output_section_statement_type *os) -{ - for (; s != NULL; s = s->header.next) - { - lang_output_section_statement_type *tos; - flagword flags; - - switch (s->header.type) - { - case lang_wild_statement_enum: - wild (&s->wild_statement, target, os); - break; - case lang_constructors_statement_enum: - map_input_to_output_sections (constructor_list.head, - target, - os); - break; - case lang_output_section_statement_enum: - tos = &s->output_section_statement; - if (tos->constraint != 0) - { - if (tos->constraint != ONLY_IF_RW - && tos->constraint != ONLY_IF_RO) - break; - tos->all_input_readonly = TRUE; - check_input_sections (tos->children.head, tos); - if (tos->all_input_readonly != (tos->constraint == ONLY_IF_RO)) - { - tos->constraint = -1; - break; - } - } - map_input_to_output_sections (tos->children.head, - target, - tos); - break; - case lang_output_statement_enum: - break; - case lang_target_statement_enum: - target = s->target_statement.target; - break; - case lang_group_statement_enum: - map_input_to_output_sections (s->group_statement.children.head, - target, - 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); - /* The output section gets CONTENTS, ALLOC and LOAD, but - these may be overridden by the script. */ - flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD; - switch (os->sectype) - { - case normal_section: - case overlay_section: - break; - case noalloc_section: - flags = SEC_HAS_CONTENTS; - break; - case noload_section: - if (bfd_get_flavour (link_info.output_bfd) - == bfd_target_elf_flavour) - flags = SEC_NEVER_LOAD | SEC_ALLOC; - else - flags = SEC_NEVER_LOAD | SEC_HAS_CONTENTS; - break; - } - if (os->bfd_section == NULL) - init_os (os, flags); - else - os->bfd_section->flags |= flags; - break; - case lang_input_section_enum: - break; - case lang_fill_statement_enum: - case lang_object_symbols_statement_enum: - case lang_reloc_statement_enum: - case lang_padding_statement_enum: - case lang_input_statement_enum: - if (os != NULL && os->bfd_section == NULL) - init_os (os, 0); - break; - case lang_assignment_statement_enum: - if (os != NULL && os->bfd_section == NULL) - init_os (os, 0); - - /* Make sure that any sections mentioned in the assignment - are initialized. */ - exp_init_os (s->assignment_statement.exp); - break; - case lang_address_statement_enum: - /* Mark the specified section with the supplied address. - If this section was actually a segment marker, then the - directive is ignored if the linker script explicitly - processed the segment marker. Originally, the linker - treated segment directives (like -Ttext on the - command-line) as section directives. We honor the - section directive semantics for backwards compatibility; - linker scripts that do not specifically check for - SEGMENT_START automatically get the old semantics. */ - if (!s->address_statement.segment - || !s->address_statement.segment->used) - { - const char *name = s->address_statement.section_name; - - /* Create the output section statement here so that - orphans with a set address will be placed after other - script sections. If we let the orphan placement code - place them in amongst other sections then the address - will affect following script sections, which is - likely to surprise naive users. */ - tos = lang_output_section_statement_lookup (name, 0, TRUE); - tos->addr_tree = s->address_statement.address; - if (tos->bfd_section == NULL) - init_os (tos, 0); - } - break; - case lang_insert_statement_enum: - break; - } - } -} - -/* An insert statement snips out all the linker statements from the - start of the list and places them after the output section - statement specified by the insert. This operation is complicated - by the fact that we keep a doubly linked list of output section - statements as well as the singly linked list of all statements. */ - -static void -process_insert_statements (void) -{ - lang_statement_union_type **s; - lang_output_section_statement_type *first_os = NULL; - lang_output_section_statement_type *last_os = NULL; - lang_output_section_statement_type *os; - - /* "start of list" is actually the statement immediately after - the special abs_section output statement, so that it isn't - reordered. */ - s = &lang_output_section_statement.head; - while (*(s = &(*s)->header.next) != NULL) - { - if ((*s)->header.type == lang_output_section_statement_enum) - { - /* Keep pointers to the first and last output section - statement in the sequence we may be about to move. */ - os = &(*s)->output_section_statement; - - ASSERT (last_os == NULL || last_os->next == os); - last_os = os; - - /* Set constraint negative so that lang_output_section_find - won't match this output section statement. At this - stage in linking constraint has values in the range - [-1, ONLY_IN_RW]. */ - last_os->constraint = -2 - last_os->constraint; - if (first_os == NULL) - first_os = last_os; - } - else if ((*s)->header.type == lang_insert_statement_enum) - { - lang_insert_statement_type *i = &(*s)->insert_statement; - lang_output_section_statement_type *where; - lang_statement_union_type **ptr; - lang_statement_union_type *first; - - where = lang_output_section_find (i->where); - if (where != NULL && i->is_before) - { - do - where = where->prev; - while (where != NULL && where->constraint < 0); - } - if (where == NULL) - { - einfo (_("%F%P: %s not found for insert\n"), i->where); - return; - } - - /* Deal with reordering the output section statement list. */ - if (last_os != NULL) - { - asection *first_sec, *last_sec; - struct lang_output_section_statement_struct **next; - - /* Snip out the output sections we are moving. */ - first_os->prev->next = last_os->next; - if (last_os->next == NULL) - { - next = &first_os->prev->next; - lang_output_section_statement.tail - = (lang_statement_union_type **) next; - } - else - last_os->next->prev = first_os->prev; - /* Add them in at the new position. */ - last_os->next = where->next; - if (where->next == NULL) - { - next = &last_os->next; - lang_output_section_statement.tail - = (lang_statement_union_type **) next; - } - else - where->next->prev = last_os; - first_os->prev = where; - where->next = first_os; - - /* Move the bfd sections in the same way. */ - first_sec = NULL; - last_sec = NULL; - for (os = first_os; os != NULL; os = os->next) - { - os->constraint = -2 - os->constraint; - if (os->bfd_section != NULL - && os->bfd_section->owner != NULL) - { - last_sec = os->bfd_section; - if (first_sec == NULL) - first_sec = last_sec; - } - if (os == last_os) - break; - } - if (last_sec != NULL) - { - asection *sec = where->bfd_section; - if (sec == NULL) - sec = output_prev_sec_find (where); - - /* The place we want to insert must come after the - sections we are moving. So if we find no - section or if the section is the same as our - last section, then no move is needed. */ - if (sec != NULL && sec != last_sec) - { - /* Trim them off. */ - if (first_sec->prev != NULL) - first_sec->prev->next = last_sec->next; - else - link_info.output_bfd->sections = last_sec->next; - if (last_sec->next != NULL) - last_sec->next->prev = first_sec->prev; - else - link_info.output_bfd->section_last = first_sec->prev; - /* Add back. */ - last_sec->next = sec->next; - if (sec->next != NULL) - sec->next->prev = last_sec; - else - link_info.output_bfd->section_last = last_sec; - first_sec->prev = sec; - sec->next = first_sec; - } - } - - first_os = NULL; - last_os = NULL; - } - - ptr = insert_os_after (where); - /* Snip everything after the abs_section output statement we - know is at the start of the list, up to and including - the insert statement we are currently processing. */ - first = lang_output_section_statement.head->header.next; - lang_output_section_statement.head->header.next = (*s)->header.next; - /* Add them back where they belong. */ - *s = *ptr; - if (*s == NULL) - statement_list.tail = s; - *ptr = first; - s = &lang_output_section_statement.head; - } - } - - /* Undo constraint twiddling. */ - for (os = first_os; os != NULL; os = os->next) - { - os->constraint = -2 - os->constraint; - if (os == last_os) - break; - } -} - -/* An output section might have been removed after its statement was - added. For example, ldemul_before_allocation can remove dynamic - sections if they turn out to be not needed. Clean them up here. */ - -void -strip_excluded_output_sections (void) -{ - lang_output_section_statement_type *os; - - /* Run lang_size_sections (if not already done). */ - if (expld.phase != lang_mark_phase_enum) - { - expld.phase = lang_mark_phase_enum; - expld.dataseg.phase = exp_seg_none; - one_lang_size_sections_pass (NULL, FALSE); - lang_reset_memory_regions (); - } - - for (os = &lang_output_section_statement.head->output_section_statement; - os != NULL; - os = os->next) - { - asection *output_section; - bfd_boolean exclude; - - if (os->constraint < 0) - continue; - - output_section = os->bfd_section; - if (output_section == NULL) - continue; - - exclude = (output_section->rawsize == 0 - && (output_section->flags & SEC_KEEP) == 0 - && !bfd_section_removed_from_list (link_info.output_bfd, - output_section)); - - /* Some sections have not yet been sized, notably .gnu.version, - .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED - input sections, so don't drop output sections that have such - input sections unless they are also marked SEC_EXCLUDE. */ - if (exclude && output_section->map_head.s != NULL) - { - asection *s; - - for (s = output_section->map_head.s; s != NULL; s = s->map_head.s) - if ((s->flags & SEC_EXCLUDE) == 0 - && ((s->flags & SEC_LINKER_CREATED) != 0 - || link_info.emitrelocations)) - { - exclude = FALSE; - break; - } - } - - if (exclude) - { - /* We don't set bfd_section to NULL since bfd_section of the - removed output section statement may still be used. */ - if (!os->update_dot) - os->ignored = TRUE; - output_section->flags |= SEC_EXCLUDE; - bfd_section_list_remove (link_info.output_bfd, output_section); - link_info.output_bfd->section_count--; - } - } -} - -/* Called from ldwrite to clear out asection.map_head and - asection.map_tail for use as link_orders in ldwrite. - FIXME: Except for sh64elf.em which starts creating link_orders in - its after_allocation routine so needs to call it early. */ - -void -lang_clear_os_map (void) -{ - lang_output_section_statement_type *os; - - if (map_head_is_link_order) - return; - - for (os = &lang_output_section_statement.head->output_section_statement; - os != NULL; - os = os->next) - { - asection *output_section; - - if (os->constraint < 0) - continue; - - output_section = os->bfd_section; - if (output_section == NULL) - continue; - - /* TODO: Don't just junk map_head.s, turn them into link_orders. */ - output_section->map_head.link_order = NULL; - output_section->map_tail.link_order = NULL; - } - - /* Stop future calls to lang_add_section from messing with map_head - and map_tail link_order fields. */ - map_head_is_link_order = TRUE; -} - -static void -print_output_section_statement - (lang_output_section_statement_type *output_section_statement) -{ - asection *section = output_section_statement->bfd_section; - int len; - - if (output_section_statement != abs_output_section) - { - minfo ("\n%s", output_section_statement->name); - - if (section != NULL) - { - print_dot = section->vma; - - len = strlen (output_section_statement->name); - if (len >= SECTION_NAME_MAP_LENGTH - 1) - { - print_nl (); - len = 0; - } - while (len < SECTION_NAME_MAP_LENGTH) - { - print_space (); - ++len; - } - - minfo ("0x%V %W", section->vma, TO_ADDR (section->size)); - - if (section->vma != section->lma) - minfo (_(" load address 0x%V"), section->lma); - - if (output_section_statement->update_dot_tree != NULL) - exp_fold_tree (output_section_statement->update_dot_tree, - bfd_abs_section_ptr, &print_dot); - } - - print_nl (); - } - - print_statement_list (output_section_statement->children.head, - output_section_statement); -} - -static void -print_assignment (lang_assignment_statement_type *assignment, - lang_output_section_statement_type *output_section) -{ - unsigned int i; - bfd_boolean is_dot; - etree_type *tree; - asection *osec; - - for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++) - print_space (); - - if (assignment->exp->type.node_class == etree_assert) - { - is_dot = FALSE; - tree = assignment->exp->assert_s.child; - } - else - { - const char *dst = assignment->exp->assign.dst; - - is_dot = (dst[0] == '.' && dst[1] == 0); - if (!is_dot) - expld.assign_name = dst; - tree = assignment->exp->assign.src; - } - - osec = output_section->bfd_section; - if (osec == NULL) - osec = bfd_abs_section_ptr; - - if (assignment->exp->type.node_class != etree_provide) - exp_fold_tree (tree, osec, &print_dot); - else - expld.result.valid_p = FALSE; - - if (expld.result.valid_p) - { - bfd_vma value; - - if (assignment->exp->type.node_class == etree_assert - || is_dot - || expld.assign_name != NULL) - { - value = expld.result.value; - - if (expld.result.section != NULL) - value += expld.result.section->vma; - - minfo ("0x%V", value); - if (is_dot) - print_dot = value; - } - else - { - struct bfd_link_hash_entry *h; - - h = bfd_link_hash_lookup (link_info.hash, assignment->exp->assign.dst, - FALSE, FALSE, TRUE); - if (h) - { - value = h->u.def.value; - value += h->u.def.section->output_section->vma; - value += h->u.def.section->output_offset; - - minfo ("[0x%V]", value); - } - else - minfo ("[unresolved]"); - } - } - else - { - if (assignment->exp->type.node_class == etree_provide) - minfo ("[!provide]"); - else - minfo ("*undef* "); -#ifdef BFD64 - minfo (" "); -#endif - } - expld.assign_name = NULL; - - minfo (" "); - exp_print_tree (assignment->exp); - print_nl (); -} - -static void -print_input_statement (lang_input_statement_type *statm) -{ - if (statm->filename != NULL - && (statm->the_bfd == NULL - || (statm->the_bfd->flags & BFD_LINKER_CREATED) == 0)) - fprintf (config.map_file, "LOAD %s\n", statm->filename); -} - -/* Print all symbols defined in a particular section. This is called - via bfd_link_hash_traverse, or by print_all_symbols. */ - -static bfd_boolean -print_one_symbol (struct bfd_link_hash_entry *hash_entry, void *ptr) -{ - asection *sec = (asection *) ptr; - - if ((hash_entry->type == bfd_link_hash_defined - || hash_entry->type == bfd_link_hash_defweak) - && sec == hash_entry->u.def.section) - { - int i; - - for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++) - print_space (); - minfo ("0x%V ", - (hash_entry->u.def.value - + hash_entry->u.def.section->output_offset - + hash_entry->u.def.section->output_section->vma)); - - minfo (" %T\n", hash_entry->root.string); - } - - return TRUE; -} - -static int -hash_entry_addr_cmp (const void *a, const void *b) -{ - const struct bfd_link_hash_entry *l = *(const struct bfd_link_hash_entry **)a; - const struct bfd_link_hash_entry *r = *(const struct bfd_link_hash_entry **)b; - - if (l->u.def.value < r->u.def.value) - return -1; - else if (l->u.def.value > r->u.def.value) - return 1; - else - return 0; -} - -static void -print_all_symbols (asection *sec) -{ - input_section_userdata_type *ud - = (input_section_userdata_type *) get_userdata (sec); - struct map_symbol_def *def; - struct bfd_link_hash_entry **entries; - unsigned int i; - - if (!ud) - return; - - *ud->map_symbol_def_tail = 0; - - /* Sort the symbols by address. */ - entries = (struct bfd_link_hash_entry **) - obstack_alloc (&map_obstack, - ud->map_symbol_def_count * sizeof (*entries)); - - for (i = 0, def = ud->map_symbol_def_head; def; def = def->next, i++) - entries[i] = def->entry; - - qsort (entries, ud->map_symbol_def_count, sizeof (*entries), - hash_entry_addr_cmp); - - /* Print the symbols. */ - for (i = 0; i < ud->map_symbol_def_count; i++) - print_one_symbol (entries[i], sec); - - obstack_free (&map_obstack, entries); -} - -/* Print information about an input section to the map file. */ - -static void -print_input_section (asection *i, bfd_boolean is_discarded) -{ - bfd_size_type size = i->size; - int len; - bfd_vma addr; - - init_opb (); - - print_space (); - minfo ("%s", i->name); - - len = 1 + strlen (i->name); - if (len >= SECTION_NAME_MAP_LENGTH - 1) - { - print_nl (); - len = 0; - } - while (len < SECTION_NAME_MAP_LENGTH) - { - print_space (); - ++len; - } - - if (i->output_section != NULL - && i->output_section->owner == link_info.output_bfd) - addr = i->output_section->vma + i->output_offset; - else - { - addr = print_dot; - if (!is_discarded) - size = 0; - } - - minfo ("0x%V %W %B\n", addr, size, i->owner); - - if (size != i->rawsize && i->rawsize != 0) - { - len = SECTION_NAME_MAP_LENGTH + 3; -#ifdef BFD64 - len += 16; -#else - len += 8; -#endif - while (len > 0) - { - print_space (); - --len; - } - - minfo (_("%W (size before relaxing)\n"), i->rawsize); - } - - if (i->output_section != NULL - && i->output_section->owner == link_info.output_bfd) - { - if (link_info.reduce_memory_overheads) - bfd_link_hash_traverse (link_info.hash, print_one_symbol, i); - else - print_all_symbols (i); - - /* Update print_dot, but make sure that we do not move it - backwards - this could happen if we have overlays and a - later overlay is shorter than an earier one. */ - if (addr + TO_ADDR (size) > print_dot) - print_dot = addr + TO_ADDR (size); - } -} - -static void -print_fill_statement (lang_fill_statement_type *fill) -{ - size_t size; - unsigned char *p; - fputs (" FILL mask 0x", config.map_file); - for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--) - fprintf (config.map_file, "%02x", *p); - fputs ("\n", config.map_file); -} - -static void -print_data_statement (lang_data_statement_type *data) -{ - int i; - bfd_vma addr; - bfd_size_type size; - const char *name; - - init_opb (); - for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++) - print_space (); - - addr = data->output_offset; - if (data->output_section != NULL) - addr += data->output_section->vma; - - switch (data->type) - { - default: - abort (); - case BYTE: - size = BYTE_SIZE; - name = "BYTE"; - break; - case SHORT: - size = SHORT_SIZE; - name = "SHORT"; - break; - case LONG: - size = LONG_SIZE; - name = "LONG"; - break; - case QUAD: - size = QUAD_SIZE; - name = "QUAD"; - break; - case SQUAD: - size = QUAD_SIZE; - name = "SQUAD"; - break; - } - - if (size < TO_SIZE ((unsigned) 1)) - size = TO_SIZE ((unsigned) 1); - minfo ("0x%V %W %s 0x%v", addr, TO_ADDR (size), name, data->value); - - if (data->exp->type.node_class != etree_value) - { - print_space (); - exp_print_tree (data->exp); - } - - print_nl (); - - print_dot = addr + TO_ADDR (size); -} - -/* Print an address statement. These are generated by options like - -Ttext. */ - -static void -print_address_statement (lang_address_statement_type *address) -{ - minfo (_("Address of section %s set to "), address->section_name); - exp_print_tree (address->address); - print_nl (); -} - -/* Print a reloc statement. */ - -static void -print_reloc_statement (lang_reloc_statement_type *reloc) -{ - int i; - bfd_vma addr; - bfd_size_type size; - - init_opb (); - for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++) - print_space (); - - addr = reloc->output_offset; - if (reloc->output_section != NULL) - addr += reloc->output_section->vma; - - size = bfd_get_reloc_size (reloc->howto); - - minfo ("0x%V %W RELOC %s ", addr, TO_ADDR (size), reloc->howto->name); - - if (reloc->name != NULL) - minfo ("%s+", reloc->name); - else - minfo ("%s+", reloc->section->name); - - exp_print_tree (reloc->addend_exp); - - print_nl (); - - print_dot = addr + TO_ADDR (size); -} - -static void -print_padding_statement (lang_padding_statement_type *s) -{ - int len; - bfd_vma addr; - - init_opb (); - minfo (" *fill*"); - - len = sizeof " *fill*" - 1; - while (len < SECTION_NAME_MAP_LENGTH) - { - print_space (); - ++len; - } - - addr = s->output_offset; - if (s->output_section != NULL) - addr += s->output_section->vma; - minfo ("0x%V %W ", addr, TO_ADDR (s->size)); - - if (s->fill->size != 0) - { - size_t size; - unsigned char *p; - for (p = s->fill->data, size = s->fill->size; size != 0; p++, size--) - fprintf (config.map_file, "%02x", *p); - } - - print_nl (); - - print_dot = addr + TO_ADDR (s->size); -} - -static void -print_wild_statement (lang_wild_statement_type *w, - lang_output_section_statement_type *os) -{ - struct wildcard_list *sec; - - print_space (); - - if (w->exclude_name_list) - { - name_list *tmp; - minfo ("EXCLUDE_FILE(%s", w->exclude_name_list->name); - for (tmp = w->exclude_name_list->next; tmp; tmp = tmp->next) - minfo (" %s", tmp->name); - minfo (") "); - } - - if (w->filenames_sorted) - minfo ("SORT_BY_NAME("); - if (w->filename != NULL) - minfo ("%s", w->filename); - else - minfo ("*"); - if (w->filenames_sorted) - minfo (")"); - - minfo ("("); - for (sec = w->section_list; sec; sec = sec->next) - { - int closing_paren = 0; - - switch (sec->spec.sorted) - { - case none: - break; - - case by_name: - minfo ("SORT_BY_NAME("); - closing_paren = 1; - break; - - case by_alignment: - minfo ("SORT_BY_ALIGNMENT("); - closing_paren = 1; - break; - - case by_name_alignment: - minfo ("SORT_BY_NAME(SORT_BY_ALIGNMENT("); - closing_paren = 2; - break; - - case by_alignment_name: - minfo ("SORT_BY_ALIGNMENT(SORT_BY_NAME("); - closing_paren = 2; - break; - - case by_none: - minfo ("SORT_NONE("); - closing_paren = 1; - break; - - case by_init_priority: - minfo ("SORT_BY_INIT_PRIORITY("); - closing_paren = 1; - break; - } - - if (sec->spec.exclude_name_list != NULL) - { - name_list *tmp; - minfo ("EXCLUDE_FILE(%s", sec->spec.exclude_name_list->name); - for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next) - minfo (" %s", tmp->name); - minfo (") "); - } - if (sec->spec.name != NULL) - minfo ("%s", sec->spec.name); - else - minfo ("*"); - for (;closing_paren > 0; closing_paren--) - minfo (")"); - if (sec->next) - minfo (" "); - } - minfo (")"); - - print_nl (); - - print_statement_list (w->children.head, os); -} - -/* Print a group statement. */ - -static void -print_group (lang_group_statement_type *s, - lang_output_section_statement_type *os) -{ - fprintf (config.map_file, "START GROUP\n"); - print_statement_list (s->children.head, os); - fprintf (config.map_file, "END GROUP\n"); -} - -/* Print the list of statements in S. - This can be called for any statement type. */ - -static void -print_statement_list (lang_statement_union_type *s, - lang_output_section_statement_type *os) -{ - while (s != NULL) - { - print_statement (s, os); - s = s->header.next; - } -} - -/* Print the first statement in statement list S. - This can be called for any statement type. */ - -static void -print_statement (lang_statement_union_type *s, - lang_output_section_statement_type *os) -{ - switch (s->header.type) - { - default: - fprintf (config.map_file, _("Fail with %d\n"), s->header.type); - FAIL (); - break; - case lang_constructors_statement_enum: - if (constructor_list.head != NULL) - { - if (constructors_sorted) - minfo (" SORT (CONSTRUCTORS)\n"); - else - minfo (" CONSTRUCTORS\n"); - print_statement_list (constructor_list.head, os); - } - break; - case lang_wild_statement_enum: - print_wild_statement (&s->wild_statement, os); - break; - case lang_address_statement_enum: - print_address_statement (&s->address_statement); - break; - case lang_object_symbols_statement_enum: - minfo (" CREATE_OBJECT_SYMBOLS\n"); - break; - case lang_fill_statement_enum: - print_fill_statement (&s->fill_statement); - break; - case lang_data_statement_enum: - print_data_statement (&s->data_statement); - break; - case lang_reloc_statement_enum: - print_reloc_statement (&s->reloc_statement); - break; - case lang_input_section_enum: - print_input_section (s->input_section.section, FALSE); - break; - case lang_padding_statement_enum: - print_padding_statement (&s->padding_statement); - break; - case lang_output_section_statement_enum: - print_output_section_statement (&s->output_section_statement); - break; - case lang_assignment_statement_enum: - print_assignment (&s->assignment_statement, os); - break; - case lang_target_statement_enum: - fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target); - break; - case lang_output_statement_enum: - minfo ("OUTPUT(%s", s->output_statement.name); - if (output_target != NULL) - minfo (" %s", output_target); - minfo (")\n"); - break; - case lang_input_statement_enum: - print_input_statement (&s->input_statement); - break; - case lang_group_statement_enum: - print_group (&s->group_statement, os); - break; - case lang_insert_statement_enum: - minfo ("INSERT %s %s\n", - s->insert_statement.is_before ? "BEFORE" : "AFTER", - s->insert_statement.where); - break; - } -} - -static void -print_statements (void) -{ - print_statement_list (statement_list.head, abs_output_section); -} - -/* Print the first N statements in statement list S to STDERR. - If N == 0, nothing is printed. - If N < 0, the entire list is printed. - Intended to be called from GDB. */ - -void -dprint_statement (lang_statement_union_type *s, int n) -{ - FILE *map_save = config.map_file; - - config.map_file = stderr; - - if (n < 0) - print_statement_list (s, abs_output_section); - else - { - while (s && --n >= 0) - { - print_statement (s, abs_output_section); - s = s->header.next; - } - } - - config.map_file = map_save; -} - -static void -insert_pad (lang_statement_union_type **ptr, - fill_type *fill, - bfd_size_type alignment_needed, - asection *output_section, - bfd_vma dot) -{ - static fill_type zero_fill; - lang_statement_union_type *pad = NULL; - - if (ptr != &statement_list.head) - pad = ((lang_statement_union_type *) - ((char *) ptr - offsetof (lang_statement_union_type, header.next))); - if (pad != NULL - && pad->header.type == lang_padding_statement_enum - && pad->padding_statement.output_section == output_section) - { - /* Use the existing pad statement. */ - } - else if ((pad = *ptr) != NULL - && pad->header.type == lang_padding_statement_enum - && pad->padding_statement.output_section == output_section) - { - /* Use the existing pad statement. */ - } - else - { - /* Make a new padding statement, linked into existing chain. */ - pad = (lang_statement_union_type *) - stat_alloc (sizeof (lang_padding_statement_type)); - pad->header.next = *ptr; - *ptr = pad; - pad->header.type = lang_padding_statement_enum; - pad->padding_statement.output_section = output_section; - if (fill == NULL) - fill = &zero_fill; - pad->padding_statement.fill = fill; - } - pad->padding_statement.output_offset = dot - output_section->vma; - pad->padding_statement.size = alignment_needed; - output_section->size = TO_SIZE (dot + TO_ADDR (alignment_needed) - - output_section->vma); -} - -/* Work out how much this section will move the dot point. */ - -static bfd_vma -size_input_section - (lang_statement_union_type **this_ptr, - lang_output_section_statement_type *output_section_statement, - fill_type *fill, - bfd_vma dot) -{ - lang_input_section_type *is = &((*this_ptr)->input_section); - asection *i = is->section; - asection *o = output_section_statement->bfd_section; - - if (i->sec_info_type == SEC_INFO_TYPE_JUST_SYMS) - i->output_offset = i->vma - o->vma; - else if (((i->flags & SEC_EXCLUDE) != 0) - || output_section_statement->ignored) - i->output_offset = dot - o->vma; - else - { - bfd_size_type alignment_needed; - - /* Align this section first to the input sections requirement, - then to the output section's requirement. If this alignment - is greater than any seen before, then record it too. Perform - the alignment by inserting a magic 'padding' statement. */ - - if (output_section_statement->subsection_alignment != -1) - i->alignment_power = output_section_statement->subsection_alignment; - - if (o->alignment_power < i->alignment_power) - o->alignment_power = i->alignment_power; - - alignment_needed = align_power (dot, i->alignment_power) - dot; - - if (alignment_needed != 0) - { - insert_pad (this_ptr, fill, TO_SIZE (alignment_needed), o, dot); - dot += alignment_needed; - } - - /* Remember where in the output section this input section goes. */ - i->output_offset = dot - o->vma; - - /* Mark how big the output section must be to contain this now. */ - dot += TO_ADDR (i->size); - o->size = TO_SIZE (dot - o->vma); - } - - return dot; -} - -struct check_sec -{ - asection *sec; - bfd_boolean warned; -}; - -static int -sort_sections_by_lma (const void *arg1, const void *arg2) -{ - const asection *sec1 = ((const struct check_sec *) arg1)->sec; - const asection *sec2 = ((const struct check_sec *) arg2)->sec; - - if (sec1->lma < sec2->lma) - return -1; - else if (sec1->lma > sec2->lma) - return 1; - else if (sec1->id < sec2->id) - return -1; - else if (sec1->id > sec2->id) - return 1; - - return 0; -} - -static int -sort_sections_by_vma (const void *arg1, const void *arg2) -{ - const asection *sec1 = ((const struct check_sec *) arg1)->sec; - const asection *sec2 = ((const struct check_sec *) arg2)->sec; - - if (sec1->vma < sec2->vma) - return -1; - else if (sec1->vma > sec2->vma) - return 1; - else if (sec1->id < sec2->id) - return -1; - else if (sec1->id > sec2->id) - return 1; - - return 0; -} - -#define IS_TBSS(s) \ - ((s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == SEC_THREAD_LOCAL) - -#define IGNORE_SECTION(s) \ - ((s->flags & SEC_ALLOC) == 0 || IS_TBSS (s)) - -/* Check to see if any allocated sections overlap with other allocated - sections. This can happen if a linker script specifies the output - section addresses of the two sections. Also check whether any memory - region has overflowed. */ - -static void -lang_check_section_addresses (void) -{ - asection *s, *p; - struct check_sec *sections; - size_t i, count; - bfd_vma addr_mask; - bfd_vma s_start; - bfd_vma s_end; - bfd_vma p_start = 0; - bfd_vma p_end = 0; - lang_memory_region_type *m; - bfd_boolean overlays; - - /* Detect address space overflow on allocated sections. */ - addr_mask = ((bfd_vma) 1 << - (bfd_arch_bits_per_address (link_info.output_bfd) - 1)) - 1; - addr_mask = (addr_mask << 1) + 1; - for (s = link_info.output_bfd->sections; s != NULL; s = s->next) - if ((s->flags & SEC_ALLOC) != 0) - { - s_end = (s->vma + s->size) & addr_mask; - if (s_end != 0 && s_end < (s->vma & addr_mask)) - einfo (_("%X%P: section %s VMA wraps around address space\n"), - s->name); - else - { - s_end = (s->lma + s->size) & addr_mask; - if (s_end != 0 && s_end < (s->lma & addr_mask)) - einfo (_("%X%P: section %s LMA wraps around address space\n"), - s->name); - } - } - - if (bfd_count_sections (link_info.output_bfd) <= 1) - return; - - count = bfd_count_sections (link_info.output_bfd); - sections = XNEWVEC (struct check_sec, count); - - /* Scan all sections in the output list. */ - count = 0; - for (s = link_info.output_bfd->sections; s != NULL; s = s->next) - { - if (IGNORE_SECTION (s) - || s->size == 0) - continue; - - sections[count].sec = s; - sections[count].warned = FALSE; - count++; - } - - if (count <= 1) - { - free (sections); - return; - } - - qsort (sections, count, sizeof (*sections), sort_sections_by_lma); - - /* First check section LMAs. There should be no overlap of LMAs on - loadable sections, even with overlays. */ - for (p = NULL, i = 0; i < count; i++) - { - s = sections[i].sec; - if ((s->flags & SEC_LOAD) != 0) - { - s_start = s->lma; - s_end = s_start + TO_ADDR (s->size) - 1; - - /* Look for an overlap. We have sorted sections by lma, so - we know that s_start >= p_start. Besides the obvious - case of overlap when the current section starts before - the previous one ends, we also must have overlap if the - previous section wraps around the address space. */ - if (p != NULL - && (s_start <= p_end - || p_end < p_start)) - { - einfo (_("%X%P: section %s LMA [%V,%V]" - " overlaps section %s LMA [%V,%V]\n"), - s->name, s_start, s_end, p->name, p_start, p_end); - sections[i].warned = TRUE; - } - p = s; - p_start = s_start; - p_end = s_end; - } - } - - /* If any non-zero size allocated section (excluding tbss) starts at - exactly the same VMA as another such section, then we have - overlays. Overlays generated by the OVERLAY keyword will have - this property. It is possible to intentionally generate overlays - that fail this test, but it would be unusual. */ - qsort (sections, count, sizeof (*sections), sort_sections_by_vma); - overlays = FALSE; - p_start = sections[0].sec->vma; - for (i = 1; i < count; i++) - { - s_start = sections[i].sec->vma; - if (p_start == s_start) - { - overlays = TRUE; - break; - } - p_start = s_start; - } - - /* Now check section VMAs if no overlays were detected. */ - if (!overlays) - { - for (p = NULL, i = 0; i < count; i++) - { - s = sections[i].sec; - s_start = s->vma; - s_end = s_start + TO_ADDR (s->size) - 1; - - if (p != NULL - && !sections[i].warned - && (s_start <= p_end - || p_end < p_start)) - einfo (_("%X%P: section %s VMA [%V,%V]" - " overlaps section %s VMA [%V,%V]\n"), - s->name, s_start, s_end, p->name, p_start, p_end); - p = s; - p_start = s_start; - p_end = s_end; - } - } - - free (sections); - - /* If any memory region has overflowed, report by how much. - We do not issue this diagnostic for regions that had sections - explicitly placed outside their bounds; os_region_check's - diagnostics are adequate for that case. - - FIXME: It is conceivable that m->current - (m->origin + m->length) - might overflow a 32-bit integer. There is, alas, no way to print - a bfd_vma quantity in decimal. */ - for (m = lang_memory_region_list; m; m = m->next) - if (m->had_full_message) - { - unsigned long over = m->current - (m->origin + m->length); - einfo (ngettext ("%X%P: region `%s' overflowed by %lu byte\n", - "%X%P: region `%s' overflowed by %lu bytes\n", - over), - m->name_list.name, over); - } -} - -/* Make sure the new address is within the region. We explicitly permit the - current address to be at the exact end of the region when the address is - non-zero, in case the region is at the end of addressable memory and the - calculation wraps around. */ - -static void -os_region_check (lang_output_section_statement_type *os, - lang_memory_region_type *region, - etree_type *tree, - bfd_vma rbase) -{ - if ((region->current < region->origin - || (region->current - region->origin > region->length)) - && ((region->current != region->origin + region->length) - || rbase == 0)) - { - if (tree != NULL) - { - einfo (_("%X%P: address 0x%v of %B section `%s'" - " is not within region `%s'\n"), - region->current, - os->bfd_section->owner, - os->bfd_section->name, - region->name_list.name); - } - else if (!region->had_full_message) - { - region->had_full_message = TRUE; - - einfo (_("%X%P: %B section `%s' will not fit in region `%s'\n"), - os->bfd_section->owner, - os->bfd_section->name, - region->name_list.name); - } - } -} - -static void -ldlang_check_relro_region (lang_statement_union_type *s, - seg_align_type *seg) -{ - if (seg->relro == exp_seg_relro_start) - { - if (!seg->relro_start_stat) - seg->relro_start_stat = s; - else - { - ASSERT (seg->relro_start_stat == s); - } - } - else if (seg->relro == exp_seg_relro_end) - { - if (!seg->relro_end_stat) - seg->relro_end_stat = s; - else - { - ASSERT (seg->relro_end_stat == s); - } - } -} - -/* Set the sizes for all the output sections. */ - -static bfd_vma -lang_size_sections_1 - (lang_statement_union_type **prev, - lang_output_section_statement_type *output_section_statement, - fill_type *fill, - bfd_vma dot, - bfd_boolean *relax, - bfd_boolean check_regions) -{ - lang_statement_union_type *s; - - /* Size up the sections from their constituent parts. */ - for (s = *prev; s != NULL; s = s->header.next) - { - switch (s->header.type) - { - case lang_output_section_statement_enum: - { - bfd_vma newdot, after, dotdelta; - lang_output_section_statement_type *os; - lang_memory_region_type *r; - int section_alignment = 0; - - os = &s->output_section_statement; - if (os->constraint == -1) - break; - - /* FIXME: We shouldn't need to zero section vmas for ld -r - here, in lang_insert_orphan, or in the default linker scripts. - This is covering for coff backend linker bugs. See PR6945. */ - if (os->addr_tree == NULL - && bfd_link_relocatable (&link_info) - && (bfd_get_flavour (link_info.output_bfd) - == bfd_target_coff_flavour)) - os->addr_tree = exp_intop (0); - if (os->addr_tree != NULL) - { - os->processed_vma = FALSE; - exp_fold_tree (os->addr_tree, bfd_abs_section_ptr, &dot); - - if (expld.result.valid_p) - { - dot = expld.result.value; - if (expld.result.section != NULL) - dot += expld.result.section->vma; - } - else if (expld.phase != lang_mark_phase_enum) - einfo (_("%F%S: non constant or forward reference" - " address expression for section %s\n"), - os->addr_tree, os->name); - } - - if (os->bfd_section == NULL) - /* This section was removed or never actually created. */ - break; - - /* If this is a COFF shared library section, use the size and - address from the input section. FIXME: This is COFF - specific; it would be cleaner if there were some other way - to do this, but nothing simple comes to mind. */ - if (((bfd_get_flavour (link_info.output_bfd) - == bfd_target_ecoff_flavour) - || (bfd_get_flavour (link_info.output_bfd) - == bfd_target_coff_flavour)) - && (os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0) - { - asection *input; - - if (os->children.head == NULL - || os->children.head->header.next != NULL - || (os->children.head->header.type - != lang_input_section_enum)) - einfo (_("%P%X: Internal error on COFF shared library" - " section %s\n"), os->name); - - input = os->children.head->input_section.section; - bfd_set_section_vma (os->bfd_section->owner, - os->bfd_section, - bfd_section_vma (input->owner, input)); - os->bfd_section->size = input->size; - break; - } - - newdot = dot; - dotdelta = 0; - if (bfd_is_abs_section (os->bfd_section)) - { - /* No matter what happens, an abs section starts at zero. */ - ASSERT (os->bfd_section->vma == 0); - } - else - { - if (os->addr_tree == NULL) - { - /* No address specified for this section, get one - from the region specification. */ - if (os->region == NULL - || ((os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD)) - && os->region->name_list.name[0] == '*' - && strcmp (os->region->name_list.name, - DEFAULT_MEMORY_REGION) == 0)) - { - os->region = lang_memory_default (os->bfd_section); - } - - /* If a loadable section is using the default memory - region, and some non default memory regions were - defined, issue an error message. */ - if (!os->ignored - && !IGNORE_SECTION (os->bfd_section) - && !bfd_link_relocatable (&link_info) - && check_regions - && strcmp (os->region->name_list.name, - DEFAULT_MEMORY_REGION) == 0 - && lang_memory_region_list != NULL - && (strcmp (lang_memory_region_list->name_list.name, - DEFAULT_MEMORY_REGION) != 0 - || lang_memory_region_list->next != NULL) - && expld.phase != lang_mark_phase_enum) - { - /* By default this is an error rather than just a - warning because if we allocate the section to the - default memory region we can end up creating an - excessively large binary, or even seg faulting when - attempting to perform a negative seek. See - sources.redhat.com/ml/binutils/2003-04/msg00423.html - for an example of this. This behaviour can be - overridden by the using the --no-check-sections - switch. */ - if (command_line.check_section_addresses) - einfo (_("%P%F: error: no memory region specified" - " for loadable section `%s'\n"), - bfd_get_section_name (link_info.output_bfd, - os->bfd_section)); - else - einfo (_("%P: warning: no memory region specified" - " for loadable section `%s'\n"), - bfd_get_section_name (link_info.output_bfd, - os->bfd_section)); - } - - newdot = os->region->current; - section_alignment = os->bfd_section->alignment_power; - } - else - section_alignment = os->section_alignment; - - /* Align to what the section needs. */ - if (section_alignment > 0) - { - bfd_vma savedot = newdot; - newdot = align_power (newdot, section_alignment); - - dotdelta = newdot - savedot; - if (dotdelta != 0 - && (config.warn_section_align - || os->addr_tree != NULL) - && expld.phase != lang_mark_phase_enum) - einfo (ngettext ("%P: warning: changing start of " - "section %s by %lu byte\n", - "%P: warning: changing start of " - "section %s by %lu bytes\n", - (unsigned long) dotdelta), - os->name, (unsigned long) dotdelta); - } - - bfd_set_section_vma (0, os->bfd_section, newdot); - - os->bfd_section->output_offset = 0; - } - - lang_size_sections_1 (&os->children.head, os, - os->fill, newdot, relax, check_regions); - - os->processed_vma = TRUE; - - if (bfd_is_abs_section (os->bfd_section) || os->ignored) - /* Except for some special linker created sections, - no output section should change from zero size - after strip_excluded_output_sections. A non-zero - size on an ignored section indicates that some - input section was not sized early enough. */ - ASSERT (os->bfd_section->size == 0); - else - { - dot = os->bfd_section->vma; - - /* Put the section within the requested block size, or - align at the block boundary. */ - after = ((dot - + TO_ADDR (os->bfd_section->size) - + os->block_value - 1) - & - (bfd_vma) os->block_value); - - os->bfd_section->size = TO_SIZE (after - os->bfd_section->vma); - } - - /* Set section lma. */ - r = os->region; - if (r == NULL) - r = lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE); - - if (os->load_base) - { - bfd_vma lma = exp_get_abs_int (os->load_base, 0, "load base"); - os->bfd_section->lma = lma; - } - else if (os->lma_region != NULL) - { - bfd_vma lma = os->lma_region->current; - - if (os->align_lma_with_input) - lma += dotdelta; - else - { - /* When LMA_REGION is the same as REGION, align the LMA - as we did for the VMA, possibly including alignment - from the bfd section. If a different region, then - only align according to the value in the output - statement. */ - if (os->lma_region != os->region) - section_alignment = os->section_alignment; - if (section_alignment > 0) - lma = align_power (lma, section_alignment); - } - os->bfd_section->lma = lma; - } - else if (r->last_os != NULL - && (os->bfd_section->flags & SEC_ALLOC) != 0) - { - bfd_vma lma; - asection *last; - - last = r->last_os->output_section_statement.bfd_section; - - /* A backwards move of dot should be accompanied by - an explicit assignment to the section LMA (ie. - os->load_base set) because backwards moves can - create overlapping LMAs. */ - if (dot < last->vma - && os->bfd_section->size != 0 - && dot + TO_ADDR (os->bfd_section->size) <= last->vma) - { - /* If dot moved backwards then leave lma equal to - vma. This is the old default lma, which might - just happen to work when the backwards move is - sufficiently large. Nag if this changes anything, - so people can fix their linker scripts. */ - - if (last->vma != last->lma) - einfo (_("%P: warning: dot moved backwards " - "before `%s'\n"), os->name); - } - else - { - /* If this is an overlay, set the current lma to that - at the end of the previous section. */ - if (os->sectype == overlay_section) - lma = last->lma + TO_ADDR (last->size); - - /* Otherwise, keep the same lma to vma relationship - as the previous section. */ - else - lma = dot + last->lma - last->vma; - - if (section_alignment > 0) - lma = align_power (lma, section_alignment); - os->bfd_section->lma = lma; - } - } - os->processed_lma = TRUE; - - /* Keep track of normal sections using the default - lma region. We use this to set the lma for - following sections. Overlays or other linker - script assignment to lma might mean that the - default lma == vma is incorrect. - To avoid warnings about dot moving backwards when using - -Ttext, don't start tracking sections until we find one - of non-zero size or with lma set differently to vma. - Do this tracking before we short-cut the loop so that we - track changes for the case where the section size is zero, - but the lma is set differently to the vma. This is - important, if an orphan section is placed after an - otherwise empty output section that has an explicit lma - set, we want that lma reflected in the orphans lma. */ - if (!IGNORE_SECTION (os->bfd_section) - && (os->bfd_section->size != 0 - || (r->last_os == NULL - && os->bfd_section->vma != os->bfd_section->lma) - || (r->last_os != NULL - && dot >= (r->last_os->output_section_statement - .bfd_section->vma))) - && os->lma_region == NULL - && !bfd_link_relocatable (&link_info)) - r->last_os = s; - - if (bfd_is_abs_section (os->bfd_section) || os->ignored) - break; - - /* .tbss sections effectively have zero size. */ - if (!IS_TBSS (os->bfd_section) - || bfd_link_relocatable (&link_info)) - dotdelta = TO_ADDR (os->bfd_section->size); - else - dotdelta = 0; - dot += dotdelta; - - if (os->update_dot_tree != 0) - exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot); - - /* Update dot in the region ? - We only do this if the section is going to be allocated, - since unallocated sections do not contribute to the region's - overall size in memory. */ - if (os->region != NULL - && (os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))) - { - os->region->current = dot; - - if (check_regions) - /* Make sure the new address is within the region. */ - os_region_check (os, os->region, os->addr_tree, - os->bfd_section->vma); - - if (os->lma_region != NULL && os->lma_region != os->region - && ((os->bfd_section->flags & SEC_LOAD) - || os->align_lma_with_input)) - { - os->lma_region->current = os->bfd_section->lma + dotdelta; - - if (check_regions) - os_region_check (os, os->lma_region, NULL, - os->bfd_section->lma); - } - } - } - break; - - case lang_constructors_statement_enum: - dot = lang_size_sections_1 (&constructor_list.head, - output_section_statement, - fill, dot, relax, check_regions); - break; - - case lang_data_statement_enum: - { - unsigned int size = 0; - - s->data_statement.output_offset = - dot - output_section_statement->bfd_section->vma; - s->data_statement.output_section = - output_section_statement->bfd_section; - - /* We might refer to provided symbols in the expression, and - need to mark them as needed. */ - exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot); - - switch (s->data_statement.type) - { - default: - abort (); - case QUAD: - case SQUAD: - size = QUAD_SIZE; - break; - case LONG: - size = LONG_SIZE; - break; - case SHORT: - size = SHORT_SIZE; - break; - case BYTE: - size = BYTE_SIZE; - break; - } - if (size < TO_SIZE ((unsigned) 1)) - size = TO_SIZE ((unsigned) 1); - dot += TO_ADDR (size); - output_section_statement->bfd_section->size - = TO_SIZE (dot - output_section_statement->bfd_section->vma); - - } - break; - - case lang_reloc_statement_enum: - { - int size; - - s->reloc_statement.output_offset = - dot - output_section_statement->bfd_section->vma; - s->reloc_statement.output_section = - output_section_statement->bfd_section; - size = bfd_get_reloc_size (s->reloc_statement.howto); - dot += TO_ADDR (size); - output_section_statement->bfd_section->size - = TO_SIZE (dot - output_section_statement->bfd_section->vma); - } - break; - - case lang_wild_statement_enum: - dot = lang_size_sections_1 (&s->wild_statement.children.head, - output_section_statement, - fill, dot, relax, check_regions); - break; - - case lang_object_symbols_statement_enum: - link_info.create_object_symbols_section = - output_section_statement->bfd_section; - break; - - case lang_output_statement_enum: - case lang_target_statement_enum: - break; - - case lang_input_section_enum: - { - asection *i; - - i = s->input_section.section; - if (relax) - { - bfd_boolean again; - - if (!bfd_relax_section (i->owner, i, &link_info, &again)) - einfo (_("%P%F: can't relax section: %E\n")); - if (again) - *relax = TRUE; - } - dot = size_input_section (prev, output_section_statement, - fill, dot); - } - break; - - case lang_input_statement_enum: - break; - - case lang_fill_statement_enum: - s->fill_statement.output_section = - output_section_statement->bfd_section; - - fill = s->fill_statement.fill; - break; - - case lang_assignment_statement_enum: - { - bfd_vma newdot = dot; - etree_type *tree = s->assignment_statement.exp; - - expld.dataseg.relro = exp_seg_relro_none; - - exp_fold_tree (tree, - output_section_statement->bfd_section, - &newdot); - - ldlang_check_relro_region (s, &expld.dataseg); - - expld.dataseg.relro = exp_seg_relro_none; - - /* This symbol may be relative to this section. */ - if ((tree->type.node_class == etree_provided - || tree->type.node_class == etree_assign) - && (tree->assign.dst [0] != '.' - || tree->assign.dst [1] != '\0')) - output_section_statement->update_dot = 1; - - if (!output_section_statement->ignored) - { - if (output_section_statement == abs_output_section) - { - /* If we don't have an output section, then just adjust - the default memory address. */ - lang_memory_region_lookup (DEFAULT_MEMORY_REGION, - FALSE)->current = newdot; - } - else if (newdot != dot) - { - /* Insert a pad after this statement. We can't - put the pad before when relaxing, in case the - assignment references dot. */ - insert_pad (&s->header.next, fill, TO_SIZE (newdot - dot), - output_section_statement->bfd_section, dot); - - /* Don't neuter the pad below when relaxing. */ - s = s->header.next; - - /* If dot is advanced, this implies that the section - should have space allocated to it, unless the - user has explicitly stated that the section - should not be allocated. */ - if (output_section_statement->sectype != noalloc_section - && (output_section_statement->sectype != noload_section - || (bfd_get_flavour (link_info.output_bfd) - == bfd_target_elf_flavour))) - output_section_statement->bfd_section->flags |= SEC_ALLOC; - } - dot = newdot; - } - } - break; - - case lang_padding_statement_enum: - /* If this is the first time lang_size_sections is called, - we won't have any padding statements. If this is the - second or later passes when relaxing, we should allow - padding to shrink. If padding is needed on this pass, it - will be added back in. */ - s->padding_statement.size = 0; - - /* Make sure output_offset is valid. If relaxation shrinks - the section and this pad isn't needed, it's possible to - have output_offset larger than the final size of the - section. bfd_set_section_contents will complain even for - a pad size of zero. */ - s->padding_statement.output_offset - = dot - output_section_statement->bfd_section->vma; - break; - - case lang_group_statement_enum: - dot = lang_size_sections_1 (&s->group_statement.children.head, - output_section_statement, - fill, dot, relax, check_regions); - break; - - case lang_insert_statement_enum: - break; - - /* We can only get here when relaxing is turned on. */ - case lang_address_statement_enum: - break; - - default: - FAIL (); - break; - } - prev = &s->header.next; - } - return dot; -} - -/* Callback routine that is used in _bfd_elf_map_sections_to_segments. - The BFD library has set NEW_SEGMENT to TRUE iff it thinks that - CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different - segments. We are allowed an opportunity to override this decision. */ - -bfd_boolean -ldlang_override_segment_assignment (struct bfd_link_info *info ATTRIBUTE_UNUSED, - bfd *abfd ATTRIBUTE_UNUSED, - asection *current_section, - asection *previous_section, - bfd_boolean new_segment) -{ - lang_output_section_statement_type *cur; - lang_output_section_statement_type *prev; - - /* The checks below are only necessary when the BFD library has decided - that the two sections ought to be placed into the same segment. */ - if (new_segment) - return TRUE; - - /* Paranoia checks. */ - if (current_section == NULL || previous_section == NULL) - return new_segment; - - /* If this flag is set, the target never wants code and non-code - sections comingled in the same segment. */ - if (config.separate_code - && ((current_section->flags ^ previous_section->flags) & SEC_CODE)) - return TRUE; - - /* Find the memory regions associated with the two sections. - We call lang_output_section_find() here rather than scanning the list - of output sections looking for a matching section pointer because if - we have a large number of sections then a hash lookup is faster. */ - cur = lang_output_section_find (current_section->name); - prev = lang_output_section_find (previous_section->name); - - /* More paranoia. */ - if (cur == NULL || prev == NULL) - return new_segment; - - /* If the regions are different then force the sections to live in - different segments. See the email thread starting at the following - URL for the reasons why this is necessary: - http://sourceware.org/ml/binutils/2007-02/msg00216.html */ - return cur->region != prev->region; -} - -void -one_lang_size_sections_pass (bfd_boolean *relax, bfd_boolean check_regions) -{ - lang_statement_iteration++; - lang_size_sections_1 (&statement_list.head, abs_output_section, - 0, 0, relax, check_regions); -} - -static bfd_boolean -lang_size_segment (seg_align_type *seg) -{ - /* If XXX_SEGMENT_ALIGN XXX_SEGMENT_END pair was seen, check whether - a page could be saved in the data segment. */ - bfd_vma first, last; - - first = -seg->base & (seg->pagesize - 1); - last = seg->end & (seg->pagesize - 1); - if (first && last - && ((seg->base & ~(seg->pagesize - 1)) - != (seg->end & ~(seg->pagesize - 1))) - && first + last <= seg->pagesize) - { - seg->phase = exp_seg_adjust; - return TRUE; - } - - seg->phase = exp_seg_done; - return FALSE; -} - -static bfd_vma -lang_size_relro_segment_1 (seg_align_type *seg) -{ - bfd_vma relro_end, desired_end; - asection *sec; - - /* Compute the expected PT_GNU_RELRO/PT_LOAD segment end. */ - relro_end = ((seg->relro_end + seg->pagesize - 1) - & ~(seg->pagesize - 1)); - - /* Adjust by the offset arg of XXX_SEGMENT_RELRO_END. */ - desired_end = relro_end - seg->relro_offset; - - /* For sections in the relro segment.. */ - for (sec = link_info.output_bfd->section_last; sec; sec = sec->prev) - if ((sec->flags & SEC_ALLOC) != 0 - && sec->vma >= seg->base - && sec->vma < seg->relro_end - seg->relro_offset) - { - /* Where do we want to put this section so that it ends as - desired? */ - bfd_vma start, end, bump; - - end = start = sec->vma; - if (!IS_TBSS (sec)) - end += TO_ADDR (sec->size); - bump = desired_end - end; - /* We'd like to increase START by BUMP, but we must heed - alignment so the increase might be less than optimum. */ - start += bump; - start &= ~(((bfd_vma) 1 << sec->alignment_power) - 1); - /* This is now the desired end for the previous section. */ - desired_end = start; - } - - seg->phase = exp_seg_relro_adjust; - ASSERT (desired_end >= seg->base); - seg->base = desired_end; - return relro_end; -} - -static bfd_boolean -lang_size_relro_segment (bfd_boolean *relax, bfd_boolean check_regions) -{ - bfd_boolean do_reset = FALSE; - bfd_boolean do_data_relro; - bfd_vma data_initial_base, data_relro_end; - - if (link_info.relro && expld.dataseg.relro_end) - { - do_data_relro = TRUE; - data_initial_base = expld.dataseg.base; - data_relro_end = lang_size_relro_segment_1 (&expld.dataseg); - } - else - { - do_data_relro = FALSE; - data_initial_base = data_relro_end = 0; - } - - if (do_data_relro) - { - lang_reset_memory_regions (); - one_lang_size_sections_pass (relax, check_regions); - - /* Assignments to dot, or to output section address in a user - script have increased padding over the original. Revert. */ - if (do_data_relro && expld.dataseg.relro_end > data_relro_end) - { - expld.dataseg.base = data_initial_base;; - do_reset = TRUE; - } - } - - if (!do_data_relro && lang_size_segment (&expld.dataseg)) - do_reset = TRUE; - - return do_reset; -} - -void -lang_size_sections (bfd_boolean *relax, bfd_boolean check_regions) -{ - expld.phase = lang_allocating_phase_enum; - expld.dataseg.phase = exp_seg_none; - - one_lang_size_sections_pass (relax, check_regions); - - if (expld.dataseg.phase != exp_seg_end_seen) - expld.dataseg.phase = exp_seg_done; - - if (expld.dataseg.phase == exp_seg_end_seen) - { - bfd_boolean do_reset - = lang_size_relro_segment (relax, check_regions); - - if (do_reset) - { - lang_reset_memory_regions (); - one_lang_size_sections_pass (relax, check_regions); - } - - if (link_info.relro && expld.dataseg.relro_end) - { - link_info.relro_start = expld.dataseg.base; - link_info.relro_end = expld.dataseg.relro_end; - } - } -} - -static lang_output_section_statement_type *current_section; -static lang_assignment_statement_type *current_assign; -static bfd_boolean prefer_next_section; - -/* Worker function for lang_do_assignments. Recursiveness goes here. */ - -static bfd_vma -lang_do_assignments_1 (lang_statement_union_type *s, - lang_output_section_statement_type *current_os, - fill_type *fill, - bfd_vma dot, - bfd_boolean *found_end) -{ - for (; s != NULL; s = s->header.next) - { - switch (s->header.type) - { - case lang_constructors_statement_enum: - dot = lang_do_assignments_1 (constructor_list.head, - current_os, fill, dot, found_end); - break; - - case lang_output_section_statement_enum: - { - lang_output_section_statement_type *os; - bfd_vma newdot; - - os = &(s->output_section_statement); - os->after_end = *found_end; - if (os->bfd_section != NULL && !os->ignored) - { - if ((os->bfd_section->flags & SEC_ALLOC) != 0) - { - current_section = os; - prefer_next_section = FALSE; - } - dot = os->bfd_section->vma; - } - newdot = lang_do_assignments_1 (os->children.head, - os, os->fill, dot, found_end); - if (!os->ignored) - { - if (os->bfd_section != NULL) - { - /* .tbss sections effectively have zero size. */ - if (!IS_TBSS (os->bfd_section) - || bfd_link_relocatable (&link_info)) - dot += TO_ADDR (os->bfd_section->size); - - if (os->update_dot_tree != NULL) - exp_fold_tree (os->update_dot_tree, - bfd_abs_section_ptr, &dot); - } - else - dot = newdot; - } - } - break; - - case lang_wild_statement_enum: - - dot = lang_do_assignments_1 (s->wild_statement.children.head, - current_os, fill, dot, found_end); - break; - - case lang_object_symbols_statement_enum: - case lang_output_statement_enum: - case lang_target_statement_enum: - break; - - case lang_data_statement_enum: - exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot); - if (expld.result.valid_p) - { - s->data_statement.value = expld.result.value; - if (expld.result.section != NULL) - s->data_statement.value += expld.result.section->vma; - } - else if (expld.phase == lang_final_phase_enum) - einfo (_("%F%P: invalid data statement\n")); - { - unsigned int size; - switch (s->data_statement.type) - { - default: - abort (); - case QUAD: - case SQUAD: - size = QUAD_SIZE; - break; - case LONG: - size = LONG_SIZE; - break; - case SHORT: - size = SHORT_SIZE; - break; - case BYTE: - size = BYTE_SIZE; - break; - } - if (size < TO_SIZE ((unsigned) 1)) - size = TO_SIZE ((unsigned) 1); - dot += TO_ADDR (size); - } - break; - - case lang_reloc_statement_enum: - exp_fold_tree (s->reloc_statement.addend_exp, - bfd_abs_section_ptr, &dot); - if (expld.result.valid_p) - s->reloc_statement.addend_value = expld.result.value; - else if (expld.phase == lang_final_phase_enum) - einfo (_("%F%P: invalid reloc statement\n")); - dot += TO_ADDR (bfd_get_reloc_size (s->reloc_statement.howto)); - break; - - case lang_input_section_enum: - { - asection *in = s->input_section.section; - - if ((in->flags & SEC_EXCLUDE) == 0) - dot += TO_ADDR (in->size); - } - break; - - case lang_input_statement_enum: - break; - - case lang_fill_statement_enum: - fill = s->fill_statement.fill; - break; - - case lang_assignment_statement_enum: - current_assign = &s->assignment_statement; - if (current_assign->exp->type.node_class != etree_assert) - { - const char *p = current_assign->exp->assign.dst; - - if (current_os == abs_output_section && p[0] == '.' && p[1] == 0) - prefer_next_section = TRUE; - - while (*p == '_') - ++p; - if (strcmp (p, "end") == 0) - *found_end = TRUE; - } - exp_fold_tree (s->assignment_statement.exp, - (current_os->bfd_section != NULL - ? current_os->bfd_section : bfd_und_section_ptr), - &dot); - break; - - case lang_padding_statement_enum: - dot += TO_ADDR (s->padding_statement.size); - break; - - case lang_group_statement_enum: - dot = lang_do_assignments_1 (s->group_statement.children.head, - current_os, fill, dot, found_end); - break; - - case lang_insert_statement_enum: - break; - - case lang_address_statement_enum: - break; - - default: - FAIL (); - break; - } - } - return dot; -} - -void -lang_do_assignments (lang_phase_type phase) -{ - bfd_boolean found_end = FALSE; - - current_section = NULL; - prefer_next_section = FALSE; - expld.phase = phase; - lang_statement_iteration++; - lang_do_assignments_1 (statement_list.head, - abs_output_section, NULL, 0, &found_end); -} - -/* For an assignment statement outside of an output section statement, - choose the best of neighbouring output sections to use for values - of "dot". */ - -asection * -section_for_dot (void) -{ - asection *s; - - /* Assignments belong to the previous output section, unless there - has been an assignment to "dot", in which case following - assignments belong to the next output section. (The assumption - is that an assignment to "dot" is setting up the address for the - next output section.) Except that past the assignment to "_end" - we always associate with the previous section. This exception is - for targets like SH that define an alloc .stack or other - weirdness after non-alloc sections. */ - if (current_section == NULL || prefer_next_section) - { - lang_statement_union_type *stmt; - lang_output_section_statement_type *os; - - for (stmt = (lang_statement_union_type *) current_assign; - stmt != NULL; - stmt = stmt->header.next) - if (stmt->header.type == lang_output_section_statement_enum) - break; - - os = &stmt->output_section_statement; - while (os != NULL - && !os->after_end - && (os->bfd_section == NULL - || (os->bfd_section->flags & SEC_EXCLUDE) != 0 - || bfd_section_removed_from_list (link_info.output_bfd, - os->bfd_section))) - os = os->next; - - if (current_section == NULL || os == NULL || !os->after_end) - { - if (os != NULL) - s = os->bfd_section; - else - s = link_info.output_bfd->section_last; - while (s != NULL - && ((s->flags & SEC_ALLOC) == 0 - || (s->flags & SEC_THREAD_LOCAL) != 0)) - s = s->prev; - if (s != NULL) - return s; - - return bfd_abs_section_ptr; - } - } - - s = current_section->bfd_section; - - /* The section may have been stripped. */ - while (s != NULL - && ((s->flags & SEC_EXCLUDE) != 0 - || (s->flags & SEC_ALLOC) == 0 - || (s->flags & SEC_THREAD_LOCAL) != 0 - || bfd_section_removed_from_list (link_info.output_bfd, s))) - s = s->prev; - if (s == NULL) - s = link_info.output_bfd->sections; - while (s != NULL - && ((s->flags & SEC_ALLOC) == 0 - || (s->flags & SEC_THREAD_LOCAL) != 0)) - s = s->next; - if (s != NULL) - return s; - - return bfd_abs_section_ptr; -} - -/* Array of __start/__stop/.startof./.sizeof/ symbols. */ - -static struct bfd_link_hash_entry **start_stop_syms; -static size_t start_stop_count = 0; -static size_t start_stop_alloc = 0; - -/* Give start/stop SYMBOL for SEC a preliminary definition, and add it - to start_stop_syms. */ - -static void -lang_define_start_stop (const char *symbol, asection *sec) -{ - struct bfd_link_hash_entry *h; - - h = bfd_define_start_stop (link_info.output_bfd, &link_info, symbol, sec); - if (h != NULL) - { - if (start_stop_count == start_stop_alloc) - { - start_stop_alloc = 2 * start_stop_alloc + 10; - start_stop_syms - = xrealloc (start_stop_syms, - start_stop_alloc * sizeof (*start_stop_syms)); - } - start_stop_syms[start_stop_count++] = h; - } -} - -/* Check for input sections whose names match references to - __start_SECNAME or __stop_SECNAME symbols. Give the symbols - preliminary definitions. */ - -static void -lang_init_start_stop (void) -{ - bfd *abfd; - asection *s; - char leading_char = bfd_get_symbol_leading_char (link_info.output_bfd); - - for (abfd = link_info.input_bfds; abfd != NULL; abfd = abfd->link.next) - for (s = abfd->sections; s != NULL; s = s->next) - { - const char *ps; - const char *secname = s->name; - - for (ps = secname; *ps != '\0'; ps++) - if (!ISALNUM ((unsigned char) *ps) && *ps != '_') - break; - if (*ps == '\0') - { - char *symbol = (char *) xmalloc (10 + strlen (secname)); - - symbol[0] = leading_char; - sprintf (symbol + (leading_char != 0), "__start_%s", secname); - lang_define_start_stop (symbol, s); - - symbol[1] = leading_char; - memcpy (symbol + 1 + (leading_char != 0), "__stop", 6); - lang_define_start_stop (symbol + 1, s); - - free (symbol); - } - } -} - -/* Iterate over start_stop_syms. */ - -static void -foreach_start_stop (void (*func) (struct bfd_link_hash_entry *)) -{ - size_t i; - - for (i = 0; i < start_stop_count; ++i) - func (start_stop_syms[i]); -} - -/* __start and __stop symbols are only supposed to be defined by the - linker for orphan sections, but we now extend that to sections that - map to an output section of the same name. The symbols were - defined early for --gc-sections, before we mapped input to output - sections, so undo those that don't satisfy this rule. */ - -static void -undef_start_stop (struct bfd_link_hash_entry *h) -{ - if (h->ldscript_def) - return; - - if (h->u.def.section->output_section == NULL - || h->u.def.section->output_section->owner != link_info.output_bfd - || strcmp (h->u.def.section->name, - h->u.def.section->output_section->name) != 0) - { - h->type = bfd_link_hash_undefined; - h->u.undef.abfd = NULL; - } -} - -static void -lang_undef_start_stop (void) -{ - foreach_start_stop (undef_start_stop); -} - -/* Check for output sections whose names match references to - .startof.SECNAME or .sizeof.SECNAME symbols. Give the symbols - preliminary definitions. */ - -static void -lang_init_startof_sizeof (void) -{ - asection *s; - - for (s = link_info.output_bfd->sections; s != NULL; s = s->next) - { - const char *secname = s->name; - char *symbol = (char *) xmalloc (10 + strlen (secname)); - - sprintf (symbol, ".startof.%s", secname); - lang_define_start_stop (symbol, s); - - memcpy (symbol + 1, ".size", 5); - lang_define_start_stop (symbol + 1, s); - free (symbol); - } -} - -/* Set .startof., .sizeof., __start and __stop symbols final values. */ - -static void -set_start_stop (struct bfd_link_hash_entry *h) -{ - if (h->ldscript_def - || h->type != bfd_link_hash_defined) - return; - - if (h->root.string[0] == '.') - { - /* .startof. or .sizeof. symbol. - .startof. already has final value. */ - if (h->root.string[2] == 'i') - { - /* .sizeof. */ - h->u.def.value = TO_ADDR (h->u.def.section->size); - h->u.def.section = bfd_abs_section_ptr; - } - } - else - { - /* __start or __stop symbol. */ - int has_lead = bfd_get_symbol_leading_char (link_info.output_bfd) != 0; - - h->u.def.section = h->u.def.section->output_section; - if (h->root.string[4 + has_lead] == 'o') - { - /* __stop_ */ - h->u.def.value = TO_ADDR (h->u.def.section->size); - } - } -} - -static void -lang_finalize_start_stop (void) -{ - foreach_start_stop (set_start_stop); -} - -static void -lang_end (void) -{ - struct bfd_link_hash_entry *h; - bfd_boolean warn; - - if ((bfd_link_relocatable (&link_info) && !link_info.gc_sections) - || bfd_link_dll (&link_info)) - warn = entry_from_cmdline; - else - warn = TRUE; - - /* Force the user to specify a root when generating a relocatable with - --gc-sections. */ - if (link_info.gc_sections && bfd_link_relocatable (&link_info) - && !(entry_from_cmdline || undef_from_cmdline)) - einfo (_("%P%F: gc-sections requires either an entry or " - "an undefined symbol\n")); - - if (entry_symbol.name == NULL) - { - /* No entry has been specified. Look for the default entry, but - don't warn if we don't find it. */ - entry_symbol.name = entry_symbol_default; - warn = FALSE; - } - - h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name, - FALSE, FALSE, TRUE); - if (h != NULL - && (h->type == bfd_link_hash_defined - || h->type == bfd_link_hash_defweak) - && h->u.def.section->output_section != NULL) - { - bfd_vma val; - - val = (h->u.def.value - + bfd_get_section_vma (link_info.output_bfd, - h->u.def.section->output_section) - + h->u.def.section->output_offset); - if (!bfd_set_start_address (link_info.output_bfd, val)) - einfo (_("%P%F:%s: can't set start address\n"), entry_symbol.name); - } - else - { - bfd_vma val; - const char *send; - - /* We couldn't find the entry symbol. Try parsing it as a - number. */ - val = bfd_scan_vma (entry_symbol.name, &send, 0); - if (*send == '\0') - { - if (!bfd_set_start_address (link_info.output_bfd, val)) - einfo (_("%P%F: can't set start address\n")); - } - else - { - asection *ts; - - /* Can't find the entry symbol, and it's not a number. Use - the first address in the text section. */ - ts = bfd_get_section_by_name (link_info.output_bfd, entry_section); - if (ts != NULL) - { - if (warn) - einfo (_("%P: warning: cannot find entry symbol %s;" - " defaulting to %V\n"), - entry_symbol.name, - bfd_get_section_vma (link_info.output_bfd, ts)); - if (!(bfd_set_start_address - (link_info.output_bfd, - bfd_get_section_vma (link_info.output_bfd, ts)))) - einfo (_("%P%F: can't set start address\n")); - } - else - { - if (warn) - einfo (_("%P: warning: cannot find entry symbol %s;" - " not setting start address\n"), - entry_symbol.name); - } - } - } -} - -/* This is a small function used when we want to ignore errors from - BFD. */ - -static void -ignore_bfd_errors (const char *fmt ATTRIBUTE_UNUSED, - va_list ap ATTRIBUTE_UNUSED) -{ - /* Don't do anything. */ -} - -/* Check that the architecture of all the input files is compatible - with the output file. Also call the backend to let it do any - other checking that is needed. */ - -static void -lang_check (void) -{ - lang_statement_union_type *file; - bfd *input_bfd; - const bfd_arch_info_type *compatible; - - for (file = file_chain.head; file != NULL; file = file->input_statement.next) - { -#ifdef ENABLE_PLUGINS - /* Don't check format of files claimed by plugin. */ - if (file->input_statement.flags.claimed) - continue; -#endif /* ENABLE_PLUGINS */ - input_bfd = file->input_statement.the_bfd; - compatible - = bfd_arch_get_compatible (input_bfd, link_info.output_bfd, - command_line.accept_unknown_input_arch); - - /* In general it is not possible to perform a relocatable - link between differing object formats when the input - file has relocations, because the relocations in the - input format may not have equivalent representations in - the output format (and besides BFD does not translate - relocs for other link purposes than a final link). */ - if ((bfd_link_relocatable (&link_info) - || link_info.emitrelocations) - && (compatible == NULL - || (bfd_get_flavour (input_bfd) - != bfd_get_flavour (link_info.output_bfd))) - && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0) - { - einfo (_("%P%F: Relocatable linking with relocations from" - " format %s (%B) to format %s (%B) is not supported\n"), - bfd_get_target (input_bfd), input_bfd, - bfd_get_target (link_info.output_bfd), link_info.output_bfd); - /* einfo with %F exits. */ - } - - if (compatible == NULL) - { - if (command_line.warn_mismatch) - einfo (_("%P%X: %s architecture of input file `%B'" - " is incompatible with %s output\n"), - bfd_printable_name (input_bfd), input_bfd, - bfd_printable_name (link_info.output_bfd)); - } - else if (bfd_count_sections (input_bfd)) - { - /* If the input bfd has no contents, it shouldn't set the - private data of the output bfd. */ - - 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. */ - if (!command_line.warn_mismatch) - pfn = bfd_set_error_handler (ignore_bfd_errors); - if (!bfd_merge_private_bfd_data (input_bfd, &link_info)) - { - if (command_line.warn_mismatch) - einfo (_("%P%X: failed to merge target specific data" - " of file %B\n"), input_bfd); - } - if (!command_line.warn_mismatch) - bfd_set_error_handler (pfn); - } - } -} - -/* Look through all the global common symbols and attach them to the - correct section. The -sort-common command line switch may be used - to roughly sort the entries by alignment. */ - -static void -lang_common (void) -{ - if (link_info.inhibit_common_definition) - return; - if (bfd_link_relocatable (&link_info) - && !command_line.force_common_definition) - return; - - if (!config.sort_common) - bfd_link_hash_traverse (link_info.hash, lang_one_common, NULL); - else - { - unsigned int power; - - if (config.sort_common == sort_descending) - { - for (power = 4; power > 0; power--) - bfd_link_hash_traverse (link_info.hash, lang_one_common, &power); - - power = 0; - bfd_link_hash_traverse (link_info.hash, lang_one_common, &power); - } - else - { - for (power = 0; power <= 4; power++) - bfd_link_hash_traverse (link_info.hash, lang_one_common, &power); - - power = (unsigned int) -1; - bfd_link_hash_traverse (link_info.hash, lang_one_common, &power); - } - } -} - -/* Place one common symbol in the correct section. */ - -static bfd_boolean -lang_one_common (struct bfd_link_hash_entry *h, void *info) -{ - unsigned int power_of_two; - bfd_vma size; - asection *section; - - if (h->type != bfd_link_hash_common) - return TRUE; - - size = h->u.c.size; - power_of_two = h->u.c.p->alignment_power; - - if (config.sort_common == sort_descending - && power_of_two < *(unsigned int *) info) - return TRUE; - else if (config.sort_common == sort_ascending - && power_of_two > *(unsigned int *) info) - return TRUE; - - section = h->u.c.p->section; - if (!bfd_define_common_symbol (link_info.output_bfd, &link_info, h)) - einfo (_("%P%F: Could not define common symbol `%T': %E\n"), - h->root.string); - - if (config.map_file != NULL) - { - static bfd_boolean header_printed; - int len; - char *name; - char buf[50]; - - if (!header_printed) - { - minfo (_("\nAllocating common symbols\n")); - minfo (_("Common symbol size file\n\n")); - header_printed = TRUE; - } - - name = bfd_demangle (link_info.output_bfd, h->root.string, - DMGL_ANSI | DMGL_PARAMS); - if (name == NULL) - { - minfo ("%s", h->root.string); - len = strlen (h->root.string); - } - else - { - minfo ("%s", name); - len = strlen (name); - free (name); - } - - if (len >= 19) - { - print_nl (); - len = 0; - } - while (len < 20) - { - print_space (); - ++len; - } - - minfo ("0x"); - if (size <= 0xffffffff) - sprintf (buf, "%lx", (unsigned long) size); - else - sprintf_vma (buf, size); - minfo ("%s", buf); - len = strlen (buf); - - while (len < 16) - { - print_space (); - ++len; - } - - minfo ("%B\n", section->owner); - } - - return TRUE; -} - -/* Handle a single orphan section S, placing the orphan into an appropriate - output section. The effects of the --orphan-handling command line - option are handled here. */ - -static void -ldlang_place_orphan (asection *s) -{ - if (config.orphan_handling == orphan_handling_discard) - { - lang_output_section_statement_type *os; - os = lang_output_section_statement_lookup (DISCARD_SECTION_NAME, 0, - TRUE); - if (os->addr_tree == NULL - && (bfd_link_relocatable (&link_info) - || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)) - os->addr_tree = exp_intop (0); - lang_add_section (&os->children, s, NULL, os); - } - else - { - lang_output_section_statement_type *os; - const char *name = s->name; - int constraint = 0; - - if (config.orphan_handling == orphan_handling_error) - einfo (_("%X%P: error: unplaced orphan section `%A' from `%B'.\n"), - s, s->owner); - - if (config.unique_orphan_sections || unique_section_p (s, NULL)) - constraint = SPECIAL; - - os = ldemul_place_orphan (s, name, constraint); - if (os == NULL) - { - os = lang_output_section_statement_lookup (name, constraint, TRUE); - if (os->addr_tree == NULL - && (bfd_link_relocatable (&link_info) - || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)) - os->addr_tree = exp_intop (0); - lang_add_section (&os->children, s, NULL, os); - } - - if (config.orphan_handling == orphan_handling_warn) - einfo (_("%P: warning: orphan section `%A' from `%B' being " - "placed in section `%s'.\n"), - s, s->owner, os->name); - } -} - -/* Run through the input files and ensure that every input section has - somewhere to go. If one is found without a destination then create - an input request and place it into the statement tree. */ - -static void -lang_place_orphans (void) -{ - LANG_FOR_EACH_INPUT_STATEMENT (file) - { - asection *s; - - for (s = file->the_bfd->sections; s != NULL; s = s->next) - { - if (s->output_section == NULL) - { - /* This section of the file is not attached, root - around for a sensible place for it to go. */ - - if (file->flags.just_syms) - bfd_link_just_syms (file->the_bfd, s, &link_info); - else if (lang_discard_section_p (s)) - s->output_section = bfd_abs_section_ptr; - else if (strcmp (s->name, "COMMON") == 0) - { - /* This is a lonely common section which must have - come from an archive. We attach to the section - with the wildcard. */ - if (!bfd_link_relocatable (&link_info) - || command_line.force_common_definition) - { - if (default_common_section == NULL) - default_common_section - = lang_output_section_statement_lookup (".bss", 0, - TRUE); - lang_add_section (&default_common_section->children, s, - NULL, default_common_section); - } - } - else - ldlang_place_orphan (s); - } - } - } -} - -void -lang_set_flags (lang_memory_region_type *ptr, const char *flags, int invert) -{ - flagword *ptr_flags; - - ptr_flags = invert ? &ptr->not_flags : &ptr->flags; - - while (*flags) - { - switch (*flags) - { - /* PR 17900: An exclamation mark in the attributes reverses - the sense of any of the attributes that follow. */ - case '!': - invert = !invert; - ptr_flags = invert ? &ptr->not_flags : &ptr->flags; - break; - - case 'A': case 'a': - *ptr_flags |= SEC_ALLOC; - break; - - case 'R': case 'r': - *ptr_flags |= SEC_READONLY; - break; - - case 'W': case 'w': - *ptr_flags |= SEC_DATA; - break; - - case 'X': case 'x': - *ptr_flags |= SEC_CODE; - break; - - case 'L': case 'l': - case 'I': case 'i': - *ptr_flags |= SEC_LOAD; - break; - - default: - einfo (_("%P%F: invalid character %c (%d) in flags\n"), - *flags, *flags); - break; - } - flags++; - } -} - -/* Call a function on each input file. This function will be called - on an archive, but not on the elements. */ - -void -lang_for_each_input_file (void (*func) (lang_input_statement_type *)) -{ - lang_input_statement_type *f; - - for (f = &input_file_chain.head->input_statement; - f != NULL; - f = &f->next_real_file->input_statement) - func (f); -} - -/* Call a function on each file. The function will be called on all - the elements of an archive which are included in the link, but will - not be called on the archive file itself. */ - -void -lang_for_each_file (void (*func) (lang_input_statement_type *)) -{ - LANG_FOR_EACH_INPUT_STATEMENT (f) - { - func (f); - } -} - -void -ldlang_add_file (lang_input_statement_type *entry) -{ - lang_statement_append (&file_chain, - (lang_statement_union_type *) entry, - &entry->next); - - /* The BFD linker needs to have a list of all input BFDs involved in - a link. */ - ASSERT (entry->the_bfd->link.next == NULL); - ASSERT (entry->the_bfd != link_info.output_bfd); - - *link_info.input_bfds_tail = entry->the_bfd; - link_info.input_bfds_tail = &entry->the_bfd->link.next; - entry->the_bfd->usrdata = entry; - bfd_set_gp_size (entry->the_bfd, g_switch_value); - - /* Look through the sections and check for any which should not be - included in the link. We need to do this now, so that we can - notice when the backend linker tries to report multiple - definition errors for symbols which are in sections we aren't - going to link. FIXME: It might be better to entirely ignore - symbols which are defined in sections which are going to be - discarded. This would require modifying the backend linker for - each backend which might set the SEC_LINK_ONCE flag. If we do - this, we should probably handle SEC_EXCLUDE in the same way. */ - - bfd_map_over_sections (entry->the_bfd, section_already_linked, entry); -} - -void -lang_add_output (const char *name, int from_script) -{ - /* Make -o on command line override OUTPUT in script. */ - if (!had_output_filename || !from_script) - { - output_filename = name; - had_output_filename = TRUE; - } -} - -static int -topower (int x) -{ - unsigned int i = 1; - int l; - - if (x < 0) - return -1; - - for (l = 0; l < 32; l++) - { - if (i >= (unsigned int) x) - return l; - i <<= 1; - } - - return 0; -} - -lang_output_section_statement_type * -lang_enter_output_section_statement (const char *output_section_statement_name, - etree_type *address_exp, - enum section_type sectype, - etree_type *align, - etree_type *subalign, - etree_type *ebase, - int constraint, - int align_with_input) -{ - lang_output_section_statement_type *os; - - os = lang_output_section_statement_lookup (output_section_statement_name, - constraint, TRUE); - current_section = os; - - if (os->addr_tree == NULL) - { - os->addr_tree = address_exp; - } - os->sectype = sectype; - if (sectype != noload_section) - os->flags = SEC_NO_FLAGS; - else - os->flags = SEC_NEVER_LOAD; - os->block_value = 1; - - /* Make next things chain into subchain of this. */ - push_stat_ptr (&os->children); - - os->align_lma_with_input = align_with_input == ALIGN_WITH_INPUT; - if (os->align_lma_with_input && align != NULL) - einfo (_("%F%P:%S: error: align with input and explicit align specified\n"), - NULL); - - os->subsection_alignment = - topower (exp_get_value_int (subalign, -1, "subsection alignment")); - os->section_alignment = - topower (exp_get_value_int (align, -1, "section alignment")); - - os->load_base = ebase; - return os; -} - -void -lang_final (void) -{ - lang_output_statement_type *new_stmt; - - new_stmt = new_stat (lang_output_statement, stat_ptr); - new_stmt->name = output_filename; -} - -/* Reset the current counters in the regions. */ - -void -lang_reset_memory_regions (void) -{ - lang_memory_region_type *p = lang_memory_region_list; - asection *o; - lang_output_section_statement_type *os; - - for (p = lang_memory_region_list; p != NULL; p = p->next) - { - p->current = p->origin; - p->last_os = NULL; - } - - for (os = &lang_output_section_statement.head->output_section_statement; - os != NULL; - os = os->next) - { - os->processed_vma = FALSE; - os->processed_lma = FALSE; - } - - for (o = link_info.output_bfd->sections; o != NULL; o = o->next) - { - /* Save the last size for possible use by bfd_relax_section. */ - o->rawsize = o->size; - o->size = 0; - } -} - -/* Worker for lang_gc_sections_1. */ - -static void -gc_section_callback (lang_wild_statement_type *ptr, - struct wildcard_list *sec ATTRIBUTE_UNUSED, - asection *section, - struct flag_info *sflag_info ATTRIBUTE_UNUSED, - lang_input_statement_type *file ATTRIBUTE_UNUSED, - void *data ATTRIBUTE_UNUSED) -{ - /* If the wild pattern was marked KEEP, the member sections - should be as well. */ - if (ptr->keep_sections) - section->flags |= SEC_KEEP; -} - -/* Iterate over sections marking them against GC. */ - -static void -lang_gc_sections_1 (lang_statement_union_type *s) -{ - for (; s != NULL; s = s->header.next) - { - switch (s->header.type) - { - case lang_wild_statement_enum: - walk_wild (&s->wild_statement, gc_section_callback, NULL); - break; - case lang_constructors_statement_enum: - lang_gc_sections_1 (constructor_list.head); - break; - case lang_output_section_statement_enum: - lang_gc_sections_1 (s->output_section_statement.children.head); - break; - case lang_group_statement_enum: - lang_gc_sections_1 (s->group_statement.children.head); - break; - default: - break; - } - } -} - -static void -lang_gc_sections (void) -{ - /* Keep all sections so marked in the link script. */ - lang_gc_sections_1 (statement_list.head); - - /* SEC_EXCLUDE is ignored when doing a relocatable link, except in - the special case of debug info. (See bfd/stabs.c) - Twiddle the flag here, to simplify later linker code. */ - if (bfd_link_relocatable (&link_info)) - { - LANG_FOR_EACH_INPUT_STATEMENT (f) - { - asection *sec; -#ifdef ENABLE_PLUGINS - if (f->flags.claimed) - continue; -#endif - for (sec = f->the_bfd->sections; sec != NULL; sec = sec->next) - if ((sec->flags & SEC_DEBUGGING) == 0) - sec->flags &= ~SEC_EXCLUDE; - } - } - - if (link_info.gc_sections) - bfd_gc_sections (link_info.output_bfd, &link_info); -} - -/* Worker for lang_find_relro_sections_1. */ - -static void -find_relro_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED, - struct wildcard_list *sec ATTRIBUTE_UNUSED, - asection *section, - struct flag_info *sflag_info ATTRIBUTE_UNUSED, - lang_input_statement_type *file ATTRIBUTE_UNUSED, - void *data) -{ - /* Discarded, excluded and ignored sections effectively have zero - size. */ - if (section->output_section != NULL - && section->output_section->owner == link_info.output_bfd - && (section->output_section->flags & SEC_EXCLUDE) == 0 - && !IGNORE_SECTION (section) - && section->size != 0) - { - bfd_boolean *has_relro_section = (bfd_boolean *) data; - *has_relro_section = TRUE; - } -} - -/* Iterate over sections for relro sections. */ - -static void -lang_find_relro_sections_1 (lang_statement_union_type *s, - seg_align_type *seg, - bfd_boolean *has_relro_section) -{ - if (*has_relro_section) - return; - - for (; s != NULL; s = s->header.next) - { - if (s == seg->relro_end_stat) - break; - - switch (s->header.type) - { - case lang_wild_statement_enum: - walk_wild (&s->wild_statement, - find_relro_section_callback, - has_relro_section); - break; - case lang_constructors_statement_enum: - lang_find_relro_sections_1 (constructor_list.head, - seg, has_relro_section); - break; - case lang_output_section_statement_enum: - lang_find_relro_sections_1 (s->output_section_statement.children.head, - seg, has_relro_section); - break; - case lang_group_statement_enum: - lang_find_relro_sections_1 (s->group_statement.children.head, - seg, has_relro_section); - break; - default: - break; - } - } -} - -static void -lang_find_relro_sections (void) -{ - bfd_boolean has_relro_section = FALSE; - - /* Check all sections in the link script. */ - - lang_find_relro_sections_1 (expld.dataseg.relro_start_stat, - &expld.dataseg, &has_relro_section); - - if (!has_relro_section) - link_info.relro = FALSE; -} - -/* Relax all sections until bfd_relax_section gives up. */ - -void -lang_relax_sections (bfd_boolean need_layout) -{ - if (RELAXATION_ENABLED) - { - /* We may need more than one relaxation pass. */ - int i = link_info.relax_pass; - - /* The backend can use it to determine the current pass. */ - link_info.relax_pass = 0; - - while (i--) - { - /* Keep relaxing until bfd_relax_section gives up. */ - bfd_boolean relax_again; - - link_info.relax_trip = -1; - do - { - link_info.relax_trip++; - - /* Note: pe-dll.c does something like this also. If you find - you need to change this code, you probably need to change - pe-dll.c also. DJ */ - - /* Do all the assignments with our current guesses as to - section sizes. */ - lang_do_assignments (lang_assigning_phase_enum); - - /* We must do this after lang_do_assignments, because it uses - size. */ - lang_reset_memory_regions (); - - /* Perform another relax pass - this time we know where the - globals are, so can make a better guess. */ - relax_again = FALSE; - lang_size_sections (&relax_again, FALSE); - } - while (relax_again); - - link_info.relax_pass++; - } - need_layout = TRUE; - } - - if (need_layout) - { - /* Final extra sizing to report errors. */ - lang_do_assignments (lang_assigning_phase_enum); - lang_reset_memory_regions (); - lang_size_sections (NULL, TRUE); - } -} - -#ifdef ENABLE_PLUGINS -/* Find the insert point for the plugin's replacement files. We - place them after the first claimed real object file, or if the - first claimed object is an archive member, after the last real - object file immediately preceding the archive. In the event - no objects have been claimed at all, we return the first dummy - object file on the list as the insert point; that works, but - the callee must be careful when relinking the file_chain as it - is not actually on that chain, only the statement_list and the - input_file list; in that case, the replacement files must be - inserted at the head of the file_chain. */ - -static lang_input_statement_type * -find_replacements_insert_point (void) -{ - lang_input_statement_type *claim1, *lastobject; - lastobject = &input_file_chain.head->input_statement; - for (claim1 = &file_chain.head->input_statement; - claim1 != NULL; - claim1 = &claim1->next->input_statement) - { - if (claim1->flags.claimed) - return claim1->flags.claim_archive ? lastobject : claim1; - /* Update lastobject if this is a real object file. */ - if (claim1->the_bfd != NULL && claim1->the_bfd->my_archive == NULL) - lastobject = claim1; - } - /* No files were claimed by the plugin. Choose the last object - file found on the list (maybe the first, dummy entry) as the - insert point. */ - return lastobject; -} - -/* Find where to insert ADD, an archive element or shared library - added during a rescan. */ - -static lang_statement_union_type ** -find_rescan_insertion (lang_input_statement_type *add) -{ - bfd *add_bfd = add->the_bfd; - lang_input_statement_type *f; - lang_input_statement_type *last_loaded = NULL; - lang_input_statement_type *before = NULL; - lang_statement_union_type **iter = NULL; - - if (add_bfd->my_archive != NULL) - add_bfd = add_bfd->my_archive; - - /* First look through the input file chain, to find an object file - before the one we've rescanned. Normal object files always - appear on both the input file chain and the file chain, so this - lets us get quickly to somewhere near the correct place on the - file chain if it is full of archive elements. Archives don't - appear on the file chain, but if an element has been extracted - then their input_statement->next points at it. */ - for (f = &input_file_chain.head->input_statement; - f != NULL; - f = &f->next_real_file->input_statement) - { - if (f->the_bfd == add_bfd) - { - before = last_loaded; - if (f->next != NULL) - return &f->next->input_statement.next; - } - if (f->the_bfd != NULL && f->next != NULL) - last_loaded = f; - } - - for (iter = before ? &before->next : &file_chain.head->input_statement.next; - *iter != NULL; - iter = &(*iter)->input_statement.next) - if ((*iter)->input_statement.the_bfd->my_archive == NULL) - break; - - return iter; -} - -/* Insert SRCLIST into DESTLIST after given element by chaining - on FIELD as the next-pointer. (Counterintuitively does not need - a pointer to the actual after-node itself, just its chain field.) */ - -static void -lang_list_insert_after (lang_statement_list_type *destlist, - lang_statement_list_type *srclist, - lang_statement_union_type **field) -{ - *(srclist->tail) = *field; - *field = srclist->head; - if (destlist->tail == field) - destlist->tail = srclist->tail; -} - -/* Detach new nodes added to DESTLIST since the time ORIGLIST - was taken as a copy of it and leave them in ORIGLIST. */ - -static void -lang_list_remove_tail (lang_statement_list_type *destlist, - lang_statement_list_type *origlist) -{ - union lang_statement_union **savetail; - /* Check that ORIGLIST really is an earlier state of DESTLIST. */ - ASSERT (origlist->head == destlist->head); - savetail = origlist->tail; - origlist->head = *(savetail); - origlist->tail = destlist->tail; - destlist->tail = savetail; - *savetail = NULL; -} -#endif /* ENABLE_PLUGINS */ - -/* Add NAME to the list of garbage collection entry points. */ - -void -lang_add_gc_name (const char *name) -{ - struct bfd_sym_chain *sym; - - if (name == NULL) - return; - - sym = (struct bfd_sym_chain *) stat_alloc (sizeof (*sym)); - - sym->next = link_info.gc_sym_list; - sym->name = name; - link_info.gc_sym_list = sym; -} - -/* Check relocations. */ - -static void -lang_check_relocs (void) -{ - if (link_info.check_relocs_after_open_input) - { - bfd *abfd; - - for (abfd = link_info.input_bfds; - abfd != (bfd *) NULL; abfd = abfd->link.next) - if (!bfd_link_check_relocs (abfd, &link_info)) - { - /* No object output, fail return. */ - config.make_executable = FALSE; - /* Note: we do not abort the loop, but rather - continue the scan in case there are other - bad relocations to report. */ - } - } -} - -/* Look through all output sections looking for places where we can - propagate forward the lma region. */ - -static void -lang_propagate_lma_regions (void) -{ - lang_output_section_statement_type *os; - - for (os = &lang_output_section_statement.head->output_section_statement; - os != NULL; - os = os->next) - { - if (os->prev != NULL - && os->lma_region == NULL - && os->load_base == NULL - && os->addr_tree == NULL - && os->region == os->prev->region) - os->lma_region = os->prev->lma_region; - } -} - -void -lang_process (void) -{ - /* Finalize dynamic list. */ - if (link_info.dynamic_list) - lang_finalize_version_expr_head (&link_info.dynamic_list->head); - - current_target = default_target; - - /* Open the output file. */ - lang_for_each_statement (ldlang_open_output); - init_opb (); - - ldemul_create_output_section_statements (); - - /* Add to the hash table all undefineds on the command line. */ - lang_place_undefineds (); - - if (!bfd_section_already_linked_table_init ()) - einfo (_("%P%F: Failed to create hash table\n")); - - /* Create a bfd for each input file. */ - current_target = default_target; - lang_statement_iteration++; - open_input_bfds (statement_list.head, OPEN_BFD_NORMAL); - -#ifdef ENABLE_PLUGINS - if (link_info.lto_plugin_active) - { - lang_statement_list_type added; - lang_statement_list_type files, inputfiles; - - /* Now all files are read, let the plugin(s) decide if there - are any more to be added to the link before we call the - emulation's after_open hook. We create a private list of - input statements for this purpose, which we will eventually - insert into the global statement list after the first claimed - file. */ - added = *stat_ptr; - /* We need to manipulate all three chains in synchrony. */ - files = file_chain; - inputfiles = input_file_chain; - if (plugin_call_all_symbols_read ()) - einfo (_("%P%F: %s: plugin reported error after all symbols read\n"), - plugin_error_plugin ()); - /* Open any newly added files, updating the file chains. */ - open_input_bfds (*added.tail, OPEN_BFD_NORMAL); - /* Restore the global list pointer now they have all been added. */ - lang_list_remove_tail (stat_ptr, &added); - /* And detach the fresh ends of the file lists. */ - lang_list_remove_tail (&file_chain, &files); - lang_list_remove_tail (&input_file_chain, &inputfiles); - /* Were any new files added? */ - if (added.head != NULL) - { - /* If so, we will insert them into the statement list immediately - after the first input file that was claimed by the plugin. */ - plugin_insert = find_replacements_insert_point (); - /* If a plugin adds input files without having claimed any, we - don't really have a good idea where to place them. Just putting - them at the start or end of the list is liable to leave them - outside the crtbegin...crtend range. */ - ASSERT (plugin_insert != NULL); - /* Splice the new statement list into the old one. */ - lang_list_insert_after (stat_ptr, &added, - &plugin_insert->header.next); - /* Likewise for the file chains. */ - lang_list_insert_after (&input_file_chain, &inputfiles, - &plugin_insert->next_real_file); - /* We must be careful when relinking file_chain; we may need to - insert the new files at the head of the list if the insert - point chosen is the dummy first input file. */ - if (plugin_insert->filename) - lang_list_insert_after (&file_chain, &files, &plugin_insert->next); - else - lang_list_insert_after (&file_chain, &files, &file_chain.head); - - /* Rescan archives in case new undefined symbols have appeared. */ - files = file_chain; - lang_statement_iteration++; - open_input_bfds (statement_list.head, OPEN_BFD_RESCAN); - lang_list_remove_tail (&file_chain, &files); - while (files.head != NULL) - { - lang_statement_union_type **insert; - lang_statement_union_type **iter, *temp; - bfd *my_arch; - - insert = find_rescan_insertion (&files.head->input_statement); - /* All elements from an archive can be added at once. */ - iter = &files.head->input_statement.next; - my_arch = files.head->input_statement.the_bfd->my_archive; - if (my_arch != NULL) - for (; *iter != NULL; iter = &(*iter)->input_statement.next) - if ((*iter)->input_statement.the_bfd->my_archive != my_arch) - break; - temp = *insert; - *insert = files.head; - files.head = *iter; - *iter = temp; - if (my_arch != NULL) - { - lang_input_statement_type *parent = my_arch->usrdata; - if (parent != NULL) - parent->next = (lang_statement_union_type *) - ((char *) iter - - offsetof (lang_input_statement_type, next)); - } - } - } - } -#endif /* ENABLE_PLUGINS */ - - /* Make sure that nobody has tried to add a symbol to this list - before now. */ - ASSERT (link_info.gc_sym_list == NULL); - - link_info.gc_sym_list = &entry_symbol; - - if (entry_symbol.name == NULL) - { - link_info.gc_sym_list = ldlang_undef_chain_list_head; - - /* entry_symbol is normally initialied by a ENTRY definition in the - linker script or the -e command line option. But if neither of - these have been used, the target specific backend may still have - provided an entry symbol via a call to lang_default_entry(). - Unfortunately this value will not be processed until lang_end() - is called, long after this function has finished. So detect this - case here and add the target's entry symbol to the list of starting - points for garbage collection resolution. */ - lang_add_gc_name (entry_symbol_default); - } - - lang_add_gc_name (link_info.init_function); - lang_add_gc_name (link_info.fini_function); - - ldemul_after_open (); - if (config.map_file != NULL) - lang_print_asneeded (); - - bfd_section_already_linked_table_free (); - - /* Make sure that we're not mixing architectures. We call this - after all the input files have been opened, but before we do any - other processing, so that any operations merge_private_bfd_data - does on the output file will be known during the rest of the - link. */ - lang_check (); - - /* Handle .exports instead of a version script if we're told to do so. */ - if (command_line.version_exports_section) - lang_do_version_exports_section (); - - /* Build all sets based on the information gathered from the input - files. */ - ldctor_build_sets (); - - /* Give initial values for __start and __stop symbols, so that ELF - gc_sections will keep sections referenced by these symbols. Must - be done before lang_do_assignments below. */ - if (config.build_constructors) - lang_init_start_stop (); - - /* PR 13683: We must rerun the assignments prior to running garbage - collection in order to make sure that all symbol aliases are resolved. */ - lang_do_assignments (lang_mark_phase_enum); - - lang_do_memory_regions(); - expld.phase = lang_first_phase_enum; - - /* Size up the common data. */ - lang_common (); - - /* Remove unreferenced sections if asked to. */ - lang_gc_sections (); - - /* Check relocations. */ - lang_check_relocs (); - - ldemul_after_check_relocs (); - - /* Update wild statements. */ - update_wild_statements (statement_list.head); - - /* Run through the contours of the script and attach input sections - to the correct output sections. */ - lang_statement_iteration++; - map_input_to_output_sections (statement_list.head, NULL, NULL); - - process_insert_statements (); - - /* Find any sections not attached explicitly and handle them. */ - lang_place_orphans (); - - if (!bfd_link_relocatable (&link_info)) - { - asection *found; - - /* Merge SEC_MERGE sections. This has to be done after GC of - sections, so that GCed sections are not merged, but before - assigning dynamic symbols, since removing whole input sections - is hard then. */ - bfd_merge_sections (link_info.output_bfd, &link_info); - - /* Look for a text section and set the readonly attribute in it. */ - found = bfd_get_section_by_name (link_info.output_bfd, ".text"); - - if (found != NULL) - { - if (config.text_read_only) - found->flags |= SEC_READONLY; - else - found->flags &= ~SEC_READONLY; - } - } - - /* Copy forward lma regions for output sections in same lma region. */ - lang_propagate_lma_regions (); - - /* Defining __start/__stop symbols early for --gc-sections to work - around a glibc build problem can result in these symbols being - defined when they should not be. Fix them now. */ - if (config.build_constructors) - lang_undef_start_stop (); - - /* Define .startof./.sizeof. symbols with preliminary values before - dynamic symbols are created. */ - if (!bfd_link_relocatable (&link_info)) - lang_init_startof_sizeof (); - - /* Do anything special before sizing sections. This is where ELF - and other back-ends size dynamic sections. */ - ldemul_before_allocation (); - - /* We must record the program headers before we try to fix the - section positions, since they will affect SIZEOF_HEADERS. */ - lang_record_phdrs (); - - /* Check relro sections. */ - if (link_info.relro && !bfd_link_relocatable (&link_info)) - lang_find_relro_sections (); - - /* Size up the sections. */ - lang_size_sections (NULL, !RELAXATION_ENABLED); - - /* See if anything special should be done now we know how big - everything is. This is where relaxation is done. */ - ldemul_after_allocation (); - - /* Fix any __start, __stop, .startof. or .sizeof. symbols. */ - lang_finalize_start_stop (); - - /* Do all the assignments, now that we know the final resting places - of all the symbols. */ - lang_do_assignments (lang_final_phase_enum); - - ldemul_finish (); - - /* Convert absolute symbols to section relative. */ - ldexp_finalize_syms (); - - /* Make sure that the section addresses make sense. */ - if (command_line.check_section_addresses) - lang_check_section_addresses (); - - /* Check any required symbols are known. */ - ldlang_check_require_defined_symbols (); - - lang_end (); -} - -/* EXPORTED TO YACC */ - -void -lang_add_wild (struct wildcard_spec *filespec, - struct wildcard_list *section_list, - bfd_boolean keep_sections) -{ - struct wildcard_list *curr, *next; - lang_wild_statement_type *new_stmt; - - /* Reverse the list as the parser puts it back to front. */ - for (curr = section_list, section_list = NULL; - curr != NULL; - section_list = curr, curr = next) - { - next = curr->next; - curr->next = section_list; - } - - if (filespec != NULL && filespec->name != NULL) - { - if (strcmp (filespec->name, "*") == 0) - filespec->name = NULL; - else if (!wildcardp (filespec->name)) - lang_has_input_file = TRUE; - } - - new_stmt = new_stat (lang_wild_statement, stat_ptr); - new_stmt->filename = NULL; - new_stmt->filenames_sorted = FALSE; - new_stmt->section_flag_list = NULL; - new_stmt->exclude_name_list = NULL; - if (filespec != NULL) - { - new_stmt->filename = filespec->name; - new_stmt->filenames_sorted = filespec->sorted == by_name; - new_stmt->section_flag_list = filespec->section_flag_list; - new_stmt->exclude_name_list = filespec->exclude_name_list; - } - new_stmt->section_list = section_list; - new_stmt->keep_sections = keep_sections; - lang_list_init (&new_stmt->children); - analyze_walk_wild_section_handler (new_stmt); -} - -void -lang_section_start (const char *name, etree_type *address, - const segment_type *segment) -{ - lang_address_statement_type *ad; - - ad = new_stat (lang_address_statement, stat_ptr); - ad->section_name = name; - ad->address = address; - ad->segment = segment; -} - -/* Set the start symbol to NAME. CMDLINE is nonzero if this is called - because of a -e argument on the command line, or zero if this is - called by ENTRY in a linker script. Command line arguments take - precedence. */ - -void -lang_add_entry (const char *name, bfd_boolean cmdline) -{ - if (entry_symbol.name == NULL - || cmdline - || !entry_from_cmdline) - { - entry_symbol.name = name; - entry_from_cmdline = cmdline; - } -} - -/* Set the default start symbol to NAME. .em files should use this, - not lang_add_entry, to override the use of "start" if neither the - linker script nor the command line specifies an entry point. NAME - must be permanently allocated. */ -void -lang_default_entry (const char *name) -{ - entry_symbol_default = name; -} - -void -lang_add_target (const char *name) -{ - lang_target_statement_type *new_stmt; - - new_stmt = new_stat (lang_target_statement, stat_ptr); - new_stmt->target = name; -} - -void -lang_add_map (const char *name) -{ - while (*name) - { - switch (*name) - { - case 'F': - map_option_f = TRUE; - break; - } - name++; - } -} - -void -lang_add_fill (fill_type *fill) -{ - lang_fill_statement_type *new_stmt; - - new_stmt = new_stat (lang_fill_statement, stat_ptr); - new_stmt->fill = fill; -} - -void -lang_add_data (int type, union etree_union *exp) -{ - lang_data_statement_type *new_stmt; - - new_stmt = new_stat (lang_data_statement, stat_ptr); - new_stmt->exp = exp; - new_stmt->type = type; -} - -/* Create a new reloc statement. RELOC is the BFD relocation type to - generate. HOWTO is the corresponding howto structure (we could - look this up, but the caller has already done so). SECTION is the - section to generate a reloc against, or NAME is the name of the - symbol to generate a reloc against. Exactly one of SECTION and - NAME must be NULL. ADDEND is an expression for the addend. */ - -void -lang_add_reloc (bfd_reloc_code_real_type reloc, - reloc_howto_type *howto, - asection *section, - const char *name, - union etree_union *addend) -{ - lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr); - - p->reloc = reloc; - p->howto = howto; - p->section = section; - p->name = name; - p->addend_exp = addend; - - p->addend_value = 0; - p->output_section = NULL; - p->output_offset = 0; -} - -lang_assignment_statement_type * -lang_add_assignment (etree_type *exp) -{ - lang_assignment_statement_type *new_stmt; - - new_stmt = new_stat (lang_assignment_statement, stat_ptr); - new_stmt->exp = exp; - return new_stmt; -} - -void -lang_add_attribute (enum statement_enum attribute) -{ - new_statement (attribute, sizeof (lang_statement_header_type), stat_ptr); -} - -void -lang_startup (const char *name) -{ - if (first_file->filename != NULL) - { - einfo (_("%P%F: multiple STARTUP files\n")); - } - first_file->filename = name; - first_file->local_sym_name = name; - first_file->flags.real = TRUE; -} - -void -lang_float (bfd_boolean maybe) -{ - lang_float_flag = maybe; -} - - -/* Work out the load- and run-time regions from a script statement, and - store them in *LMA_REGION and *REGION respectively. - - MEMSPEC is the name of the run-time region, or the value of - DEFAULT_MEMORY_REGION if the statement didn't specify one. - LMA_MEMSPEC is the name of the load-time region, or null if the - statement didn't specify one.HAVE_LMA_P is TRUE if the statement - had an explicit load address. - - It is an error to specify both a load region and a load address. */ - -static void -lang_get_regions (lang_memory_region_type **region, - lang_memory_region_type **lma_region, - const char *memspec, - const char *lma_memspec, - bfd_boolean have_lma, - bfd_boolean have_vma) -{ - *lma_region = lang_memory_region_lookup (lma_memspec, FALSE); - - /* If no runtime region or VMA has been specified, but the load region - has been specified, then use the load region for the runtime region - as well. */ - if (lma_memspec != NULL - && !have_vma - && strcmp (memspec, DEFAULT_MEMORY_REGION) == 0) - *region = *lma_region; - else - *region = lang_memory_region_lookup (memspec, FALSE); - - if (have_lma && lma_memspec != 0) - einfo (_("%X%P:%S: section has both a load address and a load region\n"), - NULL); -} - -void -lang_leave_output_section_statement (fill_type *fill, const char *memspec, - lang_output_section_phdr_list *phdrs, - const char *lma_memspec) -{ - lang_get_regions (¤t_section->region, - ¤t_section->lma_region, - memspec, lma_memspec, - current_section->load_base != NULL, - current_section->addr_tree != NULL); - - current_section->fill = fill; - current_section->phdrs = phdrs; - pop_stat_ptr (); -} - -void -lang_statement_append (lang_statement_list_type *list, - lang_statement_union_type *element, - lang_statement_union_type **field) -{ - *(list->tail) = element; - list->tail = field; -} - -/* Set the output format type. -oformat overrides scripts. */ - -void -lang_add_output_format (const char *format, - const char *big, - const char *little, - int from_script) -{ - if (output_target == NULL || !from_script) - { - if (command_line.endian == ENDIAN_BIG - && big != NULL) - format = big; - else if (command_line.endian == ENDIAN_LITTLE - && little != NULL) - format = little; - - output_target = format; - } -} - -void -lang_add_insert (const char *where, int is_before) -{ - lang_insert_statement_type *new_stmt; - - new_stmt = new_stat (lang_insert_statement, stat_ptr); - new_stmt->where = where; - new_stmt->is_before = is_before; - saved_script_handle = previous_script_handle; -} - -/* Enter a group. This creates a new lang_group_statement, and sets - stat_ptr to build new statements within the group. */ - -void -lang_enter_group (void) -{ - lang_group_statement_type *g; - - g = new_stat (lang_group_statement, stat_ptr); - lang_list_init (&g->children); - push_stat_ptr (&g->children); -} - -/* Leave a group. This just resets stat_ptr to start writing to the - regular list of statements again. Note that this will not work if - groups can occur inside anything else which can adjust stat_ptr, - but currently they can't. */ - -void -lang_leave_group (void) -{ - pop_stat_ptr (); -} - -/* Add a new program header. This is called for each entry in a PHDRS - command in a linker script. */ - -void -lang_new_phdr (const char *name, - etree_type *type, - bfd_boolean filehdr, - bfd_boolean phdrs, - etree_type *at, - etree_type *flags) -{ - struct lang_phdr *n, **pp; - bfd_boolean hdrs; - - n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr)); - n->next = NULL; - n->name = name; - n->type = exp_get_value_int (type, 0, "program header type"); - n->filehdr = filehdr; - n->phdrs = phdrs; - n->at = at; - n->flags = flags; - - hdrs = n->type == 1 && (phdrs || filehdr); - - for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next) - if (hdrs - && (*pp)->type == 1 - && !((*pp)->filehdr || (*pp)->phdrs)) - { - einfo (_("%X%P:%S: PHDRS and FILEHDR are not supported" - " when prior PT_LOAD headers lack them\n"), NULL); - hdrs = FALSE; - } - - *pp = n; -} - -/* Record the program header information in the output BFD. FIXME: We - should not be calling an ELF specific function here. */ - -static void -lang_record_phdrs (void) -{ - unsigned int alc; - asection **secs; - lang_output_section_phdr_list *last; - struct lang_phdr *l; - lang_output_section_statement_type *os; - - alc = 10; - secs = (asection **) xmalloc (alc * sizeof (asection *)); - last = NULL; - - for (l = lang_phdr_list; l != NULL; l = l->next) - { - unsigned int c; - flagword flags; - bfd_vma at; - - c = 0; - for (os = &lang_output_section_statement.head->output_section_statement; - os != NULL; - os = os->next) - { - lang_output_section_phdr_list *pl; - - if (os->constraint < 0) - continue; - - pl = os->phdrs; - if (pl != NULL) - last = pl; - else - { - if (os->sectype == noload_section - || os->bfd_section == NULL - || (os->bfd_section->flags & SEC_ALLOC) == 0) - continue; - - /* Don't add orphans to PT_INTERP header. */ - if (l->type == 3) - continue; - - if (last == NULL) - { - lang_output_section_statement_type *tmp_os; - - /* If we have not run across a section with a program - header assigned to it yet, then scan forwards to find - one. This prevents inconsistencies in the linker's - behaviour when a script has specified just a single - header and there are sections in that script which are - not assigned to it, and which occur before the first - use of that header. See here for more details: - http://sourceware.org/ml/binutils/2007-02/msg00291.html */ - for (tmp_os = os; tmp_os; tmp_os = tmp_os->next) - if (tmp_os->phdrs) - { - last = tmp_os->phdrs; - break; - } - if (last == NULL) - einfo (_("%F%P: no sections assigned to phdrs\n")); - } - pl = last; - } - - if (os->bfd_section == NULL) - continue; - - for (; pl != NULL; pl = pl->next) - { - if (strcmp (pl->name, l->name) == 0) - { - if (c >= alc) - { - alc *= 2; - secs = (asection **) xrealloc (secs, - alc * sizeof (asection *)); - } - secs[c] = os->bfd_section; - ++c; - pl->used = TRUE; - } - } - } - - if (l->flags == NULL) - flags = 0; - else - flags = exp_get_vma (l->flags, 0, "phdr flags"); - - if (l->at == NULL) - at = 0; - else - at = exp_get_vma (l->at, 0, "phdr load address"); - - if (!bfd_record_phdr (link_info.output_bfd, l->type, - l->flags != NULL, flags, l->at != NULL, - at, l->filehdr, l->phdrs, c, secs)) - einfo (_("%F%P: bfd_record_phdr failed: %E\n")); - } - - free (secs); - - /* Make sure all the phdr assignments succeeded. */ - for (os = &lang_output_section_statement.head->output_section_statement; - os != NULL; - os = os->next) - { - lang_output_section_phdr_list *pl; - - if (os->constraint < 0 - || os->bfd_section == NULL) - continue; - - 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"), - os->name, pl->name); - } -} - -/* Record a list of sections which may not be cross referenced. */ - -void -lang_add_nocrossref (lang_nocrossref_type *l) -{ - struct lang_nocrossrefs *n; - - n = (struct lang_nocrossrefs *) xmalloc (sizeof *n); - n->next = nocrossref_list; - n->list = l; - n->onlyfirst = FALSE; - nocrossref_list = n; - - /* Set notice_all so that we get informed about all symbols. */ - link_info.notice_all = TRUE; -} - -/* Record a section that cannot be referenced from a list of sections. */ - -void -lang_add_nocrossref_to (lang_nocrossref_type *l) -{ - lang_add_nocrossref (l); - nocrossref_list->onlyfirst = TRUE; -} - -/* Overlay handling. We handle overlays with some static variables. */ - -/* The overlay virtual address. */ -static etree_type *overlay_vma; -/* And subsection alignment. */ -static etree_type *overlay_subalign; - -/* An expression for the maximum section size seen so far. */ -static etree_type *overlay_max; - -/* A list of all the sections in this overlay. */ - -struct overlay_list { - struct overlay_list *next; - lang_output_section_statement_type *os; -}; - -static struct overlay_list *overlay_list; - -/* Start handling an overlay. */ - -void -lang_enter_overlay (etree_type *vma_expr, etree_type *subalign) -{ - /* The grammar should prevent nested overlays from occurring. */ - ASSERT (overlay_vma == NULL - && overlay_subalign == NULL - && overlay_max == NULL); - - overlay_vma = vma_expr; - overlay_subalign = subalign; -} - -/* Start a section in an overlay. We handle this by calling - lang_enter_output_section_statement with the correct VMA. - lang_leave_overlay sets up the LMA and memory regions. */ - -void -lang_enter_overlay_section (const char *name) -{ - struct overlay_list *n; - etree_type *size; - - lang_enter_output_section_statement (name, overlay_vma, overlay_section, - 0, overlay_subalign, 0, 0, 0); - - /* If this is the first section, then base the VMA of future - sections on this one. This will work correctly even if `.' is - used in the addresses. */ - if (overlay_list == NULL) - overlay_vma = exp_nameop (ADDR, name); - - /* Remember the section. */ - n = (struct overlay_list *) xmalloc (sizeof *n); - n->os = current_section; - n->next = overlay_list; - overlay_list = n; - - size = exp_nameop (SIZEOF, name); - - /* Arrange to work out the maximum section end address. */ - if (overlay_max == NULL) - overlay_max = size; - else - overlay_max = exp_binop (MAX_K, overlay_max, size); -} - -/* Finish a section in an overlay. There isn't any special to do - here. */ - -void -lang_leave_overlay_section (fill_type *fill, - lang_output_section_phdr_list *phdrs) -{ - const char *name; - char *clean, *s2; - const char *s1; - char *buf; - - name = current_section->name; - - /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory - region and that no load-time region has been specified. It doesn't - really matter what we say here, since lang_leave_overlay will - override it. */ - lang_leave_output_section_statement (fill, DEFAULT_MEMORY_REGION, phdrs, 0); - - /* Define the magic symbols. */ - - clean = (char *) xmalloc (strlen (name) + 1); - s2 = clean; - for (s1 = name; *s1 != '\0'; s1++) - if (ISALNUM (*s1) || *s1 == '_') - *s2++ = *s1; - *s2 = '\0'; - - buf = (char *) xmalloc (strlen (clean) + sizeof "__load_start_"); - sprintf (buf, "__load_start_%s", clean); - lang_add_assignment (exp_provide (buf, - exp_nameop (LOADADDR, name), - FALSE)); - - buf = (char *) xmalloc (strlen (clean) + sizeof "__load_stop_"); - sprintf (buf, "__load_stop_%s", clean); - lang_add_assignment (exp_provide (buf, - exp_binop ('+', - exp_nameop (LOADADDR, name), - exp_nameop (SIZEOF, name)), - FALSE)); - - free (clean); -} - -/* Finish an overlay. If there are any overlay wide settings, this - looks through all the sections in the overlay and sets them. */ - -void -lang_leave_overlay (etree_type *lma_expr, - int nocrossrefs, - fill_type *fill, - const char *memspec, - lang_output_section_phdr_list *phdrs, - const char *lma_memspec) -{ - lang_memory_region_type *region; - lang_memory_region_type *lma_region; - struct overlay_list *l; - lang_nocrossref_type *nocrossref; - - lang_get_regions (®ion, &lma_region, - memspec, lma_memspec, - lma_expr != NULL, FALSE); - - nocrossref = NULL; - - /* After setting the size of the last section, set '.' to end of the - overlay region. */ - if (overlay_list != NULL) - { - overlay_list->os->update_dot = 1; - overlay_list->os->update_dot_tree - = exp_assign (".", exp_binop ('+', overlay_vma, overlay_max), FALSE); - } - - l = overlay_list; - while (l != NULL) - { - struct overlay_list *next; - - if (fill != NULL && l->os->fill == NULL) - l->os->fill = fill; - - l->os->region = region; - l->os->lma_region = lma_region; - - /* The first section has the load address specified in the - OVERLAY statement. The rest are worked out from that. - The base address is not needed (and should be null) if - an LMA region was specified. */ - if (l->next == 0) - { - l->os->load_base = lma_expr; - l->os->sectype = normal_section; - } - if (phdrs != NULL && l->os->phdrs == NULL) - l->os->phdrs = phdrs; - - if (nocrossrefs) - { - lang_nocrossref_type *nc; - - nc = (lang_nocrossref_type *) xmalloc (sizeof *nc); - nc->name = l->os->name; - nc->next = nocrossref; - nocrossref = nc; - } - - next = l->next; - free (l); - l = next; - } - - if (nocrossref != NULL) - lang_add_nocrossref (nocrossref); - - overlay_vma = NULL; - overlay_list = NULL; - overlay_max = NULL; - overlay_subalign = NULL; -} - -/* Version handling. This is only useful for ELF. */ - -/* If PREV is NULL, return first version pattern matching particular symbol. - If PREV is non-NULL, return first version pattern matching particular - symbol after PREV (previously returned by lang_vers_match). */ - -static struct bfd_elf_version_expr * -lang_vers_match (struct bfd_elf_version_expr_head *head, - struct bfd_elf_version_expr *prev, - const char *sym) -{ - const char *c_sym; - const char *cxx_sym = sym; - const char *java_sym = sym; - struct bfd_elf_version_expr *expr = NULL; - enum demangling_styles curr_style; - - curr_style = CURRENT_DEMANGLING_STYLE; - cplus_demangle_set_style (no_demangling); - c_sym = bfd_demangle (link_info.output_bfd, sym, DMGL_NO_OPTS); - if (!c_sym) - c_sym = sym; - cplus_demangle_set_style (curr_style); - - if (head->mask & BFD_ELF_VERSION_CXX_TYPE) - { - cxx_sym = bfd_demangle (link_info.output_bfd, sym, - DMGL_PARAMS | DMGL_ANSI); - if (!cxx_sym) - cxx_sym = sym; - } - if (head->mask & BFD_ELF_VERSION_JAVA_TYPE) - { - java_sym = bfd_demangle (link_info.output_bfd, sym, DMGL_JAVA); - if (!java_sym) - java_sym = sym; - } - - if (head->htab && (prev == NULL || prev->literal)) - { - struct bfd_elf_version_expr e; - - switch (prev ? prev->mask : 0) - { - case 0: - if (head->mask & BFD_ELF_VERSION_C_TYPE) - { - e.pattern = c_sym; - expr = (struct bfd_elf_version_expr *) - htab_find ((htab_t) head->htab, &e); - while (expr && strcmp (expr->pattern, c_sym) == 0) - if (expr->mask == BFD_ELF_VERSION_C_TYPE) - goto out_ret; - else - expr = expr->next; - } - /* Fallthrough */ - case BFD_ELF_VERSION_C_TYPE: - if (head->mask & BFD_ELF_VERSION_CXX_TYPE) - { - e.pattern = cxx_sym; - expr = (struct bfd_elf_version_expr *) - htab_find ((htab_t) head->htab, &e); - while (expr && strcmp (expr->pattern, cxx_sym) == 0) - if (expr->mask == BFD_ELF_VERSION_CXX_TYPE) - goto out_ret; - else - expr = expr->next; - } - /* Fallthrough */ - case BFD_ELF_VERSION_CXX_TYPE: - if (head->mask & BFD_ELF_VERSION_JAVA_TYPE) - { - e.pattern = java_sym; - expr = (struct bfd_elf_version_expr *) - htab_find ((htab_t) head->htab, &e); - while (expr && strcmp (expr->pattern, java_sym) == 0) - if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE) - goto out_ret; - else - expr = expr->next; - } - /* Fallthrough */ - default: - break; - } - } - - /* Finally, try the wildcards. */ - if (prev == NULL || prev->literal) - expr = head->remaining; - else - expr = prev->next; - for (; expr; expr = expr->next) - { - const char *s; - - if (!expr->pattern) - continue; - - if (expr->pattern[0] == '*' && expr->pattern[1] == '\0') - break; - - if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE) - s = java_sym; - else if (expr->mask == BFD_ELF_VERSION_CXX_TYPE) - s = cxx_sym; - else - s = c_sym; - if (fnmatch (expr->pattern, s, 0) == 0) - break; - } - - out_ret: - if (c_sym != sym) - free ((char *) c_sym); - if (cxx_sym != sym) - free ((char *) cxx_sym); - if (java_sym != sym) - free ((char *) java_sym); - return expr; -} - -/* Return NULL if the PATTERN argument is a glob pattern, otherwise, - return a pointer to the symbol name with any backslash quotes removed. */ - -static const char * -realsymbol (const char *pattern) -{ - const char *p; - bfd_boolean changed = FALSE, backslash = FALSE; - char *s, *symbol = (char *) xmalloc (strlen (pattern) + 1); - - for (p = pattern, s = symbol; *p != '\0'; ++p) - { - /* It is a glob pattern only if there is no preceding - backslash. */ - if (backslash) - { - /* Remove the preceding backslash. */ - *(s - 1) = *p; - backslash = FALSE; - changed = TRUE; - } - else - { - if (*p == '?' || *p == '*' || *p == '[') - { - free (symbol); - return NULL; - } - - *s++ = *p; - backslash = *p == '\\'; - } - } - - if (changed) - { - *s = '\0'; - return symbol; - } - else - { - free (symbol); - return pattern; - } -} - -/* This is called for each variable name or match expression. NEW_NAME is - the name of the symbol to match, or, if LITERAL_P is FALSE, a glob - pattern to be matched against symbol names. */ - -struct bfd_elf_version_expr * -lang_new_vers_pattern (struct bfd_elf_version_expr *orig, - const char *new_name, - const char *lang, - bfd_boolean literal_p) -{ - struct bfd_elf_version_expr *ret; - - ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret); - ret->next = orig; - ret->symver = 0; - ret->script = 0; - ret->literal = TRUE; - ret->pattern = literal_p ? new_name : realsymbol (new_name); - if (ret->pattern == NULL) - { - ret->pattern = new_name; - ret->literal = FALSE; - } - - if (lang == NULL || strcasecmp (lang, "C") == 0) - ret->mask = BFD_ELF_VERSION_C_TYPE; - else if (strcasecmp (lang, "C++") == 0) - ret->mask = BFD_ELF_VERSION_CXX_TYPE; - else if (strcasecmp (lang, "Java") == 0) - ret->mask = BFD_ELF_VERSION_JAVA_TYPE; - else - { - einfo (_("%X%P: unknown language `%s' in version information\n"), - lang); - ret->mask = BFD_ELF_VERSION_C_TYPE; - } - - return ldemul_new_vers_pattern (ret); -} - -/* This is called for each set of variable names and match - expressions. */ - -struct bfd_elf_version_tree * -lang_new_vers_node (struct bfd_elf_version_expr *globals, - struct bfd_elf_version_expr *locals) -{ - struct bfd_elf_version_tree *ret; - - ret = (struct bfd_elf_version_tree *) xcalloc (1, sizeof *ret); - ret->globals.list = globals; - ret->locals.list = locals; - ret->match = lang_vers_match; - ret->name_indx = (unsigned int) -1; - return ret; -} - -/* This static variable keeps track of version indices. */ - -static int version_index; - -static hashval_t -version_expr_head_hash (const void *p) -{ - const struct bfd_elf_version_expr *e = - (const struct bfd_elf_version_expr *) p; - - return htab_hash_string (e->pattern); -} - -static int -version_expr_head_eq (const void *p1, const void *p2) -{ - const struct bfd_elf_version_expr *e1 = - (const struct bfd_elf_version_expr *) p1; - const struct bfd_elf_version_expr *e2 = - (const struct bfd_elf_version_expr *) p2; - - return strcmp (e1->pattern, e2->pattern) == 0; -} - -static void -lang_finalize_version_expr_head (struct bfd_elf_version_expr_head *head) -{ - size_t count = 0; - struct bfd_elf_version_expr *e, *next; - struct bfd_elf_version_expr **list_loc, **remaining_loc; - - for (e = head->list; e; e = e->next) - { - if (e->literal) - count++; - head->mask |= e->mask; - } - - if (count) - { - head->htab = htab_create (count * 2, version_expr_head_hash, - version_expr_head_eq, NULL); - list_loc = &head->list; - remaining_loc = &head->remaining; - for (e = head->list; e; e = next) - { - next = e->next; - if (!e->literal) - { - *remaining_loc = e; - remaining_loc = &e->next; - } - else - { - void **loc = htab_find_slot ((htab_t) head->htab, e, INSERT); - - if (*loc) - { - struct bfd_elf_version_expr *e1, *last; - - e1 = (struct bfd_elf_version_expr *) *loc; - last = NULL; - do - { - if (e1->mask == e->mask) - { - last = NULL; - break; - } - last = e1; - e1 = e1->next; - } - while (e1 && strcmp (e1->pattern, e->pattern) == 0); - - if (last == NULL) - { - /* This is a duplicate. */ - /* FIXME: Memory leak. Sometimes pattern is not - xmalloced alone, but in larger chunk of memory. */ - /* free (e->pattern); */ - free (e); - } - else - { - e->next = last->next; - last->next = e; - } - } - else - { - *loc = e; - *list_loc = e; - list_loc = &e->next; - } - } - } - *remaining_loc = NULL; - *list_loc = head->remaining; - } - else - head->remaining = head->list; -} - -/* This is called when we know the name and dependencies of the - version. */ - -void -lang_register_vers_node (const char *name, - struct bfd_elf_version_tree *version, - struct bfd_elf_version_deps *deps) -{ - struct bfd_elf_version_tree *t, **pp; - struct bfd_elf_version_expr *e1; - - if (name == NULL) - name = ""; - - if (link_info.version_info != NULL - && (name[0] == '\0' || link_info.version_info->name[0] == '\0')) - { - einfo (_("%X%P: anonymous version tag cannot be combined" - " with other version tags\n")); - free (version); - return; - } - - /* Make sure this node has a unique name. */ - for (t = link_info.version_info; t != NULL; t = t->next) - if (strcmp (t->name, name) == 0) - einfo (_("%X%P: duplicate version tag `%s'\n"), name); - - lang_finalize_version_expr_head (&version->globals); - lang_finalize_version_expr_head (&version->locals); - - /* Check the global and local match names, and make sure there - aren't any duplicates. */ - - for (e1 = version->globals.list; e1 != NULL; e1 = e1->next) - { - for (t = link_info.version_info; t != NULL; t = t->next) - { - struct bfd_elf_version_expr *e2; - - if (t->locals.htab && e1->literal) - { - e2 = (struct bfd_elf_version_expr *) - htab_find ((htab_t) t->locals.htab, e1); - while (e2 && strcmp (e1->pattern, e2->pattern) == 0) - { - if (e1->mask == e2->mask) - einfo (_("%X%P: duplicate expression `%s'" - " in version information\n"), e1->pattern); - e2 = e2->next; - } - } - else if (!e1->literal) - for (e2 = t->locals.remaining; e2 != NULL; e2 = e2->next) - if (strcmp (e1->pattern, e2->pattern) == 0 - && e1->mask == e2->mask) - einfo (_("%X%P: duplicate expression `%s'" - " in version information\n"), e1->pattern); - } - } - - for (e1 = version->locals.list; e1 != NULL; e1 = e1->next) - { - for (t = link_info.version_info; t != NULL; t = t->next) - { - struct bfd_elf_version_expr *e2; - - if (t->globals.htab && e1->literal) - { - e2 = (struct bfd_elf_version_expr *) - htab_find ((htab_t) t->globals.htab, e1); - while (e2 && strcmp (e1->pattern, e2->pattern) == 0) - { - if (e1->mask == e2->mask) - einfo (_("%X%P: duplicate expression `%s'" - " in version information\n"), - e1->pattern); - e2 = e2->next; - } - } - else if (!e1->literal) - for (e2 = t->globals.remaining; e2 != NULL; e2 = e2->next) - if (strcmp (e1->pattern, e2->pattern) == 0 - && e1->mask == e2->mask) - einfo (_("%X%P: duplicate expression `%s'" - " in version information\n"), e1->pattern); - } - } - - version->deps = deps; - version->name = name; - if (name[0] != '\0') - { - ++version_index; - version->vernum = version_index; - } - else - version->vernum = 0; - - for (pp = &link_info.version_info; *pp != NULL; pp = &(*pp)->next) - ; - *pp = version; -} - -/* This is called when we see a version dependency. */ - -struct bfd_elf_version_deps * -lang_add_vers_depend (struct bfd_elf_version_deps *list, const char *name) -{ - struct bfd_elf_version_deps *ret; - struct bfd_elf_version_tree *t; - - ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret); - ret->next = list; - - for (t = link_info.version_info; t != NULL; t = t->next) - { - if (strcmp (t->name, name) == 0) - { - ret->version_needed = t; - return ret; - } - } - - einfo (_("%X%P: unable to find version dependency `%s'\n"), name); - - ret->version_needed = NULL; - return ret; -} - -static void -lang_do_version_exports_section (void) -{ - struct bfd_elf_version_expr *greg = NULL, *lreg; - - LANG_FOR_EACH_INPUT_STATEMENT (is) - { - asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports"); - char *contents, *p; - bfd_size_type len; - - if (sec == NULL) - continue; - - len = sec->size; - contents = (char *) xmalloc (len); - if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len)) - einfo (_("%X%P: unable to read .exports section contents\n"), sec); - - p = contents; - while (p < contents + len) - { - greg = lang_new_vers_pattern (greg, p, NULL, FALSE); - p = strchr (p, '\0') + 1; - } - - /* Do not free the contents, as we used them creating the regex. */ - - /* Do not include this section in the link. */ - sec->flags |= SEC_EXCLUDE | SEC_KEEP; - } - - lreg = lang_new_vers_pattern (NULL, "*", NULL, FALSE); - lang_register_vers_node (command_line.version_exports_section, - lang_new_vers_node (greg, lreg), NULL); -} - -/* Evaluate LENGTH and ORIGIN parts of MEMORY spec */ - -static void -lang_do_memory_regions (void) -{ - lang_memory_region_type *r = lang_memory_region_list; - - for (; r != NULL; r = r->next) - { - if (r->origin_exp) - { - exp_fold_tree_no_dot (r->origin_exp); - if (expld.result.valid_p) - { - r->origin = expld.result.value; - r->current = r->origin; - } - else - einfo (_("%F%P: invalid origin for memory region %s\n"), - r->name_list.name); - } - if (r->length_exp) - { - exp_fold_tree_no_dot (r->length_exp); - if (expld.result.valid_p) - r->length = expld.result.value; - else - einfo (_("%F%P: invalid length for memory region %s\n"), - r->name_list.name); - } - } -} - -void -lang_add_unique (const char *name) -{ - struct unique_sections *ent; - - for (ent = unique_section_list; ent; ent = ent->next) - if (strcmp (ent->name, name) == 0) - return; - - ent = (struct unique_sections *) xmalloc (sizeof *ent); - ent->name = xstrdup (name); - ent->next = unique_section_list; - unique_section_list = ent; -} - -/* Append the list of dynamic symbols to the existing one. */ - -void -lang_append_dynamic_list (struct bfd_elf_version_expr *dynamic) -{ - if (link_info.dynamic_list) - { - struct bfd_elf_version_expr *tail; - for (tail = dynamic; tail->next != NULL; tail = tail->next) - ; - tail->next = link_info.dynamic_list->head.list; - link_info.dynamic_list->head.list = dynamic; - } - else - { - struct bfd_elf_dynamic_list *d; - - d = (struct bfd_elf_dynamic_list *) xcalloc (1, sizeof *d); - d->head.list = dynamic; - d->match = lang_vers_match; - link_info.dynamic_list = d; - } -} - -/* Append the list of C++ typeinfo dynamic symbols to the existing - one. */ - -void -lang_append_dynamic_list_cpp_typeinfo (void) -{ - const char *symbols[] = - { - "typeinfo name for*", - "typeinfo for*" - }; - struct bfd_elf_version_expr *dynamic = NULL; - unsigned int i; - - for (i = 0; i < ARRAY_SIZE (symbols); i++) - dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++", - FALSE); - - lang_append_dynamic_list (dynamic); -} - -/* Append the list of C++ operator new and delete dynamic symbols to the - existing one. */ - -void -lang_append_dynamic_list_cpp_new (void) -{ - const char *symbols[] = - { - "operator new*", - "operator delete*" - }; - struct bfd_elf_version_expr *dynamic = NULL; - unsigned int i; - - for (i = 0; i < ARRAY_SIZE (symbols); i++) - dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++", - FALSE); - - lang_append_dynamic_list (dynamic); -} - -/* Scan a space and/or comma separated string of features. */ - -void -lang_ld_feature (char *str) -{ - char *p, *q; - - p = str; - while (*p) - { - char sep; - while (*p == ',' || ISSPACE (*p)) - ++p; - if (!*p) - break; - q = p + 1; - while (*q && *q != ',' && !ISSPACE (*q)) - ++q; - sep = *q; - *q = 0; - if (strcasecmp (p, "SANE_EXPR") == 0) - config.sane_expr = TRUE; - else - einfo (_("%X%P: unknown feature `%s'\n"), p); - *q = sep; - p = q; - } -} - -/* Pretty print memory amount. */ - -static void -lang_print_memory_size (bfd_vma sz) -{ - if ((sz & 0x3fffffff) == 0) - printf ("%10" BFD_VMA_FMT "u GB", sz >> 30); - else if ((sz & 0xfffff) == 0) - printf ("%10" BFD_VMA_FMT "u MB", sz >> 20); - else if ((sz & 0x3ff) == 0) - printf ("%10" BFD_VMA_FMT "u KB", sz >> 10); - else - printf (" %10" BFD_VMA_FMT "u B", sz); -} - -/* Implement --print-memory-usage: disply per region memory usage. */ - -void -lang_print_memory_usage (void) -{ - lang_memory_region_type *r; - - printf ("Memory region Used Size Region Size %%age Used\n"); - for (r = lang_memory_region_list; r->next != NULL; r = r->next) - { - bfd_vma used_length = r->current - r->origin; - double percent; - - printf ("%16s: ",r->name_list.name); - lang_print_memory_size (used_length); - lang_print_memory_size ((bfd_vma) r->length); - - percent = used_length * 100.0 / r->length; - - printf (" %6.2f%%\n", percent); - } -} diff -rupN binutils-2.30/ld/ld.texinfo binutils-2.30-new/ld/ld.texinfo --- binutils-2.30/ld/ld.texinfo 2018-01-19 11:15:20.000000000 +0100 +++ binutils-2.30-new/ld/ld.texinfo 2018-06-14 16:31:29.315219791 +0200 @@ -4001,6 +4001,12 @@ underscore), the linker will silently us If the program references @samp{etext} but does not define it, the linker will use the definition in the linker script. +Note - the @code{PROVIDE} directive considers a common symbol to be +defined, even though such a symbol could be combined with the symbol +that the @code{PROVIDE} would create. This is particularly important +when considering constructor and destructor list symbols such as +@samp{__CTOR_LIST__} as these are often defined as common symbols. + @node PROVIDE_HIDDEN @subsection PROVIDE_HIDDEN @cindex PROVIDE_HIDDEN diff -rupN binutils-2.30/ld/scripttempl/pep.sc binutils-2.30-new/ld/scripttempl/pep.sc --- binutils-2.30/ld/scripttempl/pep.sc 2018-01-13 14:31:16.000000000 +0100 +++ binutils-2.30-new/ld/scripttempl/pep.sc 2018-06-14 16:31:29.316219791 +0200 @@ -99,8 +99,22 @@ SECTIONS ${RELOCATING+*(.glue_7)} ${CONSTRUCTING+. = ALIGN(8);} ${CONSTRUCTING+ - PROVIDE(___CTOR_LIST__ = .); - PROVIDE(__CTOR_LIST__ = .); + /* Note: we always define __CTOR_LIST__ and ___CTOR_LIST__ here, + we do not PROVIDE them. This is because the ctors.o startup + code in libgcc defines them as common symbols, with the + expectation that they will be overridden by the definitions + here. If we PROVIDE the symbols then they will not be + overridden and global constructors will not be run. + + This does mean that it is not possible for a user to define + their own __CTOR_LIST__ and __DTOR_LIST__ symbols. If that + ability is needed a custom linker script will have to be + used. (The custom script can just be a copy of this script + with the PROVIDE() qualifiers added). + + See PR 22762 for more details. */ + ___CTOR_LIST__ = .; + __CTOR_LIST__ = .; LONG (-1); LONG (-1); KEEP (*(.ctors)); KEEP (*(.ctor)); @@ -108,8 +122,10 @@ SECTIONS LONG (0); LONG (0); } ${CONSTRUCTING+ - PROVIDE(___DTOR_LIST__ = .); - PROVIDE(__DTOR_LIST__ = .); + /* See comment about __CTOR_LIST__ above. The same reasoning + applies here too. */ + ___DTOR_LIST__ = .; + __DTOR_LIST__ = .; LONG (-1); LONG (-1); KEEP (*(.dtors)); KEEP (*(.dtor)); diff -rupN binutils-2.30/ld/scripttempl/pe.sc binutils-2.30-new/ld/scripttempl/pe.sc --- binutils-2.30/ld/scripttempl/pe.sc 2018-01-13 14:31:16.000000000 +0100 +++ binutils-2.30-new/ld/scripttempl/pe.sc 2018-06-14 16:31:29.316219791 +0200 @@ -98,8 +98,22 @@ SECTIONS ${RELOCATING+*(.glue_7t)} ${RELOCATING+*(.glue_7)} ${CONSTRUCTING+ - PROVIDE(___CTOR_LIST__ = .); - PROVIDE(__CTOR_LIST__ = .); + /* Note: we always define __CTOR_LIST__ and ___CTOR_LIST__ here, + we do not PROVIDE them. This is because the ctors.o startup + code in libgcc defines them as common symbols, with the + expectation that they will be overridden by the definitions + here. If we PROVIDE the symbols then they will not be + overridden and global constructors will not be run. + + This does mean that it is not possible for a user to define + their own __CTOR_LIST__ and __DTOR_LIST__ symbols. If that + ability is needed a custom linker script will have to be + used. (The custom script can just be a copy of this script + with the PROVIDE() qualifiers added). + + See PR 22762 for more details. */ + ___CTOR_LIST__ = .; + __CTOR_LIST__ = .; LONG (-1); KEEP(*(.ctors)); KEEP(*(.ctor)); @@ -107,8 +121,10 @@ SECTIONS LONG (0); } ${CONSTRUCTING+ - PROVIDE(___DTOR_LIST__ = .); - PROVIDE(__DTOR_LIST__ = .); + /* See comment about __CTOR_LIST__ above. The same reasoning + applies here too. */ + ___DTOR_LIST__ = .; + __DTOR_LIST__ = .; LONG (-1); KEEP(*(.dtors)); KEEP(*(.dtor));