1 /* Linker command language support.
2 Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 1999
3 Free Software Foundation, Inc.
5 This file is part of GLD, the Gnu Linker.
7 GLD is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GLD is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GLD; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
24 #include "libiberty.h"
44 static lang_statement_union_type *new_statement PARAMS ((enum statement_enum,
46 lang_statement_list_type*));
50 static struct obstack stat_obstack;
52 #define obstack_chunk_alloc xmalloc
53 #define obstack_chunk_free free
54 static CONST char *startup_file;
55 static lang_statement_list_type input_file_chain;
56 static boolean placed_commons = false;
57 static lang_output_section_statement_type *default_common_section;
58 static boolean map_option_f;
59 static bfd_vma print_dot;
60 static lang_input_statement_type *first_file;
61 static lang_statement_list_type lang_output_section_statement;
62 static CONST char *current_target;
63 static CONST char *output_target;
64 static lang_statement_list_type statement_list;
65 static struct lang_phdr *lang_phdr_list;
67 static void lang_for_each_statement_worker
68 PARAMS ((void (*func) (lang_statement_union_type *),
69 lang_statement_union_type *s));
70 static lang_input_statement_type *new_afile
71 PARAMS ((const char *name, lang_input_file_enum_type file_type,
72 const char *target, boolean add_to_list));
73 static void init_os PARAMS ((lang_output_section_statement_type *s));
74 static void exp_init_os PARAMS ((etree_type *));
75 static void section_already_linked PARAMS ((bfd *, asection *, PTR));
76 static boolean wildcardp PARAMS ((const char *));
77 static lang_statement_union_type *wild_sort
78 PARAMS ((lang_wild_statement_type *, lang_input_statement_type *,
80 static lang_input_statement_type *lookup_name PARAMS ((const char *name));
81 static void load_symbols PARAMS ((lang_input_statement_type *entry,
82 lang_statement_list_type *));
83 static void wild PARAMS ((lang_wild_statement_type *s,
84 const char *section, const char *file,
86 lang_output_section_statement_type *output));
87 static bfd *open_output PARAMS ((const char *name));
88 static void ldlang_open_output PARAMS ((lang_statement_union_type *statement));
89 static void open_input_bfds
90 PARAMS ((lang_statement_union_type *statement, boolean));
91 static void lang_reasonable_defaults PARAMS ((void));
92 static void lang_place_undefineds PARAMS ((void));
93 static void map_input_to_output_sections
94 PARAMS ((lang_statement_union_type *s,
96 lang_output_section_statement_type *output_section_statement));
97 static void print_output_section_statement
98 PARAMS ((lang_output_section_statement_type *output_section_statement));
99 static void print_assignment
100 PARAMS ((lang_assignment_statement_type *assignment,
101 lang_output_section_statement_type *output_section));
102 static void print_input_statement PARAMS ((lang_input_statement_type *statm));
103 static boolean print_one_symbol PARAMS ((struct bfd_link_hash_entry *, PTR));
104 static void print_input_section PARAMS ((lang_input_section_type *in));
105 static void print_fill_statement PARAMS ((lang_fill_statement_type *fill));
106 static void print_data_statement PARAMS ((lang_data_statement_type *data));
107 static void print_address_statement PARAMS ((lang_address_statement_type *));
108 static void print_reloc_statement PARAMS ((lang_reloc_statement_type *reloc));
109 static void print_padding_statement PARAMS ((lang_padding_statement_type *s));
110 static void print_wild_statement
111 PARAMS ((lang_wild_statement_type *w,
112 lang_output_section_statement_type *os));
113 static void print_group
114 PARAMS ((lang_group_statement_type *, lang_output_section_statement_type *));
115 static void print_statement PARAMS ((lang_statement_union_type *s,
116 lang_output_section_statement_type *os));
117 static void print_statement_list PARAMS ((lang_statement_union_type *s,
118 lang_output_section_statement_type *os));
119 static void print_statements PARAMS ((void));
120 static bfd_vma insert_pad PARAMS ((lang_statement_union_type **this_ptr,
121 fill_type fill, unsigned int power,
122 asection *output_section_statement,
124 static bfd_vma size_input_section
125 PARAMS ((lang_statement_union_type **this_ptr,
126 lang_output_section_statement_type *output_section_statement,
127 fill_type fill, bfd_vma dot, boolean relax));
128 static void lang_finish PARAMS ((void));
129 static void ignore_bfd_errors PARAMS ((const char *, ...));
130 static void lang_check PARAMS ((void));
131 static void lang_common PARAMS ((void));
132 static boolean lang_one_common PARAMS ((struct bfd_link_hash_entry *, PTR));
133 static void lang_place_orphans PARAMS ((void));
134 static int topower PARAMS ((int));
135 static void lang_set_startof PARAMS ((void));
136 static void reset_memory_regions PARAMS ((void));
137 static void lang_record_phdrs PARAMS ((void));
138 static void lang_gc_wild
139 PARAMS ((lang_wild_statement_type *, const char *, const char *));
140 static void lang_gc_sections_1 PARAMS ((lang_statement_union_type *));
141 static void lang_gc_sections PARAMS ((void));
142 static void lang_do_version_exports_section PARAMS ((void));
143 static void lang_check_section_addresses PARAMS ((void));
145 typedef void (*callback_t) PARAMS ((lang_wild_statement_type *,
146 asection *, lang_input_statement_type *,
148 static void walk_wild_section
149 PARAMS ((lang_wild_statement_type *, const char *,
150 lang_input_statement_type *, callback_t, void *));
151 static void walk_wild_file
152 PARAMS ((lang_wild_statement_type *, const char *,
153 lang_input_statement_type *, callback_t, void *));
155 static int get_target PARAMS ((const bfd_target *, void *));
156 static void stricpy PARAMS ((char *, char *));
157 static void strcut PARAMS ((char *, char *));
158 static int name_compare PARAMS ((char *, char *));
159 static int closest_target_match PARAMS ((const bfd_target *, void *));
160 static char * get_first_input_target PARAMS ((void));
163 lang_output_section_statement_type *abs_output_section;
164 lang_statement_list_type *stat_ptr = &statement_list;
165 lang_statement_list_type file_chain = { NULL, NULL };
166 const char *entry_symbol = NULL;
167 boolean entry_from_cmdline;
168 boolean lang_has_input_file = false;
169 boolean had_output_filename = false;
170 boolean lang_float_flag = false;
171 boolean delete_output_file_on_failure = false;
172 struct lang_nocrossrefs *nocrossref_list;
174 etree_type *base; /* Relocation base - or null */
177 #if defined(__STDC__) || defined(ALMOST_STDC)
178 #define cat(a,b) a##b
180 #define cat(a,b) a/**/b
183 #define new_stat(x,y) (cat(x,_type)*) new_statement(cat(x,_enum), sizeof(cat(x,_type)),y)
185 #define outside_section_address(q) ( (q)->output_offset + (q)->output_section->vma)
187 #define outside_symbol_address(q) ((q)->value + outside_section_address(q->section))
189 #define SECTION_NAME_MAP_LENGTH (16)
195 return obstack_alloc (&stat_obstack, size);
198 /*----------------------------------------------------------------------
199 Generic traversal routines for finding matching sections.
203 walk_wild_section (ptr, section, file, callback, data)
204 lang_wild_statement_type *ptr;
206 lang_input_statement_type *file;
210 /* Don't process sections from files which were excluded. */
211 if (ptr->exclude_filename != NULL)
215 if (wildcardp (ptr->exclude_filename))
216 match = fnmatch (ptr->exclude_filename, file->filename, 0) == 0 ? true : false;
218 match = strcmp (ptr->exclude_filename, file->filename) == 0 ? true : false;
224 if (file->just_syms_flag == false)
226 register asection *s;
232 wildcard = wildcardp (section);
234 for (s = file->the_bfd->sections; s != NULL; s = s->next)
244 name = bfd_get_section_name (file->the_bfd, s);
246 match = fnmatch (section, name, 0) == 0 ? true : false;
248 match = strcmp (section, name) == 0 ? true : false;
252 (*callback) (ptr, s, file, data);
257 /* Handle a wild statement for a single file F. */
260 walk_wild_file (s, section, f, callback, data)
261 lang_wild_statement_type *s;
263 lang_input_statement_type *f;
267 if (f->the_bfd == NULL
268 || ! bfd_check_format (f->the_bfd, bfd_archive))
269 walk_wild_section (s, section, f, callback, data);
274 /* This is an archive file. We must map each member of the
275 archive separately. */
276 member = bfd_openr_next_archived_file (f->the_bfd, (bfd *) NULL);
277 while (member != NULL)
279 /* When lookup_name is called, it will call the add_symbols
280 entry point for the archive. For each element of the
281 archive which is included, BFD will call ldlang_add_file,
282 which will set the usrdata field of the member to the
283 lang_input_statement. */
284 if (member->usrdata != NULL)
286 walk_wild_section (s, section,
287 (lang_input_statement_type *) member->usrdata,
291 member = bfd_openr_next_archived_file (f->the_bfd, member);
297 walk_wild (s, section, file, callback, data)
298 lang_wild_statement_type *s;
304 if (file == (char *) NULL)
306 /* Perform the iteration over all files in the list. */
307 LANG_FOR_EACH_INPUT_STATEMENT (f)
309 walk_wild_file (s, section, f, callback, data);
312 else if (wildcardp (file))
314 LANG_FOR_EACH_INPUT_STATEMENT (f)
316 if (fnmatch (file, f->filename, FNM_FILE_NAME) == 0)
317 walk_wild_file (s, section, f, callback, data);
322 lang_input_statement_type *f;
324 /* Perform the iteration over a single file. */
325 f = lookup_name (file);
326 walk_wild_file (s, section, f, callback, data);
330 /*----------------------------------------------------------------------
331 lang_for_each_statement walks the parse tree and calls the provided
332 function for each node
336 lang_for_each_statement_worker (func, s)
337 void (*func) PARAMS ((lang_statement_union_type *));
338 lang_statement_union_type *s;
340 for (; s != (lang_statement_union_type *) NULL; s = s->next)
344 switch (s->header.type)
346 case lang_constructors_statement_enum:
347 lang_for_each_statement_worker (func, constructor_list.head);
349 case lang_output_section_statement_enum:
350 lang_for_each_statement_worker
352 s->output_section_statement.children.head);
354 case lang_wild_statement_enum:
355 lang_for_each_statement_worker
357 s->wild_statement.children.head);
359 case lang_group_statement_enum:
360 lang_for_each_statement_worker (func,
361 s->group_statement.children.head);
363 case lang_data_statement_enum:
364 case lang_reloc_statement_enum:
365 case lang_object_symbols_statement_enum:
366 case lang_output_statement_enum:
367 case lang_target_statement_enum:
368 case lang_input_section_enum:
369 case lang_input_statement_enum:
370 case lang_assignment_statement_enum:
371 case lang_padding_statement_enum:
372 case lang_address_statement_enum:
373 case lang_fill_statement_enum:
383 lang_for_each_statement (func)
384 void (*func) PARAMS ((lang_statement_union_type *));
386 lang_for_each_statement_worker (func,
387 statement_list.head);
390 /*----------------------------------------------------------------------*/
392 lang_list_init (list)
393 lang_statement_list_type *list;
395 list->head = (lang_statement_union_type *) NULL;
396 list->tail = &list->head;
399 /*----------------------------------------------------------------------
401 build a new statement node for the parse tree
406 lang_statement_union_type *
407 new_statement (type, size, list)
408 enum statement_enum type;
410 lang_statement_list_type * list;
412 lang_statement_union_type *new = (lang_statement_union_type *)
415 new->header.type = type;
416 new->header.next = (lang_statement_union_type *) NULL;
417 lang_statement_append (list, new, &new->header.next);
422 Build a new input file node for the language. There are several ways
423 in which we treat an input file, eg, we only look at symbols, or
424 prefix it with a -l etc.
426 We can be supplied with requests for input files more than once;
427 they may, for example be split over serveral lines like foo.o(.text)
428 foo.o(.data) etc, so when asked for a file we check that we havn't
429 got it already so we don't duplicate the bfd.
432 static lang_input_statement_type *
433 new_afile (name, file_type, target, add_to_list)
435 lang_input_file_enum_type file_type;
439 lang_input_statement_type *p;
442 p = new_stat (lang_input_statement, stat_ptr);
445 p = ((lang_input_statement_type *)
446 stat_alloc (sizeof (lang_input_statement_type)));
447 p->header.next = NULL;
450 lang_has_input_file = true;
454 case lang_input_file_is_symbols_only_enum:
456 p->is_archive = false;
458 p->local_sym_name = name;
459 p->just_syms_flag = true;
460 p->search_dirs_flag = false;
462 case lang_input_file_is_fake_enum:
464 p->is_archive = false;
466 p->local_sym_name = name;
467 p->just_syms_flag = false;
468 p->search_dirs_flag = false;
470 case lang_input_file_is_l_enum:
471 p->is_archive = true;
474 p->local_sym_name = concat ("-l", name, (const char *) NULL);
475 p->just_syms_flag = false;
476 p->search_dirs_flag = true;
478 case lang_input_file_is_marker_enum:
480 p->is_archive = false;
482 p->local_sym_name = name;
483 p->just_syms_flag = false;
484 p->search_dirs_flag = true;
486 case lang_input_file_is_search_file_enum:
488 p->is_archive = false;
490 p->local_sym_name = name;
491 p->just_syms_flag = false;
492 p->search_dirs_flag = true;
494 case lang_input_file_is_file_enum:
496 p->is_archive = false;
498 p->local_sym_name = name;
499 p->just_syms_flag = false;
500 p->search_dirs_flag = false;
505 p->the_bfd = (bfd *) NULL;
506 p->asymbols = (asymbol **) NULL;
507 p->next_real_file = (lang_statement_union_type *) NULL;
508 p->next = (lang_statement_union_type *) NULL;
510 p->dynamic = config.dynamic_link;
511 p->whole_archive = whole_archive;
513 lang_statement_append (&input_file_chain,
514 (lang_statement_union_type *) p,
519 lang_input_statement_type *
520 lang_add_input_file (name, file_type, target)
522 lang_input_file_enum_type file_type;
525 lang_has_input_file = true;
526 return new_afile (name, file_type, target, true);
529 /* Build enough state so that the parser can build its tree */
533 obstack_begin (&stat_obstack, 1000);
535 stat_ptr = &statement_list;
537 lang_list_init (stat_ptr);
539 lang_list_init (&input_file_chain);
540 lang_list_init (&lang_output_section_statement);
541 lang_list_init (&file_chain);
542 first_file = lang_add_input_file ((char *) NULL,
543 lang_input_file_is_marker_enum,
545 abs_output_section = lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME);
547 abs_output_section->bfd_section = bfd_abs_section_ptr;
551 /*----------------------------------------------------------------------
552 A region is an area of memory declared with the
553 MEMORY { name:org=exp, len=exp ... }
556 We maintain a list of all the regions here
558 If no regions are specified in the script, then the default is used
559 which is created when looked up to be the entire data space
562 static lang_memory_region_type *lang_memory_region_list;
563 static lang_memory_region_type **lang_memory_region_list_tail = &lang_memory_region_list;
565 lang_memory_region_type *
566 lang_memory_region_lookup (name)
567 CONST char *CONST name;
569 lang_memory_region_type *p;
571 for (p = lang_memory_region_list;
572 p != (lang_memory_region_type *) NULL;
575 if (strcmp (p->name, name) == 0)
582 /* This code used to always use the first region in the list as the
583 default region. I changed it to instead use a region
584 encompassing all of memory as the default region. This permits
585 NOLOAD sections to work reasonably without requiring a region.
586 People should specify what region they mean, if they really want
588 if (strcmp (name, "*default*") == 0)
590 if (lang_memory_region_list != (lang_memory_region_type *) NULL)
592 return lang_memory_region_list;
598 lang_memory_region_type *new =
599 (lang_memory_region_type *) stat_alloc (sizeof (lang_memory_region_type));
601 new->name = buystring (name);
602 new->next = (lang_memory_region_type *) NULL;
604 *lang_memory_region_list_tail = new;
605 lang_memory_region_list_tail = &new->next;
609 new->length = ~(bfd_size_type)0;
611 new->had_full_message = false;
618 lang_memory_region_type *
619 lang_memory_default (section)
622 lang_memory_region_type *p;
624 flagword sec_flags = section->flags;
626 /* Override SEC_DATA to mean a writable section. */
627 if ((sec_flags & (SEC_ALLOC | SEC_READONLY | SEC_CODE)) == SEC_ALLOC)
628 sec_flags |= SEC_DATA;
630 for (p = lang_memory_region_list;
631 p != (lang_memory_region_type *) NULL;
634 if ((p->flags & sec_flags) != 0
635 && (p->not_flags & sec_flags) == 0)
640 return lang_memory_region_lookup ("*default*");
643 lang_output_section_statement_type *
644 lang_output_section_find (name)
645 CONST char *CONST name;
647 lang_statement_union_type *u;
648 lang_output_section_statement_type *lookup;
650 for (u = lang_output_section_statement.head;
651 u != (lang_statement_union_type *) NULL;
654 lookup = &u->output_section_statement;
655 if (strcmp (name, lookup->name) == 0)
660 return (lang_output_section_statement_type *) NULL;
663 lang_output_section_statement_type *
664 lang_output_section_statement_lookup (name)
665 CONST char *CONST name;
667 lang_output_section_statement_type *lookup;
669 lookup = lang_output_section_find (name);
670 if (lookup == (lang_output_section_statement_type *) NULL)
673 lookup = (lang_output_section_statement_type *)
674 new_stat (lang_output_section_statement, stat_ptr);
675 lookup->region = (lang_memory_region_type *) NULL;
677 lookup->block_value = 1;
680 lookup->next = (lang_statement_union_type *) NULL;
681 lookup->bfd_section = (asection *) NULL;
682 lookup->processed = false;
683 lookup->sectype = normal_section;
684 lookup->addr_tree = (etree_type *) NULL;
685 lang_list_init (&lookup->children);
687 lookup->memspec = (CONST char *) NULL;
689 lookup->subsection_alignment = -1;
690 lookup->section_alignment = -1;
691 lookup->load_base = (union etree_union *) NULL;
692 lookup->phdrs = NULL;
694 lang_statement_append (&lang_output_section_statement,
695 (lang_statement_union_type *) lookup,
702 lang_map_flags (flag)
705 if (flag & SEC_ALLOC)
711 if (flag & SEC_READONLY)
724 lang_memory_region_type *m;
726 minfo (_("\nMemory Configuration\n\n"));
727 fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
728 _("Name"), _("Origin"), _("Length"), _("Attributes"));
730 for (m = lang_memory_region_list;
731 m != (lang_memory_region_type *) NULL;
737 fprintf (config.map_file, "%-16s ", m->name);
739 sprintf_vma (buf, m->origin);
740 minfo ("0x%s ", buf);
748 minfo ("0x%V", m->length);
749 if (m->flags || m->not_flags)
757 lang_map_flags (m->flags);
763 lang_map_flags (m->not_flags);
770 fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
775 /* Initialize an output section. */
779 lang_output_section_statement_type *s;
781 section_userdata_type *new;
783 if (s->bfd_section != NULL)
786 if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
787 einfo (_("%P%F: Illegal use of `%s' section"), DISCARD_SECTION_NAME);
789 new = ((section_userdata_type *)
790 stat_alloc (sizeof (section_userdata_type)));
792 s->bfd_section = bfd_get_section_by_name (output_bfd, s->name);
793 if (s->bfd_section == (asection *) NULL)
794 s->bfd_section = bfd_make_section (output_bfd, s->name);
795 if (s->bfd_section == (asection *) NULL)
797 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
798 output_bfd->xvec->name, s->name);
800 s->bfd_section->output_section = s->bfd_section;
802 /* We initialize an output sections output offset to minus its own */
803 /* vma to allow us to output a section through itself */
804 s->bfd_section->output_offset = 0;
805 get_userdata (s->bfd_section) = (PTR) new;
807 /* If there is a base address, make sure that any sections it might
808 mention are initialized. */
809 if (s->addr_tree != NULL)
810 exp_init_os (s->addr_tree);
813 /* Make sure that all output sections mentioned in an expression are
820 switch (exp->type.node_class)
823 exp_init_os (exp->assign.src);
827 exp_init_os (exp->binary.lhs);
828 exp_init_os (exp->binary.rhs);
832 exp_init_os (exp->trinary.cond);
833 exp_init_os (exp->trinary.lhs);
834 exp_init_os (exp->trinary.rhs);
838 exp_init_os (exp->unary.child);
842 switch (exp->type.node_code)
848 lang_output_section_statement_type *os;
850 os = lang_output_section_find (exp->name.name);
851 if (os != NULL && os->bfd_section == NULL)
862 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
863 once into the output. This routine checks each sections, and
864 arranges to discard it if a section of the same name has already
865 been linked. If the section has COMDAT information, then it uses
866 that to decide whether the section should be included. This code
867 assumes that all relevant sections have the SEC_LINK_ONCE flag set;
868 that is, it does not depend solely upon the section name. This is
869 called via bfd_map_over_sections. */
873 section_already_linked (abfd, sec, data)
878 lang_input_statement_type *entry = (lang_input_statement_type *) data;
881 struct sec_link_once *next;
884 static struct sec_link_once *sec_link_once_list;
887 struct sec_link_once *l;
889 /* If we are only reading symbols from this object, then we want to
890 discard all sections. */
891 if (entry->just_syms_flag)
893 sec->output_section = bfd_abs_section_ptr;
894 sec->output_offset = sec->vma;
898 flags = bfd_get_section_flags (abfd, sec);
900 if ((flags & SEC_LINK_ONCE) == 0)
903 /* FIXME: When doing a relocateable link, we may have trouble
904 copying relocations in other sections that refer to local symbols
905 in the section being discarded. Those relocations will have to
906 be converted somehow; as of this writing I'm not sure that any of
907 the backends handle that correctly.
909 It is tempting to instead not discard link once sections when
910 doing a relocateable link (technically, they should be discarded
911 whenever we are building constructors). However, that fails,
912 because the linker winds up combining all the link once sections
913 into a single large link once section, which defeats the purpose
914 of having link once sections in the first place.
916 Also, not merging link once sections in a relocateable link
917 causes trouble for MIPS ELF, which relies in link once semantics
918 to handle the .reginfo section correctly. */
920 name = bfd_get_section_name (abfd, sec);
922 for (l = sec_link_once_list; l != NULL; l = l->next)
924 if (strcmp (name, bfd_get_section_name (l->sec->owner, l->sec)) == 0
925 && (sec->comdat == NULL
926 || l->sec->comdat == NULL
927 || strcmp (sec->comdat->name, l->sec->comdat->name) == 0))
929 /* The section has already been linked. See if we should
931 switch (flags & SEC_LINK_DUPLICATES)
936 case SEC_LINK_DUPLICATES_DISCARD:
939 case SEC_LINK_DUPLICATES_ONE_ONLY:
940 if (sec->comdat == NULL)
941 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
944 einfo (_("%P: %B: warning: ignoring duplicate `%s' section symbol `%s'\n"),
945 abfd, name, sec->comdat->name);
948 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
949 /* FIXME: We should really dig out the contents of both
950 sections and memcmp them. The COFF/PE spec says that
951 the Microsoft linker does not implement this
952 correctly, so I'm not going to bother doing it
955 case SEC_LINK_DUPLICATES_SAME_SIZE:
956 if (bfd_section_size (abfd, sec)
957 != bfd_section_size (l->sec->owner, l->sec))
958 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
963 /* Set the output_section field so that wild_doit does not
964 create a lang_input_section structure for this section.
965 Since there might be a symbol in the section being
966 discarded, we must retain a pointer to the section which
967 we are really going to use. */
968 sec->output_section = bfd_abs_section_ptr;
969 if (sec->comdat != NULL)
970 sec->comdat->sec = l->sec;
976 /* This is the first section with this name. Record it. */
978 l = (struct sec_link_once *) xmalloc (sizeof *l);
980 l->next = sec_link_once_list;
981 sec_link_once_list = l;
984 /* The wild routines.
986 These expand statements like *(.text) and foo.o to a list of
987 explicit actions, like foo.o(.text), bar.o(.text) and
988 foo.o(.text, .data). */
990 /* Return true if the PATTERN argument is a wildcard pattern.
991 Although backslashes are treated specially if a pattern contains
992 wildcards, we do not consider the mere presence of a backslash to
993 be enough to cause the the pattern to be treated as a wildcard.
994 That lets us handle DOS filenames more naturally. */
1002 for (s = pattern; *s != '\0'; ++s)
1010 /* Add SECTION to the output section OUTPUT. Do this by creating a
1011 lang_input_section statement which is placed at PTR. FILE is the
1012 input file which holds SECTION. */
1015 wild_doit (ptr, section, output, file)
1016 lang_statement_list_type *ptr;
1018 lang_output_section_statement_type *output;
1019 lang_input_statement_type *file;
1024 flags = bfd_get_section_flags (section->owner, section);
1028 /* If we are doing a final link, discard sections marked with
1030 if (! link_info.relocateable
1031 && (flags & SEC_EXCLUDE) != 0)
1034 /* Discard input sections which are assigned to a section named
1035 DISCARD_SECTION_NAME. */
1036 if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
1039 /* Discard debugging sections if we are stripping debugging
1041 if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
1042 && (flags & SEC_DEBUGGING) != 0)
1047 if (section->output_section == NULL)
1049 /* This prevents future calls from assigning this section. */
1050 section->output_section = bfd_abs_section_ptr;
1055 if (section->output_section == NULL)
1058 lang_input_section_type *new;
1061 if (output->bfd_section == NULL)
1069 /* Add a section reference to the list */
1070 new = new_stat (lang_input_section, ptr);
1072 new->section = section;
1074 section->output_section = output->bfd_section;
1076 flags = section->flags;
1078 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1079 to an output section, because we want to be able to include a
1080 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1081 section (I don't know why we want to do this, but we do).
1082 build_link_order in ldwrite.c handles this case by turning
1083 the embedded SEC_NEVER_LOAD section into a fill. */
1085 flags &= ~ SEC_NEVER_LOAD;
1087 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1088 already been processed. One reason to do this is that on pe
1089 format targets, .text$foo sections go into .text and it's odd
1090 to see .text with SEC_LINK_ONCE set. */
1092 if (! link_info.relocateable)
1093 flags &= ~ (SEC_LINK_ONCE | SEC_LINK_DUPLICATES);
1095 /* If this is not the first input section, and the SEC_READONLY
1096 flag is not currently set, then don't set it just because the
1097 input section has it set. */
1099 if (! first && (section->output_section->flags & SEC_READONLY) == 0)
1100 flags &= ~ SEC_READONLY;
1102 section->output_section->flags |= flags;
1104 /* If SEC_READONLY is not set in the input section, then clear
1105 it from the output section. */
1106 if ((section->flags & SEC_READONLY) == 0)
1107 section->output_section->flags &= ~SEC_READONLY;
1109 switch (output->sectype)
1111 case normal_section:
1116 case overlay_section:
1117 output->bfd_section->flags &= ~SEC_ALLOC;
1119 case noload_section:
1120 output->bfd_section->flags &= ~SEC_LOAD;
1121 output->bfd_section->flags |= SEC_NEVER_LOAD;
1125 /* Copy over SEC_SMALL_DATA. */
1126 if (section->flags & SEC_SMALL_DATA)
1127 section->output_section->flags |= SEC_SMALL_DATA;
1129 if (section->alignment_power > output->bfd_section->alignment_power)
1130 output->bfd_section->alignment_power = section->alignment_power;
1132 /* If supplied an aligment, then force it. */
1133 if (output->section_alignment != -1)
1134 output->bfd_section->alignment_power = output->section_alignment;
1138 /* Handle wildcard sorting. This returns the lang_input_section which
1139 should follow the one we are going to create for SECTION and FILE,
1140 based on the sorting requirements of WILD. It returns NULL if the
1141 new section should just go at the end of the current list. */
1143 static lang_statement_union_type *
1144 wild_sort (wild, file, section)
1145 lang_wild_statement_type *wild;
1146 lang_input_statement_type *file;
1149 const char *section_name;
1150 lang_statement_union_type *l;
1152 if (! wild->filenames_sorted && ! wild->sections_sorted)
1155 section_name = bfd_get_section_name (file->the_bfd, section);
1156 for (l = wild->children.head; l != NULL; l = l->next)
1158 lang_input_section_type *ls;
1160 if (l->header.type != lang_input_section_enum)
1162 ls = &l->input_section;
1164 /* Sorting by filename takes precedence over sorting by section
1167 if (wild->filenames_sorted)
1169 const char *fn, *ln;
1173 /* The PE support for the .idata section as generated by
1174 dlltool assumes that files will be sorted by the name of
1175 the archive and then the name of the file within the
1178 if (file->the_bfd != NULL
1179 && bfd_my_archive (file->the_bfd) != NULL)
1181 fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
1186 fn = file->filename;
1190 if (ls->ifile->the_bfd != NULL
1191 && bfd_my_archive (ls->ifile->the_bfd) != NULL)
1193 ln = bfd_get_filename (bfd_my_archive (ls->ifile->the_bfd));
1198 ln = ls->ifile->filename;
1202 i = strcmp (fn, ln);
1211 fn = file->filename;
1213 ln = ls->ifile->filename;
1215 i = strcmp (fn, ln);
1223 /* Here either the files are not sorted by name, or we are
1224 looking at the sections for this file. */
1226 if (wild->sections_sorted)
1228 if (strcmp (section_name,
1229 bfd_get_section_name (ls->ifile->the_bfd,
1239 /* Expand a wild statement for a particular FILE. SECTION may be
1240 NULL, in which case it is a wild card. */
1243 output_section_callback (ptr, section, file, output)
1244 lang_wild_statement_type *ptr;
1246 lang_input_statement_type *file;
1249 lang_statement_union_type *before;
1251 /* If the wild pattern was marked KEEP, the member sections
1252 should be as well. */
1253 if (ptr->keep_sections)
1254 section->flags |= SEC_KEEP;
1256 before = wild_sort (ptr, file, section);
1258 /* Here BEFORE points to the lang_input_section which
1259 should follow the one we are about to add. If BEFORE
1260 is NULL, then the section should just go at the end
1261 of the current list. */
1264 wild_doit (&ptr->children, section,
1265 (lang_output_section_statement_type *) output,
1269 lang_statement_list_type list;
1270 lang_statement_union_type **pp;
1272 lang_list_init (&list);
1273 wild_doit (&list, section,
1274 (lang_output_section_statement_type *) output,
1277 /* If we are discarding the section, LIST.HEAD will
1279 if (list.head != NULL)
1281 ASSERT (list.head->next == NULL);
1283 for (pp = &ptr->children.head;
1286 ASSERT (*pp != NULL);
1288 list.head->next = *pp;
1294 /* This is passed a file name which must have been seen already and
1295 added to the statement tree. We will see if it has been opened
1296 already and had its symbols read. If not then we'll read it. */
1298 static lang_input_statement_type *
1302 lang_input_statement_type *search;
1304 for (search = (lang_input_statement_type *) input_file_chain.head;
1305 search != (lang_input_statement_type *) NULL;
1306 search = (lang_input_statement_type *) search->next_real_file)
1308 if (search->filename == (char *) NULL && name == (char *) NULL)
1310 if (search->filename != (char *) NULL
1311 && name != (char *) NULL
1312 && strcmp (search->filename, name) == 0)
1316 if (search == (lang_input_statement_type *) NULL)
1317 search = new_afile (name, lang_input_file_is_file_enum, default_target,
1320 /* If we have already added this file, or this file is not real
1321 (FIXME: can that ever actually happen?) or the name is NULL
1322 (FIXME: can that ever actually happen?) don't add this file. */
1325 || search->filename == (const char *) NULL)
1328 load_symbols (search, (lang_statement_list_type *) NULL);
1333 /* Get the symbols for an input file. */
1336 load_symbols (entry, place)
1337 lang_input_statement_type *entry;
1338 lang_statement_list_type *place;
1345 ldfile_open_file (entry);
1347 if (! bfd_check_format (entry->the_bfd, bfd_archive)
1348 && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
1351 lang_statement_list_type *hold;
1353 err = bfd_get_error ();
1354 if (err == bfd_error_file_ambiguously_recognized)
1358 einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
1359 einfo (_("%B: matching formats:"), entry->the_bfd);
1360 for (p = matching; *p != NULL; p++)
1364 else if (err != bfd_error_file_not_recognized
1366 einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
1368 bfd_close (entry->the_bfd);
1369 entry->the_bfd = NULL;
1371 /* See if the emulation has some special knowledge. */
1373 if (ldemul_unrecognized_file (entry))
1376 /* Try to interpret the file as a linker script. */
1378 ldfile_open_command_file (entry->filename);
1383 ldfile_assumed_script = true;
1384 parser_input = input_script;
1386 ldfile_assumed_script = false;
1393 if (ldemul_recognized_file (entry))
1396 /* We don't call ldlang_add_file for an archive. Instead, the
1397 add_symbols entry point will call ldlang_add_file, via the
1398 add_archive_element callback, for each element of the archive
1400 switch (bfd_get_format (entry->the_bfd))
1406 ldlang_add_file (entry);
1407 if (trace_files || trace_file_tries)
1408 info_msg ("%I\n", entry);
1412 if (entry->whole_archive)
1414 bfd *member = bfd_openr_next_archived_file (entry->the_bfd,
1416 while (member != NULL)
1418 if (! bfd_check_format (member, bfd_object))
1419 einfo (_("%F%B: object %B in archive is not object\n"),
1420 entry->the_bfd, member);
1421 if (! ((*link_info.callbacks->add_archive_element)
1422 (&link_info, member, "--whole-archive")))
1424 if (! bfd_link_add_symbols (member, &link_info))
1425 einfo (_("%F%B: could not read symbols: %E\n"), member);
1426 member = bfd_openr_next_archived_file (entry->the_bfd,
1430 entry->loaded = true;
1436 if (! bfd_link_add_symbols (entry->the_bfd, &link_info))
1437 einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
1439 entry->loaded = true;
1444 /* Handle a wild statement. SECTION or FILE or both may be NULL,
1445 indicating that it is a wildcard. Separate lang_input_section
1446 statements are created for each part of the expansion; they are
1447 added after the wild statement S. OUTPUT is the output section. */
1450 wild (s, section, file, target, output)
1451 lang_wild_statement_type *s;
1452 const char *section;
1454 const char *target ATTRIBUTE_UNUSED;
1455 lang_output_section_statement_type *output;
1457 walk_wild (s, section, file, output_section_callback, (void *) output);
1459 if (section != (char *) NULL
1460 && strcmp (section, "COMMON") == 0
1461 && default_common_section == NULL)
1463 /* Remember the section that common is going to in case we later
1464 get something which doesn't know where to put it. */
1465 default_common_section = output;
1469 /* Return true iff target is the sought target. */
1471 get_target (target, data)
1472 const bfd_target * target;
1475 const char * sought = (const char *) data;
1477 return strcmp (target->name, sought) == 0;
1480 /* Like strcpy() but convert to lower case as well. */
1488 while ((c = * src ++) != 0)
1490 if (isupper ((unsigned char) c))
1499 /* Remove the first occurance of needle (if any) in haystack
1502 strcut (haystack, needle)
1506 haystack = strstr (haystack, needle);
1512 for (src = haystack + strlen (needle); * src;)
1513 * haystack ++ = * src ++;
1519 /* Compare two target format name strings.
1520 Return a value indicating how "similar" they are. */
1522 name_compare (first, second)
1530 copy1 = xmalloc (strlen (first) + 1);
1531 copy2 = xmalloc (strlen (second) + 1);
1533 /* Convert the names to lower case. */
1534 stricpy (copy1, first);
1535 stricpy (copy2, second);
1537 /* Remove and endian strings from the name. */
1538 strcut (copy1, "big");
1539 strcut (copy1, "little");
1540 strcut (copy2, "big");
1541 strcut (copy2, "little");
1543 /* Return a value based on how many characters match,
1544 starting from the beginning. If both strings are
1545 the same then return 10 * their length. */
1546 for (result = 0; copy1 [result] == copy2 [result]; result ++)
1547 if (copy1 [result] == 0)
1559 /* Set by closest_target_match() below. */
1560 static const bfd_target * winner;
1562 /* Scan all the valid bfd targets looking for one that has the endianness
1563 requirement that was specified on the command line, and is the nearest
1564 match to the original output target. */
1566 closest_target_match (target, data)
1567 const bfd_target * target;
1570 const bfd_target * original = (const bfd_target *) data;
1572 if (command_line.endian == ENDIAN_BIG && target->byteorder != BFD_ENDIAN_BIG)
1575 if (command_line.endian == ENDIAN_LITTLE && target->byteorder != BFD_ENDIAN_LITTLE)
1578 /* Must be the same flavour. */
1579 if (target->flavour != original->flavour)
1582 /* If we have not found a potential winner yet, then record this one. */
1589 /* Oh dear, we now have two potential candidates for a successful match.
1590 Compare their names and choose the better one. */
1591 if (name_compare (target->name, original->name) > name_compare (winner->name, original->name))
1594 /* Keep on searching until wqe have checked them all. */
1598 /* Return the BFD target format of the first input file. */
1600 get_first_input_target ()
1602 char * target = NULL;
1604 LANG_FOR_EACH_INPUT_STATEMENT (s)
1606 if (s->header.type == lang_input_statement_enum
1609 ldfile_open_file (s);
1611 if (s->the_bfd != NULL
1612 && bfd_check_format (s->the_bfd, bfd_object))
1614 target = bfd_get_target (s->the_bfd);
1625 /* Open the output file. */
1633 /* Has the user told us which output format to use ? */
1634 if (output_target == (char *) NULL)
1636 /* No - has the current target been set to something other than the default ? */
1637 if (current_target != default_target)
1638 output_target = current_target;
1640 /* No - can we determine the format of the first input file ? */
1643 output_target = get_first_input_target ();
1645 /* Failed - use the default output target. */
1646 if (output_target == NULL)
1647 output_target = default_target;
1651 /* Has the user requested a particular endianness on the command line ? */
1652 if (command_line.endian != ENDIAN_UNSET)
1654 const bfd_target * target;
1655 enum bfd_endian desired_endian;
1657 /* Get the chosen target. */
1658 target = bfd_search_for_target (get_target, (void *) output_target);
1660 if (command_line.endian == ENDIAN_BIG)
1661 desired_endian = BFD_ENDIAN_BIG;
1663 desired_endian = BFD_ENDIAN_LITTLE;
1665 /* See if the target has the wrong endianness. This should not happen
1666 if the linker script has provided big and little endian alternatives,
1667 but some scrips don't do this. */
1668 if (target->byteorder != desired_endian)
1670 /* If it does, then see if the target provides
1671 an alternative with the correct endianness. */
1672 if (target->alternative_target != NULL
1673 && (target->alternative_target->byteorder == desired_endian))
1674 output_target = target->alternative_target->name;
1677 /* Try to find a target as similar as possible to the default
1678 target, but which has the desired endian characteristic. */
1679 (void) bfd_search_for_target (closest_target_match, (void *) target);
1681 /* Oh dear - we could not find any targets that satisfy our requirements. */
1683 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1685 output_target = winner->name;
1690 output = bfd_openw (name, output_target);
1692 if (output == (bfd *) NULL)
1694 if (bfd_get_error () == bfd_error_invalid_target)
1695 einfo (_("%P%F: target %s not found\n"), output_target);
1697 einfo (_("%P%F: cannot open output file %s: %E\n"), name);
1700 delete_output_file_on_failure = true;
1702 /* output->flags |= D_PAGED;*/
1704 if (! bfd_set_format (output, bfd_object))
1705 einfo (_("%P%F:%s: can not make object file: %E\n"), name);
1706 if (! bfd_set_arch_mach (output,
1707 ldfile_output_architecture,
1708 ldfile_output_machine))
1709 einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
1711 link_info.hash = bfd_link_hash_table_create (output);
1712 if (link_info.hash == (struct bfd_link_hash_table *) NULL)
1713 einfo (_("%P%F: can not create link hash table: %E\n"));
1715 bfd_set_gp_size (output, g_switch_value);
1720 ldlang_open_output (statement)
1721 lang_statement_union_type * statement;
1723 switch (statement->header.type)
1725 case lang_output_statement_enum:
1726 ASSERT (output_bfd == (bfd *) NULL);
1727 output_bfd = open_output (statement->output_statement.name);
1728 ldemul_set_output_arch ();
1729 if (config.magic_demand_paged && !link_info.relocateable)
1730 output_bfd->flags |= D_PAGED;
1732 output_bfd->flags &= ~D_PAGED;
1733 if (config.text_read_only)
1734 output_bfd->flags |= WP_TEXT;
1736 output_bfd->flags &= ~WP_TEXT;
1737 if (link_info.traditional_format)
1738 output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
1740 output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
1743 case lang_target_statement_enum:
1744 current_target = statement->target_statement.target;
1751 /* Open all the input files. */
1754 open_input_bfds (s, force)
1755 lang_statement_union_type *s;
1758 for (; s != (lang_statement_union_type *) NULL; s = s->next)
1760 switch (s->header.type)
1762 case lang_constructors_statement_enum:
1763 open_input_bfds (constructor_list.head, force);
1765 case lang_output_section_statement_enum:
1766 open_input_bfds (s->output_section_statement.children.head, force);
1768 case lang_wild_statement_enum:
1769 /* Maybe we should load the file's symbols */
1770 if (s->wild_statement.filename
1771 && ! wildcardp (s->wild_statement.filename))
1772 (void) lookup_name (s->wild_statement.filename);
1773 open_input_bfds (s->wild_statement.children.head, force);
1775 case lang_group_statement_enum:
1777 struct bfd_link_hash_entry *undefs;
1779 /* We must continually search the entries in the group
1780 until no new symbols are added to the list of undefined
1785 undefs = link_info.hash->undefs_tail;
1786 open_input_bfds (s->group_statement.children.head, true);
1788 while (undefs != link_info.hash->undefs_tail);
1791 case lang_target_statement_enum:
1792 current_target = s->target_statement.target;
1794 case lang_input_statement_enum:
1795 if (s->input_statement.real)
1797 lang_statement_list_type add;
1799 s->input_statement.target = current_target;
1801 /* If we are being called from within a group, and this
1802 is an archive which has already been searched, then
1803 force it to be researched. */
1805 && s->input_statement.loaded
1806 && bfd_check_format (s->input_statement.the_bfd,
1808 s->input_statement.loaded = false;
1810 lang_list_init (&add);
1812 load_symbols (&s->input_statement, &add);
1814 if (add.head != NULL)
1816 *add.tail = s->next;
1827 /* If there are [COMMONS] statements, put a wild one into the bss section */
1830 lang_reasonable_defaults ()
1833 lang_output_section_statement_lookup (".text");
1834 lang_output_section_statement_lookup (".data");
1836 default_common_section =
1837 lang_output_section_statement_lookup (".bss");
1840 if (placed_commons == false)
1842 lang_wild_statement_type *new =
1843 new_stat (lang_wild_statement,
1844 &default_common_section->children);
1846 new->section_name = "COMMON";
1847 new->filename = (char *) NULL;
1848 lang_list_init (&new->children);
1855 Add the supplied name to the symbol table as an undefined reference.
1856 Remove items from the chain as we open input bfds
1858 typedef struct ldlang_undef_chain_list
1860 struct ldlang_undef_chain_list *next;
1862 } ldlang_undef_chain_list_type;
1864 static ldlang_undef_chain_list_type *ldlang_undef_chain_list_head;
1867 ldlang_add_undef (name)
1868 CONST char *CONST name;
1870 ldlang_undef_chain_list_type *new =
1871 ((ldlang_undef_chain_list_type *)
1872 stat_alloc (sizeof (ldlang_undef_chain_list_type)));
1874 new->next = ldlang_undef_chain_list_head;
1875 ldlang_undef_chain_list_head = new;
1877 new->name = buystring (name);
1880 /* Run through the list of undefineds created above and place them
1881 into the linker hash table as undefined symbols belonging to the
1885 lang_place_undefineds ()
1887 ldlang_undef_chain_list_type *ptr;
1889 for (ptr = ldlang_undef_chain_list_head;
1890 ptr != (ldlang_undef_chain_list_type *) NULL;
1893 struct bfd_link_hash_entry *h;
1895 h = bfd_link_hash_lookup (link_info.hash, ptr->name, true, false, true);
1896 if (h == (struct bfd_link_hash_entry *) NULL)
1897 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1898 if (h->type == bfd_link_hash_new)
1900 h->type = bfd_link_hash_undefined;
1901 h->u.undef.abfd = NULL;
1902 bfd_link_add_undef (link_info.hash, h);
1907 /* Open input files and attatch to output sections */
1909 map_input_to_output_sections (s, target, output_section_statement)
1910 lang_statement_union_type * s;
1912 lang_output_section_statement_type * output_section_statement;
1914 for (; s != (lang_statement_union_type *) NULL; s = s->next)
1916 switch (s->header.type)
1920 case lang_wild_statement_enum:
1921 wild (&s->wild_statement, s->wild_statement.section_name,
1922 s->wild_statement.filename, target,
1923 output_section_statement);
1926 case lang_constructors_statement_enum:
1927 map_input_to_output_sections (constructor_list.head,
1929 output_section_statement);
1931 case lang_output_section_statement_enum:
1932 map_input_to_output_sections (s->output_section_statement.children.head,
1934 &s->output_section_statement);
1936 case lang_output_statement_enum:
1938 case lang_target_statement_enum:
1939 target = s->target_statement.target;
1941 case lang_group_statement_enum:
1942 map_input_to_output_sections (s->group_statement.children.head,
1944 output_section_statement);
1946 case lang_fill_statement_enum:
1947 case lang_input_section_enum:
1948 case lang_object_symbols_statement_enum:
1949 case lang_data_statement_enum:
1950 case lang_reloc_statement_enum:
1951 case lang_padding_statement_enum:
1952 case lang_input_statement_enum:
1953 if (output_section_statement != NULL
1954 && output_section_statement->bfd_section == NULL)
1955 init_os (output_section_statement);
1957 case lang_assignment_statement_enum:
1958 if (output_section_statement != NULL
1959 && output_section_statement->bfd_section == NULL)
1960 init_os (output_section_statement);
1962 /* Make sure that any sections mentioned in the assignment
1964 exp_init_os (s->assignment_statement.exp);
1966 case lang_afile_asection_pair_statement_enum:
1969 case lang_address_statement_enum:
1970 /* Mark the specified section with the supplied address */
1972 lang_output_section_statement_type *os =
1973 lang_output_section_statement_lookup
1974 (s->address_statement.section_name);
1976 if (os->bfd_section == NULL)
1978 os->addr_tree = s->address_statement.address;
1986 print_output_section_statement (output_section_statement)
1987 lang_output_section_statement_type * output_section_statement;
1989 asection *section = output_section_statement->bfd_section;
1992 if (output_section_statement != abs_output_section)
1994 minfo ("\n%s", output_section_statement->name);
1996 if (section != NULL)
1998 print_dot = section->vma;
2000 len = strlen (output_section_statement->name);
2001 if (len >= SECTION_NAME_MAP_LENGTH - 1)
2006 while (len < SECTION_NAME_MAP_LENGTH)
2012 minfo ("0x%V %W", section->vma, section->_raw_size);
2014 if (output_section_statement->load_base != NULL)
2018 addr = exp_get_abs_int (output_section_statement->load_base, 0,
2019 "load base", lang_final_phase_enum);
2020 minfo (_(" load address 0x%V"), addr);
2027 print_statement_list (output_section_statement->children.head,
2028 output_section_statement);
2032 print_assignment (assignment, output_section)
2033 lang_assignment_statement_type * assignment;
2034 lang_output_section_statement_type * output_section;
2037 etree_value_type result;
2039 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2042 result = exp_fold_tree (assignment->exp->assign.src, output_section,
2043 lang_final_phase_enum, print_dot, &print_dot);
2045 minfo ("0x%V", result.value + result.section->bfd_section->vma);
2056 exp_print_tree (assignment->exp);
2062 print_input_statement (statm)
2063 lang_input_statement_type * statm;
2065 if (statm->filename != (char *) NULL)
2067 fprintf (config.map_file, "LOAD %s\n", statm->filename);
2071 /* Print all symbols defined in a particular section. This is called
2072 via bfd_link_hash_traverse. */
2075 print_one_symbol (hash_entry, ptr)
2076 struct bfd_link_hash_entry *hash_entry;
2079 asection *sec = (asection *) ptr;
2081 if ((hash_entry->type == bfd_link_hash_defined
2082 || hash_entry->type == bfd_link_hash_defweak)
2083 && sec == hash_entry->u.def.section)
2087 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2090 (hash_entry->u.def.value
2091 + hash_entry->u.def.section->output_offset
2092 + hash_entry->u.def.section->output_section->vma));
2094 minfo (" %T\n", hash_entry->root.string);
2100 /* Print information about an input section to the map file. */
2103 print_input_section (in)
2104 lang_input_section_type * in;
2106 asection *i = in->section;
2107 bfd_size_type size = i->_cooked_size != 0 ? i->_cooked_size : i->_raw_size;
2113 minfo ("%s", i->name);
2115 if (i->output_section != NULL)
2119 len = 1 + strlen (i->name);
2120 if (len >= SECTION_NAME_MAP_LENGTH - 1)
2125 while (len < SECTION_NAME_MAP_LENGTH)
2131 minfo ("0x%V %W %B\n",
2132 i->output_section->vma + i->output_offset, size,
2135 if (i->_cooked_size != 0 && i->_cooked_size != i->_raw_size)
2137 len = SECTION_NAME_MAP_LENGTH + 3;
2149 minfo (_("%W (size before relaxing)\n"), i->_raw_size);
2152 bfd_link_hash_traverse (link_info.hash, print_one_symbol, (PTR) i);
2154 print_dot = i->output_section->vma + i->output_offset + size;
2160 print_fill_statement (fill)
2161 lang_fill_statement_type * fill;
2163 fprintf (config.map_file, " FILL mask 0x%x\n", fill->fill);
2167 print_data_statement (data)
2168 lang_data_statement_type * data;
2175 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2178 addr = data->output_vma;
2179 if (data->output_section != NULL)
2180 addr += data->output_section->vma;
2208 minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
2210 if (data->exp->type.node_class != etree_value)
2213 exp_print_tree (data->exp);
2218 print_dot = addr + size;
2221 /* Print an address statement. These are generated by options like
2225 print_address_statement (address)
2226 lang_address_statement_type *address;
2228 minfo (_("Address of section %s set to "), address->section_name);
2229 exp_print_tree (address->address);
2233 /* Print a reloc statement. */
2236 print_reloc_statement (reloc)
2237 lang_reloc_statement_type *reloc;
2243 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2246 addr = reloc->output_vma;
2247 if (reloc->output_section != NULL)
2248 addr += reloc->output_section->vma;
2250 size = bfd_get_reloc_size (reloc->howto);
2252 minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
2254 if (reloc->name != NULL)
2255 minfo ("%s+", reloc->name);
2257 minfo ("%s+", reloc->section->name);
2259 exp_print_tree (reloc->addend_exp);
2263 print_dot = addr + size;
2267 print_padding_statement (s)
2268 lang_padding_statement_type *s;
2275 len = sizeof " *fill*" - 1;
2276 while (len < SECTION_NAME_MAP_LENGTH)
2282 addr = s->output_offset;
2283 if (s->output_section != NULL)
2284 addr += s->output_section->vma;
2285 minfo ("0x%V %W", addr, s->size);
2288 minfo (" %u", s->fill);
2292 print_dot = addr + s->size;
2296 print_wild_statement (w, os)
2297 lang_wild_statement_type * w;
2298 lang_output_section_statement_type * os;
2302 if (w->filenames_sorted)
2304 if (w->exclude_filename != NULL)
2305 minfo ("EXCLUDE_FILE ( %s )", w->exclude_filename);
2306 if (w->filename != NULL)
2307 minfo ("%s", w->filename);
2310 if (w->filenames_sorted)
2314 if (w->sections_sorted)
2316 if (w->section_name != NULL)
2317 minfo ("%s", w->section_name);
2320 if (w->sections_sorted)
2326 print_statement_list (w->children.head, os);
2329 /* Print a group statement. */
2333 lang_group_statement_type *s;
2334 lang_output_section_statement_type *os;
2336 fprintf (config.map_file, "START GROUP\n");
2337 print_statement_list (s->children.head, os);
2338 fprintf (config.map_file, "END GROUP\n");
2341 /* Print the list of statements in S.
2342 This can be called for any statement type. */
2345 print_statement_list (s, os)
2346 lang_statement_union_type *s;
2347 lang_output_section_statement_type *os;
2351 print_statement (s, os);
2356 /* Print the first statement in statement list S.
2357 This can be called for any statement type. */
2360 print_statement (s, os)
2361 lang_statement_union_type *s;
2362 lang_output_section_statement_type *os;
2364 switch (s->header.type)
2367 fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
2370 case lang_constructors_statement_enum:
2371 if (constructor_list.head != NULL)
2373 if (constructors_sorted)
2374 minfo (" SORT (CONSTRUCTORS)\n");
2376 minfo (" CONSTRUCTORS\n");
2377 print_statement_list (constructor_list.head, os);
2380 case lang_wild_statement_enum:
2381 print_wild_statement (&s->wild_statement, os);
2383 case lang_address_statement_enum:
2384 print_address_statement (&s->address_statement);
2386 case lang_object_symbols_statement_enum:
2387 minfo (" CREATE_OBJECT_SYMBOLS\n");
2389 case lang_fill_statement_enum:
2390 print_fill_statement (&s->fill_statement);
2392 case lang_data_statement_enum:
2393 print_data_statement (&s->data_statement);
2395 case lang_reloc_statement_enum:
2396 print_reloc_statement (&s->reloc_statement);
2398 case lang_input_section_enum:
2399 print_input_section (&s->input_section);
2401 case lang_padding_statement_enum:
2402 print_padding_statement (&s->padding_statement);
2404 case lang_output_section_statement_enum:
2405 print_output_section_statement (&s->output_section_statement);
2407 case lang_assignment_statement_enum:
2408 print_assignment (&s->assignment_statement, os);
2410 case lang_target_statement_enum:
2411 fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
2413 case lang_output_statement_enum:
2414 minfo ("OUTPUT(%s", s->output_statement.name);
2415 if (output_target != NULL)
2416 minfo (" %s", output_target);
2419 case lang_input_statement_enum:
2420 print_input_statement (&s->input_statement);
2422 case lang_group_statement_enum:
2423 print_group (&s->group_statement, os);
2425 case lang_afile_asection_pair_statement_enum:
2434 print_statement_list (statement_list.head, abs_output_section);
2437 /* Print the first N statements in statement list S to STDERR.
2438 If N == 0, nothing is printed.
2439 If N < 0, the entire list is printed.
2440 Intended to be called from GDB. */
2443 dprint_statement (s, n)
2444 lang_statement_union_type * s;
2447 FILE *map_save = config.map_file;
2449 config.map_file = stderr;
2452 print_statement_list (s, abs_output_section);
2455 while (s && --n >= 0)
2457 print_statement (s, abs_output_section);
2462 config.map_file = map_save;
2466 insert_pad (this_ptr, fill, power, output_section_statement, dot)
2467 lang_statement_union_type ** this_ptr;
2470 asection * output_section_statement;
2473 /* Align this section first to the
2474 input sections requirement, then
2475 to the output section's requirement.
2476 If this alignment is > than any seen before,
2477 then record it too. Perform the alignment by
2478 inserting a magic 'padding' statement.
2481 unsigned int alignment_needed = align_power (dot, power) - dot;
2483 if (alignment_needed != 0)
2485 lang_statement_union_type *new =
2486 ((lang_statement_union_type *)
2487 stat_alloc (sizeof (lang_padding_statement_type)));
2489 /* Link into existing chain */
2490 new->header.next = *this_ptr;
2492 new->header.type = lang_padding_statement_enum;
2493 new->padding_statement.output_section = output_section_statement;
2494 new->padding_statement.output_offset =
2495 dot - output_section_statement->vma;
2496 new->padding_statement.fill = fill;
2497 new->padding_statement.size = alignment_needed;
2501 /* Remember the most restrictive alignment */
2502 if (power > output_section_statement->alignment_power)
2504 output_section_statement->alignment_power = power;
2506 output_section_statement->_raw_size += alignment_needed;
2507 return alignment_needed + dot;
2511 /* Work out how much this section will move the dot point */
2513 size_input_section (this_ptr, output_section_statement, fill, dot, relax)
2514 lang_statement_union_type ** this_ptr;
2515 lang_output_section_statement_type * output_section_statement;
2518 boolean relax ATTRIBUTE_UNUSED;
2520 lang_input_section_type *is = &((*this_ptr)->input_section);
2521 asection *i = is->section;
2523 if (is->ifile->just_syms_flag == false)
2525 if (output_section_statement->subsection_alignment != -1)
2526 i->alignment_power =
2527 output_section_statement->subsection_alignment;
2529 dot = insert_pad (this_ptr, fill, i->alignment_power,
2530 output_section_statement->bfd_section, dot);
2532 /* Remember where in the output section this input section goes */
2534 i->output_offset = dot - output_section_statement->bfd_section->vma;
2536 /* Mark how big the output section must be to contain this now
2538 if (i->_cooked_size != 0)
2539 dot += i->_cooked_size;
2541 dot += i->_raw_size;
2542 output_section_statement->bfd_section->_raw_size = dot - output_section_statement->bfd_section->vma;
2546 i->output_offset = i->vma - output_section_statement->bfd_section->vma;
2552 /* Check to see if any allocated sections overlap with other allocated
2553 sections. This can happen when the linker script specifically specifies
2554 the output section addresses of the two sections. */
2556 lang_check_section_addresses ()
2560 /* Scan all sections in the output list. */
2561 for (s = output_bfd->sections; s != NULL; s = s->next)
2562 /* Ignore sections which are not loaded or which have no contents. */
2563 if ((bfd_get_section_flags (output_bfd, s) & (SEC_ALLOC | SEC_LOAD))
2564 && bfd_section_size (output_bfd, s) != 0)
2568 /* Once we reach section 's' stop our seach. This prevents two
2569 warning messages from being produced, one for 'section A overlaps
2570 section B' and one for 'section B overlaps section A'. */
2571 for (os = output_bfd->sections; os != s; os = os->next)
2578 /* Only consider loadable sections with real contents. */
2579 if (((bfd_get_section_flags (output_bfd, os)
2580 & (SEC_ALLOC | SEC_LOAD)) == 0)
2581 || bfd_section_size (output_bfd, os) == 0)
2584 /* We must check the sections' LMA addresses not their
2585 VMA addresses because overlay sections can have
2586 overlapping VMAs but they must have distinct LMAs. */
2587 s_start = bfd_section_lma (output_bfd, s);
2588 os_start = bfd_section_lma (output_bfd, os);
2589 s_end = s_start + bfd_section_size (output_bfd, s) - 1;
2590 os_end = os_start + bfd_section_size (output_bfd, os) - 1;
2592 /* Look for an overlap. */
2593 if ((s_end < os_start) || (s_start > os_end))
2597 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2598 s->name, s_start, s_end, os->name, os_start, os_end);
2600 /* Once we have found one overlap for this section,
2601 stop looking for others. */
2607 /* This variable indicates whether bfd_relax_section should be called
2610 static boolean relax_again;
2612 /* Set the sizes for all the output sections. */
2615 lang_size_sections (s, output_section_statement, prev, fill, dot, relax)
2616 lang_statement_union_type * s;
2617 lang_output_section_statement_type * output_section_statement;
2618 lang_statement_union_type ** prev;
2623 /* Size up the sections from their constituent parts. */
2624 for (; s != (lang_statement_union_type *) NULL; s = s->next)
2626 switch (s->header.type)
2628 case lang_output_section_statement_enum:
2631 lang_output_section_statement_type *os = &s->output_section_statement;
2633 if (os->bfd_section == NULL)
2634 /* This section was never actually created. */
2637 /* If this is a COFF shared library section, use the size and
2638 address from the input section. FIXME: This is COFF
2639 specific; it would be cleaner if there were some other way
2640 to do this, but nothing simple comes to mind. */
2641 if ((os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
2645 if (os->children.head == NULL
2646 || os->children.head->next != NULL
2647 || os->children.head->header.type != lang_input_section_enum)
2648 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2651 input = os->children.head->input_section.section;
2652 bfd_set_section_vma (os->bfd_section->owner,
2654 bfd_section_vma (input->owner, input));
2655 os->bfd_section->_raw_size = input->_raw_size;
2659 if (bfd_is_abs_section (os->bfd_section))
2661 /* No matter what happens, an abs section starts at zero. */
2662 ASSERT (os->bfd_section->vma == 0);
2666 if (os->addr_tree == (etree_type *) NULL)
2668 /* No address specified for this section, get one
2669 from the region specification. */
2670 if (os->region == (lang_memory_region_type *) NULL
2671 || (((bfd_get_section_flags (output_bfd, os->bfd_section)
2672 & (SEC_ALLOC | SEC_LOAD)) != 0)
2673 && os->region->name[0] == '*'
2674 && strcmp (os->region->name, "*default*") == 0))
2676 os->region = lang_memory_default (os->bfd_section);
2679 /* If a loadable section is using the default memory
2680 region, and some non default memory regions were
2681 defined, issue a warning. */
2682 if ((bfd_get_section_flags (output_bfd, os->bfd_section)
2683 & (SEC_ALLOC | SEC_LOAD)) != 0
2684 && ! link_info.relocateable
2685 && strcmp (os->region->name, "*default*") == 0
2686 && lang_memory_region_list != NULL
2687 && (strcmp (lang_memory_region_list->name, "*default*") != 0
2688 || lang_memory_region_list->next != NULL))
2689 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2690 bfd_get_section_name (output_bfd, os->bfd_section));
2692 dot = os->region->current;
2694 if (os->section_alignment == -1)
2699 dot = align_power (dot, os->bfd_section->alignment_power);
2701 if (dot != olddot && config.warn_section_align)
2702 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2703 os->name, (unsigned int) (dot - olddot));
2710 r = exp_fold_tree (os->addr_tree,
2712 lang_allocating_phase_enum,
2714 if (r.valid_p == false)
2716 einfo (_("%F%S: non constant address expression for section %s\n"),
2719 dot = r.value + r.section->bfd_section->vma;
2722 /* The section starts here.
2723 First, align to what the section needs. */
2725 if (os->section_alignment != -1)
2726 dot = align_power (dot, os->section_alignment);
2728 bfd_set_section_vma (0, os->bfd_section, dot);
2730 os->bfd_section->output_offset = 0;
2733 (void) lang_size_sections (os->children.head, os, &os->children.head,
2734 os->fill, dot, relax);
2736 /* Ignore the size of the input sections, use the vma and size to
2739 after = ALIGN_N (os->bfd_section->vma +
2740 os->bfd_section->_raw_size,
2741 /* The coercion here is important, see ld.h. */
2742 (bfd_vma) os->block_value);
2744 if (bfd_is_abs_section (os->bfd_section))
2745 ASSERT (after == os->bfd_section->vma);
2747 os->bfd_section->_raw_size = after - os->bfd_section->vma;
2748 dot = os->bfd_section->vma + os->bfd_section->_raw_size;
2749 os->processed = true;
2751 /* Update dot in the region ?
2752 We only do this if the section is going to be allocated,
2753 since unallocated sections do not contribute to the region's
2754 overall size in memory. */
2755 if (os->region != (lang_memory_region_type *) NULL
2756 && (bfd_get_section_flags (output_bfd, os->bfd_section)
2757 & (SEC_ALLOC | SEC_LOAD)))
2759 os->region->current = dot;
2761 /* Make sure the new address is within the region. We
2762 explicitly permit the current address to be at the
2763 exact end of the region when the VMA is non-zero,
2764 in case the region is at the end of addressable
2765 memory and the calculation wraps around. */
2766 if ((os->region->current < os->region->origin
2767 || (os->region->current - os->region->origin
2768 > os->region->length))
2769 && ((os->region->current
2770 != os->region->origin + os->region->length)
2771 || os->bfd_section->vma == 0))
2774 if (os->addr_tree != (etree_type *) NULL)
2776 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2777 os->region->current,
2778 os->bfd_section->owner,
2779 os->bfd_section->name,
2784 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2786 os->bfd_section->owner,
2787 os->bfd_section->name);
2789 /* Reset the region pointer. */
2790 os->region->current = os->region->origin;
2796 case lang_constructors_statement_enum:
2797 dot = lang_size_sections (constructor_list.head,
2798 output_section_statement,
2799 &s->wild_statement.children.head,
2804 case lang_data_statement_enum:
2806 unsigned int size = 0;
2808 s->data_statement.output_vma = dot - output_section_statement->bfd_section->vma;
2809 s->data_statement.output_section =
2810 output_section_statement->bfd_section;
2812 switch (s->data_statement.type)
2830 output_section_statement->bfd_section->_raw_size += size;
2831 /* The output section gets contents, and then we inspect for
2832 any flags set in the input script which override any ALLOC. */
2833 output_section_statement->bfd_section->flags |= SEC_HAS_CONTENTS;
2834 if (!(output_section_statement->flags & SEC_NEVER_LOAD)) {
2835 output_section_statement->bfd_section->flags |= SEC_ALLOC | SEC_LOAD;
2840 case lang_reloc_statement_enum:
2844 s->reloc_statement.output_vma =
2845 dot - output_section_statement->bfd_section->vma;
2846 s->reloc_statement.output_section =
2847 output_section_statement->bfd_section;
2848 size = bfd_get_reloc_size (s->reloc_statement.howto);
2850 output_section_statement->bfd_section->_raw_size += size;
2854 case lang_wild_statement_enum:
2856 dot = lang_size_sections (s->wild_statement.children.head,
2857 output_section_statement,
2858 &s->wild_statement.children.head,
2864 case lang_object_symbols_statement_enum:
2865 link_info.create_object_symbols_section =
2866 output_section_statement->bfd_section;
2868 case lang_output_statement_enum:
2869 case lang_target_statement_enum:
2871 case lang_input_section_enum:
2875 i = (*prev)->input_section.section;
2878 if (i->_cooked_size == 0)
2879 i->_cooked_size = i->_raw_size;
2885 if (! bfd_relax_section (i->owner, i, &link_info, &again))
2886 einfo (_("%P%F: can't relax section: %E\n"));
2890 dot = size_input_section (prev,
2891 output_section_statement,
2892 output_section_statement->fill,
2896 case lang_input_statement_enum:
2898 case lang_fill_statement_enum:
2899 s->fill_statement.output_section = output_section_statement->bfd_section;
2901 fill = s->fill_statement.fill;
2903 case lang_assignment_statement_enum:
2905 bfd_vma newdot = dot;
2907 exp_fold_tree (s->assignment_statement.exp,
2908 output_section_statement,
2909 lang_allocating_phase_enum,
2915 /* The assignment changed dot. Insert a pad. */
2916 if (output_section_statement == abs_output_section)
2918 /* If we don't have an output section, then just adjust
2919 the default memory address. */
2920 lang_memory_region_lookup ("*default*")->current = newdot;
2924 lang_statement_union_type *new =
2925 ((lang_statement_union_type *)
2926 stat_alloc (sizeof (lang_padding_statement_type)));
2928 /* Link into existing chain. */
2929 new->header.next = *prev;
2931 new->header.type = lang_padding_statement_enum;
2932 new->padding_statement.output_section =
2933 output_section_statement->bfd_section;
2934 new->padding_statement.output_offset =
2935 dot - output_section_statement->bfd_section->vma;
2936 new->padding_statement.fill = fill;
2937 new->padding_statement.size = newdot - dot;
2938 output_section_statement->bfd_section->_raw_size +=
2939 new->padding_statement.size;
2947 case lang_padding_statement_enum:
2948 /* If we are relaxing, and this is not the first pass, some
2949 padding statements may have been inserted during previous
2950 passes. We may have to move the padding statement to a new
2951 location if dot has a different value at this point in this
2952 pass than it did at this point in the previous pass. */
2953 s->padding_statement.output_offset =
2954 dot - output_section_statement->bfd_section->vma;
2955 dot += s->padding_statement.size;
2956 output_section_statement->bfd_section->_raw_size +=
2957 s->padding_statement.size;
2960 case lang_group_statement_enum:
2961 dot = lang_size_sections (s->group_statement.children.head,
2962 output_section_statement,
2963 &s->group_statement.children.head,
2971 /* This can only get here when relaxing is turned on. */
2973 case lang_address_statement_enum:
2976 prev = &s->header.next;
2982 lang_do_assignments (s, output_section_statement, fill, dot)
2983 lang_statement_union_type * s;
2984 lang_output_section_statement_type * output_section_statement;
2988 for (; s != (lang_statement_union_type *) NULL; s = s->next)
2990 switch (s->header.type)
2992 case lang_constructors_statement_enum:
2993 dot = lang_do_assignments (constructor_list.head,
2994 output_section_statement,
2999 case lang_output_section_statement_enum:
3001 lang_output_section_statement_type *os =
3002 &(s->output_section_statement);
3004 if (os->bfd_section != NULL)
3006 dot = os->bfd_section->vma;
3007 (void) lang_do_assignments (os->children.head, os,
3009 dot = os->bfd_section->vma + os->bfd_section->_raw_size;
3013 /* If nothing has been placed into the output section then
3014 it won't have a bfd_section. */
3015 if (os->bfd_section)
3017 os->bfd_section->lma
3018 = exp_get_abs_int(os->load_base, 0,"load base", lang_final_phase_enum);
3023 case lang_wild_statement_enum:
3025 dot = lang_do_assignments (s->wild_statement.children.head,
3026 output_section_statement,
3031 case lang_object_symbols_statement_enum:
3032 case lang_output_statement_enum:
3033 case lang_target_statement_enum:
3035 case lang_common_statement_enum:
3038 case lang_data_statement_enum:
3040 etree_value_type value;
3042 value = exp_fold_tree (s->data_statement.exp,
3044 lang_final_phase_enum, dot, &dot);
3045 s->data_statement.value = value.value;
3046 if (value.valid_p == false)
3047 einfo (_("%F%P: invalid data statement\n"));
3049 switch (s->data_statement.type)
3067 case lang_reloc_statement_enum:
3069 etree_value_type value;
3071 value = exp_fold_tree (s->reloc_statement.addend_exp,
3073 lang_final_phase_enum, dot, &dot);
3074 s->reloc_statement.addend_value = value.value;
3075 if (value.valid_p == false)
3076 einfo (_("%F%P: invalid reloc statement\n"));
3078 dot += bfd_get_reloc_size (s->reloc_statement.howto);
3081 case lang_input_section_enum:
3083 asection *in = s->input_section.section;
3085 if (in->_cooked_size != 0)
3086 dot += in->_cooked_size;
3088 dot += in->_raw_size;
3092 case lang_input_statement_enum:
3094 case lang_fill_statement_enum:
3095 fill = s->fill_statement.fill;
3097 case lang_assignment_statement_enum:
3099 exp_fold_tree (s->assignment_statement.exp,
3100 output_section_statement,
3101 lang_final_phase_enum,
3107 case lang_padding_statement_enum:
3108 dot += s->padding_statement.size;
3111 case lang_group_statement_enum:
3112 dot = lang_do_assignments (s->group_statement.children.head,
3113 output_section_statement,
3121 case lang_address_statement_enum:
3129 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3130 operator .startof. (section_name), it produces an undefined symbol
3131 .startof.section_name. Similarly, when it sees
3132 .sizeof. (section_name), it produces an undefined symbol
3133 .sizeof.section_name. For all the output sections, we look for
3134 such symbols, and set them to the correct value. */
3141 if (link_info.relocateable)
3144 for (s = output_bfd->sections; s != NULL; s = s->next)
3146 const char *secname;
3148 struct bfd_link_hash_entry *h;
3150 secname = bfd_get_section_name (output_bfd, s);
3151 buf = xmalloc (10 + strlen (secname));
3153 sprintf (buf, ".startof.%s", secname);
3154 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3155 if (h != NULL && h->type == bfd_link_hash_undefined)
3157 h->type = bfd_link_hash_defined;
3158 h->u.def.value = bfd_get_section_vma (output_bfd, s);
3159 h->u.def.section = bfd_abs_section_ptr;
3162 sprintf (buf, ".sizeof.%s", secname);
3163 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3164 if (h != NULL && h->type == bfd_link_hash_undefined)
3166 h->type = bfd_link_hash_defined;
3167 if (s->_cooked_size != 0)
3168 h->u.def.value = s->_cooked_size;
3170 h->u.def.value = s->_raw_size;
3171 h->u.def.section = bfd_abs_section_ptr;
3181 struct bfd_link_hash_entry *h;
3184 if (link_info.relocateable || link_info.shared)
3189 if (entry_symbol == (char *) NULL)
3191 /* No entry has been specified. Look for start, but don't warn
3192 if we don't find it. */
3193 entry_symbol = "start";
3197 h = bfd_link_hash_lookup (link_info.hash, entry_symbol, false, false, true);
3198 if (h != (struct bfd_link_hash_entry *) NULL
3199 && (h->type == bfd_link_hash_defined
3200 || h->type == bfd_link_hash_defweak)
3201 && h->u.def.section->output_section != NULL)
3205 val = (h->u.def.value
3206 + bfd_get_section_vma (output_bfd,
3207 h->u.def.section->output_section)
3208 + h->u.def.section->output_offset);
3209 if (! bfd_set_start_address (output_bfd, val))
3210 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol);
3217 /* We couldn't find the entry symbol. Try parsing it as a
3219 val = bfd_scan_vma (entry_symbol, &send, 0);
3222 if (! bfd_set_start_address (output_bfd, val))
3223 einfo (_("%P%F: can't set start address\n"));
3229 /* Can't find the entry symbol, and it's not a number. Use
3230 the first address in the text section. */
3231 ts = bfd_get_section_by_name (output_bfd, ".text");
3232 if (ts != (asection *) NULL)
3235 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3236 entry_symbol, bfd_get_section_vma (output_bfd, ts));
3237 if (! bfd_set_start_address (output_bfd,
3238 bfd_get_section_vma (output_bfd,
3240 einfo (_("%P%F: can't set start address\n"));
3245 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3252 /* This is a small function used when we want to ignore errors from
3256 #ifdef ANSI_PROTOTYPES
3257 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
3259 ignore_bfd_errors (s)
3260 const char *s ATTRIBUTE_UNUSED;
3263 /* Don't do anything. */
3266 /* Check that the architecture of all the input files is compatible
3267 with the output file. Also call the backend to let it do any
3268 other checking that is needed. */
3273 lang_statement_union_type *file;
3275 CONST bfd_arch_info_type *compatible;
3277 for (file = file_chain.head;
3278 file != (lang_statement_union_type *) NULL;
3279 file = file->input_statement.next)
3281 input_bfd = file->input_statement.the_bfd;
3282 compatible = bfd_arch_get_compatible (input_bfd,
3284 if (compatible == NULL)
3286 if (command_line.warn_mismatch)
3287 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3288 bfd_printable_name (input_bfd), input_bfd,
3289 bfd_printable_name (output_bfd));
3293 bfd_error_handler_type pfn = NULL;
3295 /* If we aren't supposed to warn about mismatched input
3296 files, temporarily set the BFD error handler to a
3297 function which will do nothing. We still want to call
3298 bfd_merge_private_bfd_data, since it may set up
3299 information which is needed in the output file. */
3300 if (! command_line.warn_mismatch)
3301 pfn = bfd_set_error_handler (ignore_bfd_errors);
3302 if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
3304 if (command_line.warn_mismatch)
3305 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3308 if (! command_line.warn_mismatch)
3309 bfd_set_error_handler (pfn);
3314 /* Look through all the global common symbols and attach them to the
3315 correct section. The -sort-common command line switch may be used
3316 to roughly sort the entries by size. */
3321 if (link_info.relocateable
3322 && ! command_line.force_common_definition)
3325 if (! config.sort_common)
3326 bfd_link_hash_traverse (link_info.hash, lang_one_common, (PTR) NULL);
3331 for (power = 4; power >= 0; power--)
3332 bfd_link_hash_traverse (link_info.hash, lang_one_common,
3337 /* Place one common symbol in the correct section. */
3340 lang_one_common (h, info)
3341 struct bfd_link_hash_entry *h;
3344 unsigned int power_of_two;
3348 if (h->type != bfd_link_hash_common)
3352 power_of_two = h->u.c.p->alignment_power;
3354 if (config.sort_common
3355 && power_of_two < (unsigned int) *(int *) info)
3358 section = h->u.c.p->section;
3360 /* Increase the size of the section. */
3361 section->_cooked_size = ALIGN_N (section->_cooked_size,
3362 (bfd_size_type) (1 << power_of_two));
3364 /* Adjust the alignment if necessary. */
3365 if (power_of_two > section->alignment_power)
3366 section->alignment_power = power_of_two;
3368 /* Change the symbol from common to defined. */
3369 h->type = bfd_link_hash_defined;
3370 h->u.def.section = section;
3371 h->u.def.value = section->_cooked_size;
3373 /* Increase the size of the section. */
3374 section->_cooked_size += size;
3376 /* Make sure the section is allocated in memory, and make sure that
3377 it is no longer a common section. */
3378 section->flags |= SEC_ALLOC;
3379 section->flags &= ~ SEC_IS_COMMON;
3381 if (config.map_file != NULL)
3383 static boolean header_printed;
3388 if (! header_printed)
3390 minfo (_("\nAllocating common symbols\n"));
3391 minfo (_("Common symbol size file\n\n"));
3392 header_printed = true;
3395 name = demangle (h->root.string);
3397 len = strlen (name);
3412 if (size <= 0xffffffff)
3413 sprintf (buf, "%lx", (unsigned long) size);
3415 sprintf_vma (buf, size);
3425 minfo ("%B\n", section->owner);
3432 run through the input files and ensure that every input
3433 section has somewhere to go. If one is found without
3434 a destination then create an input request and place it
3435 into the statement tree.
3439 lang_place_orphans ()
3441 LANG_FOR_EACH_INPUT_STATEMENT (file)
3445 for (s = file->the_bfd->sections;
3446 s != (asection *) NULL;
3449 if (s->output_section == (asection *) NULL)
3451 /* This section of the file is not attatched, root
3452 around for a sensible place for it to go */
3454 if (file->just_syms_flag)
3456 /* We are only retrieving symbol values from this
3457 file. We want the symbols to act as though the
3458 values in the file are absolute. */
3459 s->output_section = bfd_abs_section_ptr;
3460 s->output_offset = s->vma;
3462 else if (strcmp (s->name, "COMMON") == 0)
3464 /* This is a lonely common section which must have
3465 come from an archive. We attach to the section
3466 with the wildcard. */
3467 if (! link_info.relocateable
3468 || command_line.force_common_definition)
3470 if (default_common_section == NULL)
3473 /* This message happens when using the
3474 svr3.ifile linker script, so I have
3476 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3478 default_common_section =
3479 lang_output_section_statement_lookup (".bss");
3482 wild_doit (&default_common_section->children, s,
3483 default_common_section, file);
3486 else if (ldemul_place_orphan (file, s))
3490 lang_output_section_statement_type *os =
3491 lang_output_section_statement_lookup (s->name);
3493 wild_doit (&os->children, s, os, file);
3502 lang_set_flags (ptr, flags, invert)
3503 lang_memory_region_type *ptr;
3507 flagword *ptr_flags;
3509 ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
3515 *ptr_flags |= SEC_ALLOC;
3519 *ptr_flags |= SEC_READONLY;
3523 *ptr_flags |= SEC_DATA;
3527 *ptr_flags |= SEC_CODE;
3532 *ptr_flags |= SEC_LOAD;
3536 einfo (_("%P%F: invalid syntax in flags\n"));
3543 /* Call a function on each input file. This function will be called
3544 on an archive, but not on the elements. */
3547 lang_for_each_input_file (func)
3548 void (*func) PARAMS ((lang_input_statement_type *));
3550 lang_input_statement_type *f;
3552 for (f = (lang_input_statement_type *) input_file_chain.head;
3554 f = (lang_input_statement_type *) f->next_real_file)
3558 /* Call a function on each file. The function will be called on all
3559 the elements of an archive which are included in the link, but will
3560 not be called on the archive file itself. */
3563 lang_for_each_file (func)
3564 void (*func) PARAMS ((lang_input_statement_type *));
3566 LANG_FOR_EACH_INPUT_STATEMENT (f)
3577 lang_for_each_input_section (func)
3578 void (*func) PARAMS ((bfd * ab, asection * as));
3580 LANG_FOR_EACH_INPUT_STATEMENT (f)
3584 for (s = f->the_bfd->sections;
3585 s != (asection *) NULL;
3588 func (f->the_bfd, s);
3596 ldlang_add_file (entry)
3597 lang_input_statement_type * entry;
3601 lang_statement_append (&file_chain,
3602 (lang_statement_union_type *) entry,
3605 /* The BFD linker needs to have a list of all input BFDs involved in
3607 ASSERT (entry->the_bfd->link_next == (bfd *) NULL);
3608 ASSERT (entry->the_bfd != output_bfd);
3609 for (pp = &link_info.input_bfds;
3610 *pp != (bfd *) NULL;
3611 pp = &(*pp)->link_next)
3613 *pp = entry->the_bfd;
3614 entry->the_bfd->usrdata = (PTR) entry;
3615 bfd_set_gp_size (entry->the_bfd, g_switch_value);
3617 /* Look through the sections and check for any which should not be
3618 included in the link. We need to do this now, so that we can
3619 notice when the backend linker tries to report multiple
3620 definition errors for symbols which are in sections we aren't
3621 going to link. FIXME: It might be better to entirely ignore
3622 symbols which are defined in sections which are going to be
3623 discarded. This would require modifying the backend linker for
3624 each backend which might set the SEC_LINK_ONCE flag. If we do
3625 this, we should probably handle SEC_EXCLUDE in the same way. */
3627 bfd_map_over_sections (entry->the_bfd, section_already_linked, (PTR) entry);
3631 lang_add_output (name, from_script)
3635 /* Make -o on command line override OUTPUT in script. */
3636 if (had_output_filename == false || !from_script)
3638 output_filename = name;
3639 had_output_filename = true;
3644 static lang_output_section_statement_type *current_section;
3656 for (l = 0; l < 32; l++)
3658 if (i >= (unsigned int) x)
3667 lang_enter_output_section_statement (output_section_statement_name,
3668 address_exp, sectype, block_value,
3669 align, subalign, ebase)
3670 const char *output_section_statement_name;
3671 etree_type * address_exp;
3672 enum section_type sectype;
3673 bfd_vma block_value;
3675 etree_type *subalign;
3678 lang_output_section_statement_type *os;
3682 lang_output_section_statement_lookup (output_section_statement_name);
3686 /* Add this statement to tree */
3687 /* add_statement(lang_output_section_statement_enum,
3688 output_section_statement);*/
3689 /* Make next things chain into subchain of this */
3691 if (os->addr_tree ==
3692 (etree_type *) NULL)
3697 os->sectype = sectype;
3698 if (sectype != noload_section)
3699 os->flags = SEC_NO_FLAGS;
3701 os->flags = SEC_NEVER_LOAD;
3702 os->block_value = block_value ? block_value : 1;
3703 stat_ptr = &os->children;
3705 os->subsection_alignment = topower(
3706 exp_get_value_int(subalign, -1,
3707 "subsection alignment",
3709 os->section_alignment = topower(
3710 exp_get_value_int(align, -1,
3711 "section alignment", 0));
3713 os->load_base = ebase;
3720 lang_output_statement_type *new =
3721 new_stat (lang_output_statement, stat_ptr);
3723 new->name = output_filename;
3726 /* Reset the current counters in the regions */
3728 reset_memory_regions ()
3730 lang_memory_region_type *p = lang_memory_region_list;
3732 for (p = lang_memory_region_list;
3733 p != (lang_memory_region_type *) NULL;
3736 p->old_length = (bfd_size_type) (p->current - p->origin);
3737 p->current = p->origin;
3741 /* Expand a wild statement for a particular FILE, marking its sections KEEP
3742 as needed. SECTION may be NULL, in which case it is a wild card. */
3745 gc_section_callback (ptr, section, file, data)
3746 lang_wild_statement_type *ptr;
3748 lang_input_statement_type *file ATTRIBUTE_UNUSED;
3749 void *data ATTRIBUTE_UNUSED;
3751 /* If the wild pattern was marked KEEP, the member sections
3752 should be as well. */
3753 if (ptr->keep_sections)
3754 section->flags |= SEC_KEEP;
3757 /* Handle a wild statement, marking it against GC. SECTION or FILE or both
3758 may be NULL, indicating that it is a wildcard. */
3761 lang_gc_wild (s, section, file)
3762 lang_wild_statement_type *s;
3763 const char *section;
3766 walk_wild (s, section, file, gc_section_callback, NULL);
3769 /* Iterate over sections marking them against GC. */
3772 lang_gc_sections_1 (s)
3773 lang_statement_union_type * s;
3775 for (; s != (lang_statement_union_type *) NULL; s = s->next)
3777 switch (s->header.type)
3779 case lang_wild_statement_enum:
3780 lang_gc_wild (&s->wild_statement,
3781 s->wild_statement.section_name,
3782 s->wild_statement.filename);
3784 case lang_constructors_statement_enum:
3785 lang_gc_sections_1 (constructor_list.head);
3787 case lang_output_section_statement_enum:
3788 lang_gc_sections_1 (s->output_section_statement.children.head);
3790 case lang_group_statement_enum:
3791 lang_gc_sections_1 (s->group_statement.children.head);
3802 struct bfd_link_hash_entry *h;
3803 ldlang_undef_chain_list_type *ulist, fake_list_start;
3805 /* Keep all sections so marked in the link script. */
3807 lang_gc_sections_1 (statement_list.head);
3809 /* Keep all sections containing symbols undefined on the command-line.
3810 Handle the entry symbol at the same time. */
3812 if (entry_symbol != NULL)
3814 fake_list_start.next = ldlang_undef_chain_list_head;
3815 fake_list_start.name = (char *) entry_symbol;
3816 ulist = &fake_list_start;
3819 ulist = ldlang_undef_chain_list_head;
3821 for (; ulist; ulist = ulist->next)
3823 h = bfd_link_hash_lookup (link_info.hash, ulist->name,
3824 false, false, false);
3826 if (h != (struct bfd_link_hash_entry *) NULL
3827 && (h->type == bfd_link_hash_defined
3828 || h->type == bfd_link_hash_defweak)
3829 && ! bfd_is_abs_section (h->u.def.section))
3831 h->u.def.section->flags |= SEC_KEEP;
3835 bfd_gc_sections (output_bfd, &link_info);
3841 lang_reasonable_defaults ();
3842 current_target = default_target;
3844 lang_for_each_statement (ldlang_open_output); /* Open the output file */
3846 ldemul_create_output_section_statements ();
3848 /* Add to the hash table all undefineds on the command line */
3849 lang_place_undefineds ();
3851 /* Create a bfd for each input file */
3852 current_target = default_target;
3853 open_input_bfds (statement_list.head, false);
3855 ldemul_after_open ();
3857 /* Make sure that we're not mixing architectures. We call this
3858 after all the input files have been opened, but before we do any
3859 other processing, so that any operations merge_private_bfd_data
3860 does on the output file will be known during the rest of the
3864 /* Handle .exports instead of a version script if we're told to do so. */
3865 if (command_line.version_exports_section)
3866 lang_do_version_exports_section ();
3868 /* Build all sets based on the information gathered from the input
3870 ldctor_build_sets ();
3872 /* Remove unreferenced sections if asked to. */
3873 if (command_line.gc_sections)
3874 lang_gc_sections ();
3876 /* Size up the common data */
3879 /* Run through the contours of the script and attach input sections
3880 to the correct output sections
3882 map_input_to_output_sections (statement_list.head, (char *) NULL,
3883 (lang_output_section_statement_type *) NULL);
3886 /* Find any sections not attached explicitly and handle them */
3887 lang_place_orphans ();
3889 ldemul_before_allocation ();
3891 /* We must record the program headers before we try to fix the
3892 section positions, since they will affect SIZEOF_HEADERS. */
3893 lang_record_phdrs ();
3895 /* Now run around and relax if we can */
3896 if (command_line.relax)
3898 /* First time round is a trial run to get the 'worst case'
3899 addresses of the objects if there was no relaxing. */
3900 lang_size_sections (statement_list.head,
3902 &(statement_list.head), 0, (bfd_vma) 0, false);
3904 /* Keep relaxing until bfd_relax_section gives up. */
3907 reset_memory_regions ();
3909 relax_again = false;
3911 /* Note: pe-dll.c does something like this also. If you find
3912 you need to change this code, you probably need to change
3913 pe-dll.c also. DJ */
3915 /* Do all the assignments with our current guesses as to
3917 lang_do_assignments (statement_list.head,
3919 (fill_type) 0, (bfd_vma) 0);
3921 /* Perform another relax pass - this time we know where the
3922 globals are, so can make better guess. */
3923 lang_size_sections (statement_list.head,
3925 &(statement_list.head), 0, (bfd_vma) 0, true);
3927 while (relax_again);
3931 /* Size up the sections. */
3932 lang_size_sections (statement_list.head,
3934 &(statement_list.head), 0, (bfd_vma) 0, false);
3937 /* See if anything special should be done now we know how big
3939 ldemul_after_allocation ();
3941 /* Fix any .startof. or .sizeof. symbols. */
3942 lang_set_startof ();
3944 /* Do all the assignments, now that we know the final restingplaces
3945 of all the symbols */
3947 lang_do_assignments (statement_list.head,
3949 (fill_type) 0, (bfd_vma) 0);
3951 /* Make sure that the section addresses make sense. */
3952 if (! link_info.relocateable
3953 && command_line.check_section_addresses)
3954 lang_check_section_addresses ();
3962 /* EXPORTED TO YACC */
3965 lang_add_wild (section_name, sections_sorted, filename, filenames_sorted,
3966 keep_sections, exclude_filename)
3967 const char *const section_name;
3968 boolean sections_sorted;
3969 const char *const filename;
3970 boolean filenames_sorted;
3971 boolean keep_sections;
3972 const char *exclude_filename;
3974 lang_wild_statement_type *new = new_stat (lang_wild_statement,
3977 if (section_name != (char *) NULL && strcmp (section_name, "COMMON") == 0)
3979 placed_commons = true;
3981 if (filename != NULL && ! wildcardp (filename))
3983 lang_has_input_file = true;
3985 new->section_name = section_name;
3986 new->sections_sorted = sections_sorted;
3987 new->filename = filename;
3988 new->filenames_sorted = filenames_sorted;
3989 new->keep_sections = keep_sections;
3990 new->exclude_filename = exclude_filename;
3991 lang_list_init (&new->children);
3995 lang_section_start (name, address)
3997 etree_type * address;
3999 lang_address_statement_type *ad = new_stat (lang_address_statement, stat_ptr);
4001 ad->section_name = name;
4002 ad->address = address;
4005 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4006 because of a -e argument on the command line, or zero if this is
4007 called by ENTRY in a linker script. Command line arguments take
4011 lang_add_entry (name, cmdline)
4015 if (entry_symbol == NULL
4017 || ! entry_from_cmdline)
4019 entry_symbol = name;
4020 entry_from_cmdline = cmdline;
4025 lang_add_target (name)
4028 lang_target_statement_type *new = new_stat (lang_target_statement,
4044 map_option_f = true;
4055 lang_fill_statement_type *new = new_stat (lang_fill_statement,
4062 lang_add_data (type, exp)
4064 union etree_union *exp;
4067 lang_data_statement_type *new = new_stat (lang_data_statement,
4075 /* Create a new reloc statement. RELOC is the BFD relocation type to
4076 generate. HOWTO is the corresponding howto structure (we could
4077 look this up, but the caller has already done so). SECTION is the
4078 section to generate a reloc against, or NAME is the name of the
4079 symbol to generate a reloc against. Exactly one of SECTION and
4080 NAME must be NULL. ADDEND is an expression for the addend. */
4083 lang_add_reloc (reloc, howto, section, name, addend)
4084 bfd_reloc_code_real_type reloc;
4085 reloc_howto_type *howto;
4088 union etree_union *addend;
4090 lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
4094 p->section = section;
4096 p->addend_exp = addend;
4098 p->addend_value = 0;
4099 p->output_section = NULL;
4103 lang_assignment_statement_type *
4104 lang_add_assignment (exp)
4107 lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
4115 lang_add_attribute (attribute)
4116 enum statement_enum attribute;
4118 new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
4125 if (startup_file != (char *) NULL)
4127 einfo (_("%P%Fmultiple STARTUP files\n"));
4129 first_file->filename = name;
4130 first_file->local_sym_name = name;
4131 first_file->real = true;
4133 startup_file = name;
4140 lang_float_flag = maybe;
4144 lang_leave_output_section_statement (fill, memspec, phdrs)
4146 const char *memspec;
4147 struct lang_output_section_phdr_list *phdrs;
4149 current_section->fill = fill;
4150 current_section->region = lang_memory_region_lookup (memspec);
4151 current_section->phdrs = phdrs;
4152 stat_ptr = &statement_list;
4156 Create an absolute symbol with the given name with the value of the
4157 address of first byte of the section named.
4159 If the symbol already exists, then do nothing.
4162 lang_abs_symbol_at_beginning_of (secname, name)
4163 const char *secname;
4166 struct bfd_link_hash_entry *h;
4168 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4169 if (h == (struct bfd_link_hash_entry *) NULL)
4170 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4172 if (h->type == bfd_link_hash_new
4173 || h->type == bfd_link_hash_undefined)
4177 h->type = bfd_link_hash_defined;
4179 sec = bfd_get_section_by_name (output_bfd, secname);
4180 if (sec == (asection *) NULL)
4183 h->u.def.value = bfd_get_section_vma (output_bfd, sec);
4185 h->u.def.section = bfd_abs_section_ptr;
4190 Create an absolute symbol with the given name with the value of the
4191 address of the first byte after the end of the section named.
4193 If the symbol already exists, then do nothing.
4196 lang_abs_symbol_at_end_of (secname, name)
4197 const char *secname;
4200 struct bfd_link_hash_entry *h;
4202 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4203 if (h == (struct bfd_link_hash_entry *) NULL)
4204 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4206 if (h->type == bfd_link_hash_new
4207 || h->type == bfd_link_hash_undefined)
4211 h->type = bfd_link_hash_defined;
4213 sec = bfd_get_section_by_name (output_bfd, secname);
4214 if (sec == (asection *) NULL)
4217 h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
4218 + bfd_section_size (output_bfd, sec));
4220 h->u.def.section = bfd_abs_section_ptr;
4225 lang_statement_append (list, element, field)
4226 lang_statement_list_type * list;
4227 lang_statement_union_type * element;
4228 lang_statement_union_type ** field;
4230 *(list->tail) = element;
4234 /* Set the output format type. -oformat overrides scripts. */
4237 lang_add_output_format (format, big, little, from_script)
4243 if (output_target == NULL || !from_script)
4245 if (command_line.endian == ENDIAN_BIG
4248 else if (command_line.endian == ENDIAN_LITTLE
4252 output_target = format;
4256 /* Enter a group. This creates a new lang_group_statement, and sets
4257 stat_ptr to build new statements within the group. */
4262 lang_group_statement_type *g;
4264 g = new_stat (lang_group_statement, stat_ptr);
4265 lang_list_init (&g->children);
4266 stat_ptr = &g->children;
4269 /* Leave a group. This just resets stat_ptr to start writing to the
4270 regular list of statements again. Note that this will not work if
4271 groups can occur inside anything else which can adjust stat_ptr,
4272 but currently they can't. */
4277 stat_ptr = &statement_list;
4280 /* Add a new program header. This is called for each entry in a PHDRS
4281 command in a linker script. */
4284 lang_new_phdr (name, type, filehdr, phdrs, at, flags)
4292 struct lang_phdr *n, **pp;
4294 n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));
4297 n->type = exp_get_value_int (type, 0, "program header type",
4298 lang_final_phase_enum);
4299 n->filehdr = filehdr;
4304 for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
4309 /* Record the program header information in the output BFD. FIXME: We
4310 should not be calling an ELF specific function here. */
4313 lang_record_phdrs ()
4317 struct lang_output_section_phdr_list *last;
4318 struct lang_phdr *l;
4319 lang_statement_union_type *u;
4322 secs = (asection **) xmalloc (alc * sizeof (asection *));
4324 for (l = lang_phdr_list; l != NULL; l = l->next)
4331 for (u = lang_output_section_statement.head;
4333 u = u->output_section_statement.next)
4335 lang_output_section_statement_type *os;
4336 struct lang_output_section_phdr_list *pl;
4338 os = &u->output_section_statement;
4345 if (os->sectype == noload_section
4346 || os->bfd_section == NULL
4347 || (os->bfd_section->flags & SEC_ALLOC) == 0)
4352 if (os->bfd_section == NULL)
4355 for (; pl != NULL; pl = pl->next)
4357 if (strcmp (pl->name, l->name) == 0)
4362 secs = ((asection **)
4363 xrealloc (secs, alc * sizeof (asection *)));
4365 secs[c] = os->bfd_section;
4372 if (l->flags == NULL)
4375 flags = exp_get_vma (l->flags, 0, "phdr flags",
4376 lang_final_phase_enum);
4381 at = exp_get_vma (l->at, 0, "phdr load address",
4382 lang_final_phase_enum);
4384 if (! bfd_record_phdr (output_bfd, l->type,
4385 l->flags == NULL ? false : true,
4387 l->at == NULL ? false : true,
4388 at, l->filehdr, l->phdrs, c, secs))
4389 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4394 /* Make sure all the phdr assignments succeeded. */
4395 for (u = lang_output_section_statement.head;
4397 u = u->output_section_statement.next)
4399 struct lang_output_section_phdr_list *pl;
4401 if (u->output_section_statement.bfd_section == NULL)
4404 for (pl = u->output_section_statement.phdrs;
4407 if (! pl->used && strcmp (pl->name, "NONE") != 0)
4408 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4409 u->output_section_statement.name, pl->name);
4413 /* Record a list of sections which may not be cross referenced. */
4416 lang_add_nocrossref (l)
4417 struct lang_nocrossref *l;
4419 struct lang_nocrossrefs *n;
4421 n = (struct lang_nocrossrefs *) xmalloc (sizeof *n);
4422 n->next = nocrossref_list;
4424 nocrossref_list = n;
4426 /* Set notice_all so that we get informed about all symbols. */
4427 link_info.notice_all = true;
4430 /* Overlay handling. We handle overlays with some static variables. */
4432 /* The overlay virtual address. */
4433 static etree_type *overlay_vma;
4435 /* The overlay load address. */
4436 static etree_type *overlay_lma;
4438 /* Whether nocrossrefs is set for this overlay. */
4439 static int overlay_nocrossrefs;
4441 /* An expression for the maximum section size seen so far. */
4442 static etree_type *overlay_max;
4444 /* A list of all the sections in this overlay. */
4448 struct overlay_list *next;
4449 lang_output_section_statement_type *os;
4452 static struct overlay_list *overlay_list;
4454 /* Start handling an overlay. */
4457 lang_enter_overlay (vma_expr, lma_expr, nocrossrefs)
4458 etree_type *vma_expr;
4459 etree_type *lma_expr;
4462 /* The grammar should prevent nested overlays from occurring. */
4463 ASSERT (overlay_vma == NULL
4464 && overlay_lma == NULL
4465 && overlay_list == NULL
4466 && overlay_max == NULL);
4468 overlay_vma = vma_expr;
4469 overlay_lma = lma_expr;
4470 overlay_nocrossrefs = nocrossrefs;
4473 /* Start a section in an overlay. We handle this by calling
4474 lang_enter_output_section_statement with the correct VMA and LMA. */
4477 lang_enter_overlay_section (name)
4480 struct overlay_list *n;
4483 lang_enter_output_section_statement (name, overlay_vma, normal_section,
4484 0, 0, 0, overlay_lma);
4486 /* If this is the first section, then base the VMA and LMA of future
4487 sections on this one. This will work correctly even if `.' is
4488 used in the addresses. */
4489 if (overlay_list == NULL)
4491 overlay_vma = exp_nameop (ADDR, name);
4492 overlay_lma = exp_nameop (LOADADDR, name);
4495 /* Remember the section. */
4496 n = (struct overlay_list *) xmalloc (sizeof *n);
4497 n->os = current_section;
4498 n->next = overlay_list;
4501 size = exp_nameop (SIZEOF, name);
4503 /* Adjust the LMA for the next section. */
4504 overlay_lma = exp_binop ('+', overlay_lma, size);
4506 /* Arrange to work out the maximum section end address. */
4507 if (overlay_max == NULL)
4510 overlay_max = exp_binop (MAX_K, overlay_max, size);
4513 /* Finish a section in an overlay. There isn't any special to do
4517 lang_leave_overlay_section (fill, phdrs)
4519 struct lang_output_section_phdr_list *phdrs;
4526 name = current_section->name;
4528 lang_leave_output_section_statement (fill, "*default*", phdrs);
4530 /* Define the magic symbols. */
4532 clean = xmalloc (strlen (name) + 1);
4534 for (s1 = name; *s1 != '\0'; s1++)
4535 if (isalnum ((unsigned char) *s1) || *s1 == '_')
4539 buf = xmalloc (strlen (clean) + sizeof "__load_start_");
4540 sprintf (buf, "__load_start_%s", clean);
4541 lang_add_assignment (exp_assop ('=', buf,
4542 exp_nameop (LOADADDR, name)));
4544 buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
4545 sprintf (buf, "__load_stop_%s", clean);
4546 lang_add_assignment (exp_assop ('=', buf,
4548 exp_nameop (LOADADDR, name),
4549 exp_nameop (SIZEOF, name))));
4554 /* Finish an overlay. If there are any overlay wide settings, this
4555 looks through all the sections in the overlay and sets them. */
4558 lang_leave_overlay (fill, memspec, phdrs)
4560 const char *memspec;
4561 struct lang_output_section_phdr_list *phdrs;
4563 lang_memory_region_type *region;
4564 struct overlay_list *l;
4565 struct lang_nocrossref *nocrossref;
4567 if (memspec == NULL)
4570 region = lang_memory_region_lookup (memspec);
4577 struct overlay_list *next;
4579 if (fill != 0 && l->os->fill == 0)
4581 if (region != NULL && l->os->region == NULL)
4582 l->os->region = region;
4583 if (phdrs != NULL && l->os->phdrs == NULL)
4584 l->os->phdrs = phdrs;
4586 if (overlay_nocrossrefs)
4588 struct lang_nocrossref *nc;
4590 nc = (struct lang_nocrossref *) xmalloc (sizeof *nc);
4591 nc->name = l->os->name;
4592 nc->next = nocrossref;
4601 if (nocrossref != NULL)
4602 lang_add_nocrossref (nocrossref);
4604 /* Update . for the end of the overlay. */
4605 lang_add_assignment (exp_assop ('=', ".",
4606 exp_binop ('+', overlay_vma, overlay_max)));
4610 overlay_nocrossrefs = 0;
4611 overlay_list = NULL;
4615 /* Version handling. This is only useful for ELF. */
4617 /* This global variable holds the version tree that we build. */
4619 struct bfd_elf_version_tree *lang_elf_version_info;
4622 lang_vers_match_lang_c (expr, sym)
4623 struct bfd_elf_version_expr *expr;
4626 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4628 return fnmatch (expr->pattern, sym, 0) == 0;
4632 lang_vers_match_lang_cplusplus (expr, sym)
4633 struct bfd_elf_version_expr *expr;
4639 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4642 alt_sym = cplus_demangle(sym, /* DMGL_NO_TPARAMS */ 0);
4645 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
4646 Should we early out false in this case? */
4647 result = fnmatch (expr->pattern, sym, 0) == 0;
4651 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
4659 lang_vers_match_lang_java (expr, sym)
4660 struct bfd_elf_version_expr *expr;
4666 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4669 alt_sym = cplus_demangle(sym, DMGL_JAVA);
4672 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
4673 Should we early out false in this case? */
4674 result = fnmatch (expr->pattern, sym, 0) == 0;
4678 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
4685 /* This is called for each variable name or match expression. */
4687 struct bfd_elf_version_expr *
4688 lang_new_vers_regex (orig, new, lang)
4689 struct bfd_elf_version_expr *orig;
4693 struct bfd_elf_version_expr *ret;
4695 ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret);
4699 if (lang == NULL || strcasecmp (lang, "C") == 0)
4700 ret->match = lang_vers_match_lang_c;
4701 else if (strcasecmp (lang, "C++") == 0)
4702 ret->match = lang_vers_match_lang_cplusplus;
4703 else if (strcasecmp (lang, "Java") == 0)
4704 ret->match = lang_vers_match_lang_java;
4707 einfo (_("%X%P: unknown language `%s' in version information\n"),
4709 ret->match = lang_vers_match_lang_c;
4715 /* This is called for each set of variable names and match
4718 struct bfd_elf_version_tree *
4719 lang_new_vers_node (globals, locals)
4720 struct bfd_elf_version_expr *globals;
4721 struct bfd_elf_version_expr *locals;
4723 struct bfd_elf_version_tree *ret;
4725 ret = (struct bfd_elf_version_tree *) xmalloc (sizeof *ret);
4729 ret->globals = globals;
4730 ret->locals = locals;
4732 ret->name_indx = (unsigned int) -1;
4737 /* This static variable keeps track of version indices. */
4739 static int version_index;
4741 /* This is called when we know the name and dependencies of the
4745 lang_register_vers_node (name, version, deps)
4747 struct bfd_elf_version_tree *version;
4748 struct bfd_elf_version_deps *deps;
4750 struct bfd_elf_version_tree *t, **pp;
4751 struct bfd_elf_version_expr *e1;
4753 /* Make sure this node has a unique name. */
4754 for (t = lang_elf_version_info; t != NULL; t = t->next)
4755 if (strcmp (t->name, name) == 0)
4756 einfo (_("%X%P: duplicate version tag `%s'\n"), name);
4758 /* Check the global and local match names, and make sure there
4759 aren't any duplicates. */
4761 for (e1 = version->globals; e1 != NULL; e1 = e1->next)
4763 for (t = lang_elf_version_info; t != NULL; t = t->next)
4765 struct bfd_elf_version_expr *e2;
4767 for (e2 = t->locals; e2 != NULL; e2 = e2->next)
4768 if (strcmp (e1->pattern, e2->pattern) == 0)
4769 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
4774 for (e1 = version->locals; e1 != NULL; e1 = e1->next)
4776 for (t = lang_elf_version_info; t != NULL; t = t->next)
4778 struct bfd_elf_version_expr *e2;
4780 for (e2 = t->globals; e2 != NULL; e2 = e2->next)
4781 if (strcmp (e1->pattern, e2->pattern) == 0)
4782 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
4787 version->deps = deps;
4788 version->name = name;
4790 version->vernum = version_index;
4792 for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
4797 /* This is called when we see a version dependency. */
4799 struct bfd_elf_version_deps *
4800 lang_add_vers_depend (list, name)
4801 struct bfd_elf_version_deps *list;
4804 struct bfd_elf_version_deps *ret;
4805 struct bfd_elf_version_tree *t;
4807 ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret);
4810 for (t = lang_elf_version_info; t != NULL; t = t->next)
4812 if (strcmp (t->name, name) == 0)
4814 ret->version_needed = t;
4819 einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
4825 lang_do_version_exports_section ()
4827 struct bfd_elf_version_expr *greg = NULL, *lreg;
4829 LANG_FOR_EACH_INPUT_STATEMENT (is)
4831 asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
4838 len = bfd_section_size (is->the_bfd, sec);
4839 contents = xmalloc (len);
4840 if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
4841 einfo (_("%X%P: unable to read .exports section contents"), sec);
4844 while (p < contents+len)
4846 greg = lang_new_vers_regex (greg, p, NULL);
4847 p = strchr (p, '\0') + 1;
4850 /* Do not free the contents, as we used them creating the regex. */
4852 /* Do not include this section in the link. */
4853 bfd_set_section_flags (is->the_bfd, sec,
4854 bfd_get_section_flags (is->the_bfd, sec) | SEC_EXCLUDE);
4857 lreg = lang_new_vers_regex (NULL, "*", NULL);
4858 lang_register_vers_node (command_line.version_exports_section,
4859 lang_new_vers_node (greg, lreg), NULL);