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. This code assumes that all relevant sections have the
866 SEC_LINK_ONCE flag set; that is, it does not depend solely upon the
867 section name. This is called via bfd_map_over_sections. */
871 section_already_linked (abfd, sec, data)
876 lang_input_statement_type *entry = (lang_input_statement_type *) data;
879 struct sec_link_once *next;
882 static struct sec_link_once *sec_link_once_list;
885 struct sec_link_once *l;
887 /* If we are only reading symbols from this object, then we want to
888 discard all sections. */
889 if (entry->just_syms_flag)
891 sec->output_section = bfd_abs_section_ptr;
892 sec->output_offset = sec->vma;
896 flags = bfd_get_section_flags (abfd, sec);
898 if ((flags & SEC_LINK_ONCE) == 0)
901 /* FIXME: When doing a relocateable link, we may have trouble
902 copying relocations in other sections that refer to local symbols
903 in the section being discarded. Those relocations will have to
904 be converted somehow; as of this writing I'm not sure that any of
905 the backends handle that correctly.
907 It is tempting to instead not discard link once sections when
908 doing a relocateable link (technically, they should be discarded
909 whenever we are building constructors). However, that fails,
910 because the linker winds up combining all the link once sections
911 into a single large link once section, which defeats the purpose
912 of having link once sections in the first place.
914 Also, not merging link once sections in a relocateable link
915 causes trouble for MIPS ELF, which relies in link once semantics
916 to handle the .reginfo section correctly. */
918 name = bfd_get_section_name (abfd, sec);
920 for (l = sec_link_once_list; l != NULL; l = l->next)
922 if (strcmp (name, bfd_get_section_name (l->sec->owner, l->sec)) == 0)
924 /* The section has already been linked. See if we should
926 switch (flags & SEC_LINK_DUPLICATES)
931 case SEC_LINK_DUPLICATES_DISCARD:
934 case SEC_LINK_DUPLICATES_ONE_ONLY:
935 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
939 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
940 /* FIXME: We should really dig out the contents of both
941 sections and memcmp them. The COFF/PE spec says that
942 the Microsoft linker does not implement this
943 correctly, so I'm not going to bother doing it
946 case SEC_LINK_DUPLICATES_SAME_SIZE:
947 if (bfd_section_size (abfd, sec)
948 != bfd_section_size (l->sec->owner, l->sec))
949 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
954 /* Set the output_section field so that wild_doit does not
955 create a lang_input_section structure for this section. */
956 sec->output_section = bfd_abs_section_ptr;
962 /* This is the first section with this name. Record it. */
964 l = (struct sec_link_once *) xmalloc (sizeof *l);
966 l->next = sec_link_once_list;
967 sec_link_once_list = l;
970 /* The wild routines.
972 These expand statements like *(.text) and foo.o to a list of
973 explicit actions, like foo.o(.text), bar.o(.text) and
974 foo.o(.text, .data). */
976 /* Return true if the PATTERN argument is a wildcard pattern.
977 Although backslashes are treated specially if a pattern contains
978 wildcards, we do not consider the mere presence of a backslash to
979 be enough to cause the the pattern to be treated as a wildcard.
980 That lets us handle DOS filenames more naturally. */
988 for (s = pattern; *s != '\0'; ++s)
996 /* Add SECTION to the output section OUTPUT. Do this by creating a
997 lang_input_section statement which is placed at PTR. FILE is the
998 input file which holds SECTION. */
1001 wild_doit (ptr, section, output, file)
1002 lang_statement_list_type *ptr;
1004 lang_output_section_statement_type *output;
1005 lang_input_statement_type *file;
1010 flags = bfd_get_section_flags (section->owner, section);
1014 /* If we are doing a final link, discard sections marked with
1016 if (! link_info.relocateable
1017 && (flags & SEC_EXCLUDE) != 0)
1020 /* Discard input sections which are assigned to a section named
1021 DISCARD_SECTION_NAME. */
1022 if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
1025 /* Discard debugging sections if we are stripping debugging
1027 if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
1028 && (flags & SEC_DEBUGGING) != 0)
1033 if (section->output_section == NULL)
1035 /* This prevents future calls from assigning this section. */
1036 section->output_section = bfd_abs_section_ptr;
1041 if (section->output_section == NULL)
1044 lang_input_section_type *new;
1047 if (output->bfd_section == NULL)
1055 /* Add a section reference to the list */
1056 new = new_stat (lang_input_section, ptr);
1058 new->section = section;
1060 section->output_section = output->bfd_section;
1062 flags = section->flags;
1064 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1065 to an output section, because we want to be able to include a
1066 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1067 section (I don't know why we want to do this, but we do).
1068 build_link_order in ldwrite.c handles this case by turning
1069 the embedded SEC_NEVER_LOAD section into a fill. */
1071 flags &= ~ SEC_NEVER_LOAD;
1073 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1074 already been processed. One reason to do this is that on pe
1075 format targets, .text$foo sections go into .text and it's odd
1076 to see .text with SEC_LINK_ONCE set. */
1078 if (! link_info.relocateable)
1079 flags &= ~ (SEC_LINK_ONCE | SEC_LINK_DUPLICATES);
1081 /* If this is not the first input section, and the SEC_READONLY
1082 flag is not currently set, then don't set it just because the
1083 input section has it set. */
1085 if (! first && (section->output_section->flags & SEC_READONLY) == 0)
1086 flags &= ~ SEC_READONLY;
1088 section->output_section->flags |= flags;
1090 /* If SEC_READONLY is not set in the input section, then clear
1091 it from the output section. */
1092 if ((section->flags & SEC_READONLY) == 0)
1093 section->output_section->flags &= ~SEC_READONLY;
1095 switch (output->sectype)
1097 case normal_section:
1102 case overlay_section:
1103 output->bfd_section->flags &= ~SEC_ALLOC;
1105 case noload_section:
1106 output->bfd_section->flags &= ~SEC_LOAD;
1107 output->bfd_section->flags |= SEC_NEVER_LOAD;
1111 /* Copy over SEC_SHORT. */
1112 if (section->flags & SEC_SHORT)
1113 section->output_section->flags |= SEC_SHORT;
1115 if (section->alignment_power > output->bfd_section->alignment_power)
1116 output->bfd_section->alignment_power = section->alignment_power;
1118 /* If supplied an aligment, then force it. */
1119 if (output->section_alignment != -1)
1120 output->bfd_section->alignment_power = output->section_alignment;
1124 /* Handle wildcard sorting. This returns the lang_input_section which
1125 should follow the one we are going to create for SECTION and FILE,
1126 based on the sorting requirements of WILD. It returns NULL if the
1127 new section should just go at the end of the current list. */
1129 static lang_statement_union_type *
1130 wild_sort (wild, file, section)
1131 lang_wild_statement_type *wild;
1132 lang_input_statement_type *file;
1135 const char *section_name;
1136 lang_statement_union_type *l;
1138 if (! wild->filenames_sorted && ! wild->sections_sorted)
1141 section_name = bfd_get_section_name (file->the_bfd, section);
1142 for (l = wild->children.head; l != NULL; l = l->next)
1144 lang_input_section_type *ls;
1146 if (l->header.type != lang_input_section_enum)
1148 ls = &l->input_section;
1150 /* Sorting by filename takes precedence over sorting by section
1153 if (wild->filenames_sorted)
1155 const char *fn, *ln;
1159 /* The PE support for the .idata section as generated by
1160 dlltool assumes that files will be sorted by the name of
1161 the archive and then the name of the file within the
1164 if (file->the_bfd != NULL
1165 && bfd_my_archive (file->the_bfd) != NULL)
1167 fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
1172 fn = file->filename;
1176 if (ls->ifile->the_bfd != NULL
1177 && bfd_my_archive (ls->ifile->the_bfd) != NULL)
1179 ln = bfd_get_filename (bfd_my_archive (ls->ifile->the_bfd));
1184 ln = ls->ifile->filename;
1188 i = strcmp (fn, ln);
1197 fn = file->filename;
1199 ln = ls->ifile->filename;
1201 i = strcmp (fn, ln);
1209 /* Here either the files are not sorted by name, or we are
1210 looking at the sections for this file. */
1212 if (wild->sections_sorted)
1214 if (strcmp (section_name,
1215 bfd_get_section_name (ls->ifile->the_bfd,
1225 /* Expand a wild statement for a particular FILE. SECTION may be
1226 NULL, in which case it is a wild card. */
1229 output_section_callback (ptr, section, file, output)
1230 lang_wild_statement_type *ptr;
1232 lang_input_statement_type *file;
1235 lang_statement_union_type *before;
1237 /* If the wild pattern was marked KEEP, the member sections
1238 should be as well. */
1239 if (ptr->keep_sections)
1240 section->flags |= SEC_KEEP;
1242 before = wild_sort (ptr, file, section);
1244 /* Here BEFORE points to the lang_input_section which
1245 should follow the one we are about to add. If BEFORE
1246 is NULL, then the section should just go at the end
1247 of the current list. */
1250 wild_doit (&ptr->children, section,
1251 (lang_output_section_statement_type *) output,
1255 lang_statement_list_type list;
1256 lang_statement_union_type **pp;
1258 lang_list_init (&list);
1259 wild_doit (&list, section,
1260 (lang_output_section_statement_type *) output,
1263 /* If we are discarding the section, LIST.HEAD will
1265 if (list.head != NULL)
1267 ASSERT (list.head->next == NULL);
1269 for (pp = &ptr->children.head;
1272 ASSERT (*pp != NULL);
1274 list.head->next = *pp;
1280 /* This is passed a file name which must have been seen already and
1281 added to the statement tree. We will see if it has been opened
1282 already and had its symbols read. If not then we'll read it. */
1284 static lang_input_statement_type *
1288 lang_input_statement_type *search;
1290 for (search = (lang_input_statement_type *) input_file_chain.head;
1291 search != (lang_input_statement_type *) NULL;
1292 search = (lang_input_statement_type *) search->next_real_file)
1294 if (search->filename == (char *) NULL && name == (char *) NULL)
1296 if (search->filename != (char *) NULL
1297 && name != (char *) NULL
1298 && strcmp (search->filename, name) == 0)
1302 if (search == (lang_input_statement_type *) NULL)
1303 search = new_afile (name, lang_input_file_is_file_enum, default_target,
1306 /* If we have already added this file, or this file is not real
1307 (FIXME: can that ever actually happen?) or the name is NULL
1308 (FIXME: can that ever actually happen?) don't add this file. */
1311 || search->filename == (const char *) NULL)
1314 load_symbols (search, (lang_statement_list_type *) NULL);
1319 /* Get the symbols for an input file. */
1322 load_symbols (entry, place)
1323 lang_input_statement_type *entry;
1324 lang_statement_list_type *place;
1331 ldfile_open_file (entry);
1333 if (! bfd_check_format (entry->the_bfd, bfd_archive)
1334 && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
1337 lang_statement_list_type *hold;
1339 err = bfd_get_error ();
1340 if (err == bfd_error_file_ambiguously_recognized)
1344 einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
1345 einfo (_("%B: matching formats:"), entry->the_bfd);
1346 for (p = matching; *p != NULL; p++)
1350 else if (err != bfd_error_file_not_recognized
1352 einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
1354 bfd_close (entry->the_bfd);
1355 entry->the_bfd = NULL;
1357 /* See if the emulation has some special knowledge. */
1359 if (ldemul_unrecognized_file (entry))
1362 /* Try to interpret the file as a linker script. */
1364 ldfile_open_command_file (entry->filename);
1369 ldfile_assumed_script = true;
1370 parser_input = input_script;
1372 ldfile_assumed_script = false;
1379 if (ldemul_recognized_file (entry))
1382 /* We don't call ldlang_add_file for an archive. Instead, the
1383 add_symbols entry point will call ldlang_add_file, via the
1384 add_archive_element callback, for each element of the archive
1386 switch (bfd_get_format (entry->the_bfd))
1392 ldlang_add_file (entry);
1393 if (trace_files || trace_file_tries)
1394 info_msg ("%I\n", entry);
1398 if (entry->whole_archive)
1400 bfd *member = bfd_openr_next_archived_file (entry->the_bfd,
1402 while (member != NULL)
1404 if (! bfd_check_format (member, bfd_object))
1405 einfo (_("%F%B: object %B in archive is not object\n"),
1406 entry->the_bfd, member);
1407 if (! ((*link_info.callbacks->add_archive_element)
1408 (&link_info, member, "--whole-archive")))
1410 if (! bfd_link_add_symbols (member, &link_info))
1411 einfo (_("%F%B: could not read symbols: %E\n"), member);
1412 member = bfd_openr_next_archived_file (entry->the_bfd,
1416 entry->loaded = true;
1422 if (! bfd_link_add_symbols (entry->the_bfd, &link_info))
1423 einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
1425 entry->loaded = true;
1430 /* Handle a wild statement. SECTION or FILE or both may be NULL,
1431 indicating that it is a wildcard. Separate lang_input_section
1432 statements are created for each part of the expansion; they are
1433 added after the wild statement S. OUTPUT is the output section. */
1436 wild (s, section, file, target, output)
1437 lang_wild_statement_type *s;
1438 const char *section;
1440 const char *target ATTRIBUTE_UNUSED;
1441 lang_output_section_statement_type *output;
1443 walk_wild (s, section, file, output_section_callback, (void *) output);
1445 if (section != (char *) NULL
1446 && strcmp (section, "COMMON") == 0
1447 && default_common_section == NULL)
1449 /* Remember the section that common is going to in case we later
1450 get something which doesn't know where to put it. */
1451 default_common_section = output;
1455 /* Return true iff target is the sought target. */
1457 get_target (target, data)
1458 const bfd_target * target;
1461 const char * sought = (const char *) data;
1463 return strcmp (target->name, sought) == 0;
1466 /* Like strcpy() but convert to lower case as well. */
1474 while ((c = * src ++) != 0)
1476 if (isupper ((unsigned char) c))
1485 /* Remove the first occurance of needle (if any) in haystack
1488 strcut (haystack, needle)
1492 haystack = strstr (haystack, needle);
1498 for (src = haystack + strlen (needle); * src;)
1499 * haystack ++ = * src ++;
1505 /* Compare two target format name strings.
1506 Return a value indicating how "similar" they are. */
1508 name_compare (first, second)
1516 copy1 = xmalloc (strlen (first) + 1);
1517 copy2 = xmalloc (strlen (second) + 1);
1519 /* Convert the names to lower case. */
1520 stricpy (copy1, first);
1521 stricpy (copy2, second);
1523 /* Remove and endian strings from the name. */
1524 strcut (copy1, "big");
1525 strcut (copy1, "little");
1526 strcut (copy2, "big");
1527 strcut (copy2, "little");
1529 /* Return a value based on how many characters match,
1530 starting from the beginning. If both strings are
1531 the same then return 10 * their length. */
1532 for (result = 0; copy1 [result] == copy2 [result]; result ++)
1533 if (copy1 [result] == 0)
1545 /* Set by closest_target_match() below. */
1546 static const bfd_target * winner;
1548 /* Scan all the valid bfd targets looking for one that has the endianness
1549 requirement that was specified on the command line, and is the nearest
1550 match to the original output target. */
1552 closest_target_match (target, data)
1553 const bfd_target * target;
1556 const bfd_target * original = (const bfd_target *) data;
1558 if (command_line.endian == ENDIAN_BIG && target->byteorder != BFD_ENDIAN_BIG)
1561 if (command_line.endian == ENDIAN_LITTLE && target->byteorder != BFD_ENDIAN_LITTLE)
1564 /* Must be the same flavour. */
1565 if (target->flavour != original->flavour)
1568 /* If we have not found a potential winner yet, then record this one. */
1575 /* Oh dear, we now have two potential candidates for a successful match.
1576 Compare their names and choose the better one. */
1577 if (name_compare (target->name, original->name) > name_compare (winner->name, original->name))
1580 /* Keep on searching until wqe have checked them all. */
1584 /* Return the BFD target format of the first input file. */
1586 get_first_input_target ()
1588 char * target = NULL;
1590 LANG_FOR_EACH_INPUT_STATEMENT (s)
1592 if (s->header.type == lang_input_statement_enum
1595 ldfile_open_file (s);
1597 if (s->the_bfd != NULL
1598 && bfd_check_format (s->the_bfd, bfd_object))
1600 target = bfd_get_target (s->the_bfd);
1611 /* Open the output file. */
1619 /* Has the user told us which output format to use ? */
1620 if (output_target == (char *) NULL)
1622 /* No - has the current target been set to something other than the default ? */
1623 if (current_target != default_target)
1624 output_target = current_target;
1626 /* No - can we determine the format of the first input file ? */
1629 output_target = get_first_input_target ();
1631 /* Failed - use the default output target. */
1632 if (output_target == NULL)
1633 output_target = default_target;
1637 /* Has the user requested a particular endianness on the command line ? */
1638 if (command_line.endian != ENDIAN_UNSET)
1640 const bfd_target * target;
1643 /* Get the chosen target. */
1644 target = bfd_search_for_target (get_target, (void *) output_target);
1646 if (command_line.endian == ENDIAN_BIG)
1647 desired_endian = BFD_ENDIAN_BIG;
1649 desired_endian = BFD_ENDIAN_LITTLE;
1651 /* See if the target has the wrong endianness. This should not happen
1652 if the linker script has provided big and little endian alternatives,
1653 but some scrips don't do this. */
1654 if (target->byteorder != desired_endian)
1656 /* If it does, then see if the target provides
1657 an alternative with the correct endianness. */
1658 if (target->alternative_target != NULL
1659 && (target->alternative_target->byteorder == desired_endian))
1660 output_target = target->alternative_target->name;
1663 /* Try to find a target as similar as possible to the default
1664 target, but which has the desired endian characteristic. */
1665 (void) bfd_search_for_target (closest_target_match, (void *) target);
1667 /* Oh dear - we could not find any targets that satisfy our requirements. */
1669 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1671 output_target = winner->name;
1676 output = bfd_openw (name, output_target);
1678 if (output == (bfd *) NULL)
1680 if (bfd_get_error () == bfd_error_invalid_target)
1681 einfo (_("%P%F: target %s not found\n"), output_target);
1683 einfo (_("%P%F: cannot open output file %s: %E\n"), name);
1686 delete_output_file_on_failure = true;
1688 /* output->flags |= D_PAGED;*/
1690 if (! bfd_set_format (output, bfd_object))
1691 einfo (_("%P%F:%s: can not make object file: %E\n"), name);
1692 if (! bfd_set_arch_mach (output,
1693 ldfile_output_architecture,
1694 ldfile_output_machine))
1695 einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
1697 link_info.hash = bfd_link_hash_table_create (output);
1698 if (link_info.hash == (struct bfd_link_hash_table *) NULL)
1699 einfo (_("%P%F: can not create link hash table: %E\n"));
1701 bfd_set_gp_size (output, g_switch_value);
1706 ldlang_open_output (statement)
1707 lang_statement_union_type * statement;
1709 switch (statement->header.type)
1711 case lang_output_statement_enum:
1712 ASSERT (output_bfd == (bfd *) NULL);
1713 output_bfd = open_output (statement->output_statement.name);
1714 ldemul_set_output_arch ();
1715 if (config.magic_demand_paged && !link_info.relocateable)
1716 output_bfd->flags |= D_PAGED;
1718 output_bfd->flags &= ~D_PAGED;
1719 if (config.text_read_only)
1720 output_bfd->flags |= WP_TEXT;
1722 output_bfd->flags &= ~WP_TEXT;
1723 if (link_info.traditional_format)
1724 output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
1726 output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
1729 case lang_target_statement_enum:
1730 current_target = statement->target_statement.target;
1737 /* Open all the input files. */
1740 open_input_bfds (s, force)
1741 lang_statement_union_type *s;
1744 for (; s != (lang_statement_union_type *) NULL; s = s->next)
1746 switch (s->header.type)
1748 case lang_constructors_statement_enum:
1749 open_input_bfds (constructor_list.head, force);
1751 case lang_output_section_statement_enum:
1752 open_input_bfds (s->output_section_statement.children.head, force);
1754 case lang_wild_statement_enum:
1755 /* Maybe we should load the file's symbols */
1756 if (s->wild_statement.filename
1757 && ! wildcardp (s->wild_statement.filename))
1758 (void) lookup_name (s->wild_statement.filename);
1759 open_input_bfds (s->wild_statement.children.head, force);
1761 case lang_group_statement_enum:
1763 struct bfd_link_hash_entry *undefs;
1765 /* We must continually search the entries in the group
1766 until no new symbols are added to the list of undefined
1771 undefs = link_info.hash->undefs_tail;
1772 open_input_bfds (s->group_statement.children.head, true);
1774 while (undefs != link_info.hash->undefs_tail);
1777 case lang_target_statement_enum:
1778 current_target = s->target_statement.target;
1780 case lang_input_statement_enum:
1781 if (s->input_statement.real)
1783 lang_statement_list_type add;
1785 s->input_statement.target = current_target;
1787 /* If we are being called from within a group, and this
1788 is an archive which has already been searched, then
1789 force it to be researched. */
1791 && s->input_statement.loaded
1792 && bfd_check_format (s->input_statement.the_bfd,
1794 s->input_statement.loaded = false;
1796 lang_list_init (&add);
1798 load_symbols (&s->input_statement, &add);
1800 if (add.head != NULL)
1802 *add.tail = s->next;
1813 /* If there are [COMMONS] statements, put a wild one into the bss section */
1816 lang_reasonable_defaults ()
1819 lang_output_section_statement_lookup (".text");
1820 lang_output_section_statement_lookup (".data");
1822 default_common_section =
1823 lang_output_section_statement_lookup (".bss");
1826 if (placed_commons == false)
1828 lang_wild_statement_type *new =
1829 new_stat (lang_wild_statement,
1830 &default_common_section->children);
1832 new->section_name = "COMMON";
1833 new->filename = (char *) NULL;
1834 lang_list_init (&new->children);
1841 Add the supplied name to the symbol table as an undefined reference.
1842 Remove items from the chain as we open input bfds
1844 typedef struct ldlang_undef_chain_list
1846 struct ldlang_undef_chain_list *next;
1848 } ldlang_undef_chain_list_type;
1850 static ldlang_undef_chain_list_type *ldlang_undef_chain_list_head;
1853 ldlang_add_undef (name)
1854 CONST char *CONST name;
1856 ldlang_undef_chain_list_type *new =
1857 ((ldlang_undef_chain_list_type *)
1858 stat_alloc (sizeof (ldlang_undef_chain_list_type)));
1860 new->next = ldlang_undef_chain_list_head;
1861 ldlang_undef_chain_list_head = new;
1863 new->name = buystring (name);
1866 /* Run through the list of undefineds created above and place them
1867 into the linker hash table as undefined symbols belonging to the
1871 lang_place_undefineds ()
1873 ldlang_undef_chain_list_type *ptr;
1875 for (ptr = ldlang_undef_chain_list_head;
1876 ptr != (ldlang_undef_chain_list_type *) NULL;
1879 struct bfd_link_hash_entry *h;
1881 h = bfd_link_hash_lookup (link_info.hash, ptr->name, true, false, true);
1882 if (h == (struct bfd_link_hash_entry *) NULL)
1883 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1884 if (h->type == bfd_link_hash_new)
1886 h->type = bfd_link_hash_undefined;
1887 h->u.undef.abfd = NULL;
1888 bfd_link_add_undef (link_info.hash, h);
1893 /* Open input files and attatch to output sections */
1895 map_input_to_output_sections (s, target, output_section_statement)
1896 lang_statement_union_type * s;
1898 lang_output_section_statement_type * output_section_statement;
1900 for (; s != (lang_statement_union_type *) NULL; s = s->next)
1902 switch (s->header.type)
1906 case lang_wild_statement_enum:
1907 wild (&s->wild_statement, s->wild_statement.section_name,
1908 s->wild_statement.filename, target,
1909 output_section_statement);
1912 case lang_constructors_statement_enum:
1913 map_input_to_output_sections (constructor_list.head,
1915 output_section_statement);
1917 case lang_output_section_statement_enum:
1918 map_input_to_output_sections (s->output_section_statement.children.head,
1920 &s->output_section_statement);
1922 case lang_output_statement_enum:
1924 case lang_target_statement_enum:
1925 target = s->target_statement.target;
1927 case lang_group_statement_enum:
1928 map_input_to_output_sections (s->group_statement.children.head,
1930 output_section_statement);
1932 case lang_fill_statement_enum:
1933 case lang_input_section_enum:
1934 case lang_object_symbols_statement_enum:
1935 case lang_data_statement_enum:
1936 case lang_reloc_statement_enum:
1937 case lang_padding_statement_enum:
1938 case lang_input_statement_enum:
1939 if (output_section_statement != NULL
1940 && output_section_statement->bfd_section == NULL)
1941 init_os (output_section_statement);
1943 case lang_assignment_statement_enum:
1944 if (output_section_statement != NULL
1945 && output_section_statement->bfd_section == NULL)
1946 init_os (output_section_statement);
1948 /* Make sure that any sections mentioned in the assignment
1950 exp_init_os (s->assignment_statement.exp);
1952 case lang_afile_asection_pair_statement_enum:
1955 case lang_address_statement_enum:
1956 /* Mark the specified section with the supplied address */
1958 lang_output_section_statement_type *os =
1959 lang_output_section_statement_lookup
1960 (s->address_statement.section_name);
1962 if (os->bfd_section == NULL)
1964 os->addr_tree = s->address_statement.address;
1972 print_output_section_statement (output_section_statement)
1973 lang_output_section_statement_type * output_section_statement;
1975 asection *section = output_section_statement->bfd_section;
1978 if (output_section_statement != abs_output_section)
1980 minfo ("\n%s", output_section_statement->name);
1982 if (section != NULL)
1984 print_dot = section->vma;
1986 len = strlen (output_section_statement->name);
1987 if (len >= SECTION_NAME_MAP_LENGTH - 1)
1992 while (len < SECTION_NAME_MAP_LENGTH)
1998 minfo ("0x%V %W", section->vma, section->_raw_size);
2000 if (output_section_statement->load_base != NULL)
2004 addr = exp_get_abs_int (output_section_statement->load_base, 0,
2005 "load base", lang_final_phase_enum);
2006 minfo (_(" load address 0x%V"), addr);
2013 print_statement_list (output_section_statement->children.head,
2014 output_section_statement);
2018 print_assignment (assignment, output_section)
2019 lang_assignment_statement_type * assignment;
2020 lang_output_section_statement_type * output_section;
2023 etree_value_type result;
2025 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2028 result = exp_fold_tree (assignment->exp->assign.src, output_section,
2029 lang_final_phase_enum, print_dot, &print_dot);
2031 minfo ("0x%V", result.value + result.section->bfd_section->vma);
2042 exp_print_tree (assignment->exp);
2048 print_input_statement (statm)
2049 lang_input_statement_type * statm;
2051 if (statm->filename != (char *) NULL)
2053 fprintf (config.map_file, "LOAD %s\n", statm->filename);
2057 /* Print all symbols defined in a particular section. This is called
2058 via bfd_link_hash_traverse. */
2061 print_one_symbol (hash_entry, ptr)
2062 struct bfd_link_hash_entry *hash_entry;
2065 asection *sec = (asection *) ptr;
2067 if ((hash_entry->type == bfd_link_hash_defined
2068 || hash_entry->type == bfd_link_hash_defweak)
2069 && sec == hash_entry->u.def.section)
2073 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2076 (hash_entry->u.def.value
2077 + hash_entry->u.def.section->output_offset
2078 + hash_entry->u.def.section->output_section->vma));
2080 minfo (" %T\n", hash_entry->root.string);
2086 /* Print information about an input section to the map file. */
2089 print_input_section (in)
2090 lang_input_section_type * in;
2092 asection *i = in->section;
2093 bfd_size_type size = i->_cooked_size != 0 ? i->_cooked_size : i->_raw_size;
2099 minfo ("%s", i->name);
2101 if (i->output_section != NULL)
2105 len = 1 + strlen (i->name);
2106 if (len >= SECTION_NAME_MAP_LENGTH - 1)
2111 while (len < SECTION_NAME_MAP_LENGTH)
2117 minfo ("0x%V %W %B\n",
2118 i->output_section->vma + i->output_offset, size,
2121 if (i->_cooked_size != 0 && i->_cooked_size != i->_raw_size)
2123 len = SECTION_NAME_MAP_LENGTH + 3;
2135 minfo (_("%W (size before relaxing)\n"), i->_raw_size);
2138 bfd_link_hash_traverse (link_info.hash, print_one_symbol, (PTR) i);
2140 print_dot = i->output_section->vma + i->output_offset + size;
2146 print_fill_statement (fill)
2147 lang_fill_statement_type * fill;
2149 fprintf (config.map_file, " FILL mask 0x%x\n", fill->fill);
2153 print_data_statement (data)
2154 lang_data_statement_type * data;
2161 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2164 addr = data->output_vma;
2165 if (data->output_section != NULL)
2166 addr += data->output_section->vma;
2194 minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
2196 if (data->exp->type.node_class != etree_value)
2199 exp_print_tree (data->exp);
2204 print_dot = addr + size;
2207 /* Print an address statement. These are generated by options like
2211 print_address_statement (address)
2212 lang_address_statement_type *address;
2214 minfo (_("Address of section %s set to "), address->section_name);
2215 exp_print_tree (address->address);
2219 /* Print a reloc statement. */
2222 print_reloc_statement (reloc)
2223 lang_reloc_statement_type *reloc;
2229 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2232 addr = reloc->output_vma;
2233 if (reloc->output_section != NULL)
2234 addr += reloc->output_section->vma;
2236 size = bfd_get_reloc_size (reloc->howto);
2238 minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
2240 if (reloc->name != NULL)
2241 minfo ("%s+", reloc->name);
2243 minfo ("%s+", reloc->section->name);
2245 exp_print_tree (reloc->addend_exp);
2249 print_dot = addr + size;
2253 print_padding_statement (s)
2254 lang_padding_statement_type *s;
2261 len = sizeof " *fill*" - 1;
2262 while (len < SECTION_NAME_MAP_LENGTH)
2268 addr = s->output_offset;
2269 if (s->output_section != NULL)
2270 addr += s->output_section->vma;
2271 minfo ("0x%V %W", addr, s->size);
2274 minfo (" %u", s->fill);
2278 print_dot = addr + s->size;
2282 print_wild_statement (w, os)
2283 lang_wild_statement_type * w;
2284 lang_output_section_statement_type * os;
2288 if (w->filenames_sorted)
2290 if (w->exclude_filename != NULL)
2291 minfo ("EXCLUDE_FILE ( %s )", w->exclude_filename);
2292 if (w->filename != NULL)
2293 minfo ("%s", w->filename);
2296 if (w->filenames_sorted)
2300 if (w->sections_sorted)
2302 if (w->section_name != NULL)
2303 minfo ("%s", w->section_name);
2306 if (w->sections_sorted)
2312 print_statement_list (w->children.head, os);
2315 /* Print a group statement. */
2319 lang_group_statement_type *s;
2320 lang_output_section_statement_type *os;
2322 fprintf (config.map_file, "START GROUP\n");
2323 print_statement_list (s->children.head, os);
2324 fprintf (config.map_file, "END GROUP\n");
2327 /* Print the list of statements in S.
2328 This can be called for any statement type. */
2331 print_statement_list (s, os)
2332 lang_statement_union_type *s;
2333 lang_output_section_statement_type *os;
2337 print_statement (s, os);
2342 /* Print the first statement in statement list S.
2343 This can be called for any statement type. */
2346 print_statement (s, os)
2347 lang_statement_union_type *s;
2348 lang_output_section_statement_type *os;
2350 switch (s->header.type)
2353 fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
2356 case lang_constructors_statement_enum:
2357 if (constructor_list.head != NULL)
2359 if (constructors_sorted)
2360 minfo (" SORT (CONSTRUCTORS)\n");
2362 minfo (" CONSTRUCTORS\n");
2363 print_statement_list (constructor_list.head, os);
2366 case lang_wild_statement_enum:
2367 print_wild_statement (&s->wild_statement, os);
2369 case lang_address_statement_enum:
2370 print_address_statement (&s->address_statement);
2372 case lang_object_symbols_statement_enum:
2373 minfo (" CREATE_OBJECT_SYMBOLS\n");
2375 case lang_fill_statement_enum:
2376 print_fill_statement (&s->fill_statement);
2378 case lang_data_statement_enum:
2379 print_data_statement (&s->data_statement);
2381 case lang_reloc_statement_enum:
2382 print_reloc_statement (&s->reloc_statement);
2384 case lang_input_section_enum:
2385 print_input_section (&s->input_section);
2387 case lang_padding_statement_enum:
2388 print_padding_statement (&s->padding_statement);
2390 case lang_output_section_statement_enum:
2391 print_output_section_statement (&s->output_section_statement);
2393 case lang_assignment_statement_enum:
2394 print_assignment (&s->assignment_statement, os);
2396 case lang_target_statement_enum:
2397 fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
2399 case lang_output_statement_enum:
2400 minfo ("OUTPUT(%s", s->output_statement.name);
2401 if (output_target != NULL)
2402 minfo (" %s", output_target);
2405 case lang_input_statement_enum:
2406 print_input_statement (&s->input_statement);
2408 case lang_group_statement_enum:
2409 print_group (&s->group_statement, os);
2411 case lang_afile_asection_pair_statement_enum:
2420 print_statement_list (statement_list.head, abs_output_section);
2423 /* Print the first N statements in statement list S to STDERR.
2424 If N == 0, nothing is printed.
2425 If N < 0, the entire list is printed.
2426 Intended to be called from GDB. */
2429 dprint_statement (s, n)
2430 lang_statement_union_type * s;
2433 FILE *map_save = config.map_file;
2435 config.map_file = stderr;
2438 print_statement_list (s, abs_output_section);
2441 while (s && --n >= 0)
2443 print_statement (s, abs_output_section);
2448 config.map_file = map_save;
2452 insert_pad (this_ptr, fill, power, output_section_statement, dot)
2453 lang_statement_union_type ** this_ptr;
2456 asection * output_section_statement;
2459 /* Align this section first to the
2460 input sections requirement, then
2461 to the output section's requirement.
2462 If this alignment is > than any seen before,
2463 then record it too. Perform the alignment by
2464 inserting a magic 'padding' statement.
2467 unsigned int alignment_needed = align_power (dot, power) - dot;
2469 if (alignment_needed != 0)
2471 lang_statement_union_type *new =
2472 ((lang_statement_union_type *)
2473 stat_alloc (sizeof (lang_padding_statement_type)));
2475 /* Link into existing chain */
2476 new->header.next = *this_ptr;
2478 new->header.type = lang_padding_statement_enum;
2479 new->padding_statement.output_section = output_section_statement;
2480 new->padding_statement.output_offset =
2481 dot - output_section_statement->vma;
2482 new->padding_statement.fill = fill;
2483 new->padding_statement.size = alignment_needed;
2487 /* Remember the most restrictive alignment */
2488 if (power > output_section_statement->alignment_power)
2490 output_section_statement->alignment_power = power;
2492 output_section_statement->_raw_size += alignment_needed;
2493 return alignment_needed + dot;
2497 /* Work out how much this section will move the dot point */
2499 size_input_section (this_ptr, output_section_statement, fill, dot, relax)
2500 lang_statement_union_type ** this_ptr;
2501 lang_output_section_statement_type * output_section_statement;
2504 boolean relax ATTRIBUTE_UNUSED;
2506 lang_input_section_type *is = &((*this_ptr)->input_section);
2507 asection *i = is->section;
2509 if (is->ifile->just_syms_flag == false)
2511 if (output_section_statement->subsection_alignment != -1)
2512 i->alignment_power =
2513 output_section_statement->subsection_alignment;
2515 dot = insert_pad (this_ptr, fill, i->alignment_power,
2516 output_section_statement->bfd_section, dot);
2518 /* Remember where in the output section this input section goes */
2520 i->output_offset = dot - output_section_statement->bfd_section->vma;
2522 /* Mark how big the output section must be to contain this now
2524 if (i->_cooked_size != 0)
2525 dot += i->_cooked_size;
2527 dot += i->_raw_size;
2528 output_section_statement->bfd_section->_raw_size = dot - output_section_statement->bfd_section->vma;
2532 i->output_offset = i->vma - output_section_statement->bfd_section->vma;
2538 /* Check to see if any allocated sections overlap with other allocated
2539 sections. This can happen when the linker script specifically specifies
2540 the output section addresses of the two sections. */
2542 lang_check_section_addresses ()
2546 /* Scan all sections in the output list. */
2547 for (s = output_bfd->sections; s != NULL; s = s->next)
2548 /* Ignore sections which are not loaded or which have no contents. */
2549 if ((bfd_get_section_flags (output_bfd, s) & (SEC_ALLOC | SEC_LOAD))
2550 && bfd_section_size (output_bfd, s) != 0)
2554 /* Once we reach section 's' stop our seach. This prevents two
2555 warning messages from being produced, one for 'section A overlaps
2556 section B' and one for 'section B overlaps section A'. */
2557 for (os = output_bfd->sections; os != s; os = os->next)
2564 /* Only consider loadable sections with real contents. */
2565 if (((bfd_get_section_flags (output_bfd, os)
2566 & (SEC_ALLOC | SEC_LOAD)) == 0)
2567 || bfd_section_size (output_bfd, os) == 0)
2570 /* We must check the sections' LMA addresses not their
2571 VMA addresses because overlay sections can have
2572 overlapping VMAs but they must have distinct LMAs. */
2573 s_start = bfd_section_lma (output_bfd, s);
2574 os_start = bfd_section_lma (output_bfd, os);
2575 s_end = s_start + bfd_section_size (output_bfd, s) - 1;
2576 os_end = os_start + bfd_section_size (output_bfd, os) - 1;
2578 /* Look for an overlap. */
2579 if ((s_end < os_start) || (s_start > os_end))
2583 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2584 s->name, s_start, s_end, os->name, os_start, os_end);
2586 /* Once we have found one overlap for this section,
2587 stop looking for others. */
2593 /* This variable indicates whether bfd_relax_section should be called
2596 static boolean relax_again;
2598 /* Set the sizes for all the output sections. */
2601 lang_size_sections (s, output_section_statement, prev, fill, dot, relax)
2602 lang_statement_union_type * s;
2603 lang_output_section_statement_type * output_section_statement;
2604 lang_statement_union_type ** prev;
2609 /* Size up the sections from their constituent parts. */
2610 for (; s != (lang_statement_union_type *) NULL; s = s->next)
2612 switch (s->header.type)
2614 case lang_output_section_statement_enum:
2617 lang_output_section_statement_type *os = &s->output_section_statement;
2619 if (os->bfd_section == NULL)
2620 /* This section was never actually created. */
2623 /* If this is a COFF shared library section, use the size and
2624 address from the input section. FIXME: This is COFF
2625 specific; it would be cleaner if there were some other way
2626 to do this, but nothing simple comes to mind. */
2627 if ((os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
2631 if (os->children.head == NULL
2632 || os->children.head->next != NULL
2633 || os->children.head->header.type != lang_input_section_enum)
2634 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2637 input = os->children.head->input_section.section;
2638 bfd_set_section_vma (os->bfd_section->owner,
2640 bfd_section_vma (input->owner, input));
2641 os->bfd_section->_raw_size = input->_raw_size;
2645 if (bfd_is_abs_section (os->bfd_section))
2647 /* No matter what happens, an abs section starts at zero. */
2648 ASSERT (os->bfd_section->vma == 0);
2652 if (os->addr_tree == (etree_type *) NULL)
2654 /* No address specified for this section, get one
2655 from the region specification. */
2656 if (os->region == (lang_memory_region_type *) NULL
2657 || (((bfd_get_section_flags (output_bfd, os->bfd_section)
2658 & (SEC_ALLOC | SEC_LOAD)) != 0)
2659 && os->region->name[0] == '*'
2660 && strcmp (os->region->name, "*default*") == 0))
2662 os->region = lang_memory_default (os->bfd_section);
2665 /* If a loadable section is using the default memory
2666 region, and some non default memory regions were
2667 defined, issue a warning. */
2668 if ((bfd_get_section_flags (output_bfd, os->bfd_section)
2669 & (SEC_ALLOC | SEC_LOAD)) != 0
2670 && ! link_info.relocateable
2671 && strcmp (os->region->name, "*default*") == 0
2672 && lang_memory_region_list != NULL
2673 && (strcmp (lang_memory_region_list->name, "*default*") != 0
2674 || lang_memory_region_list->next != NULL))
2675 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2676 bfd_get_section_name (output_bfd, os->bfd_section));
2678 dot = os->region->current;
2680 if (os->section_alignment == -1)
2685 dot = align_power (dot, os->bfd_section->alignment_power);
2687 if (dot != olddot && config.warn_section_align)
2688 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2689 os->name, (unsigned int) (dot - olddot));
2696 r = exp_fold_tree (os->addr_tree,
2698 lang_allocating_phase_enum,
2700 if (r.valid_p == false)
2702 einfo (_("%F%S: non constant address expression for section %s\n"),
2705 dot = r.value + r.section->bfd_section->vma;
2708 /* The section starts here.
2709 First, align to what the section needs. */
2711 if (os->section_alignment != -1)
2712 dot = align_power (dot, os->section_alignment);
2714 bfd_set_section_vma (0, os->bfd_section, dot);
2716 os->bfd_section->output_offset = 0;
2719 (void) lang_size_sections (os->children.head, os, &os->children.head,
2720 os->fill, dot, relax);
2722 /* Ignore the size of the input sections, use the vma and size to
2725 after = ALIGN_N (os->bfd_section->vma +
2726 os->bfd_section->_raw_size,
2727 /* The coercion here is important, see ld.h. */
2728 (bfd_vma) os->block_value);
2730 if (bfd_is_abs_section (os->bfd_section))
2731 ASSERT (after == os->bfd_section->vma);
2733 os->bfd_section->_raw_size = after - os->bfd_section->vma;
2734 dot = os->bfd_section->vma + os->bfd_section->_raw_size;
2735 os->processed = true;
2737 /* Update dot in the region ?
2738 We only do this if the section is going to be allocated,
2739 since unallocated sections do not contribute to the region's
2740 overall size in memory. */
2741 if (os->region != (lang_memory_region_type *) NULL
2742 && (bfd_get_section_flags (output_bfd, os->bfd_section)
2743 & (SEC_ALLOC | SEC_LOAD)))
2745 os->region->current = dot;
2747 /* Make sure this isn't silly. */
2748 if (os->region->current < os->region->origin
2749 || (os->region->current - os->region->origin
2750 > os->region->length))
2752 if (os->addr_tree != (etree_type *) NULL)
2754 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2755 os->region->current,
2756 os->bfd_section->owner,
2757 os->bfd_section->name,
2762 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2764 os->bfd_section->owner,
2765 os->bfd_section->name);
2767 /* Reset the region pointer. */
2768 os->region->current = os->region->origin;
2774 case lang_constructors_statement_enum:
2775 dot = lang_size_sections (constructor_list.head,
2776 output_section_statement,
2777 &s->wild_statement.children.head,
2782 case lang_data_statement_enum:
2784 unsigned int size = 0;
2786 s->data_statement.output_vma = dot - output_section_statement->bfd_section->vma;
2787 s->data_statement.output_section =
2788 output_section_statement->bfd_section;
2790 switch (s->data_statement.type)
2808 output_section_statement->bfd_section->_raw_size += size;
2809 /* The output section gets contents, and then we inspect for
2810 any flags set in the input script which override any ALLOC. */
2811 output_section_statement->bfd_section->flags |= SEC_HAS_CONTENTS;
2812 if (!(output_section_statement->flags & SEC_NEVER_LOAD)) {
2813 output_section_statement->bfd_section->flags |= SEC_ALLOC | SEC_LOAD;
2818 case lang_reloc_statement_enum:
2822 s->reloc_statement.output_vma =
2823 dot - output_section_statement->bfd_section->vma;
2824 s->reloc_statement.output_section =
2825 output_section_statement->bfd_section;
2826 size = bfd_get_reloc_size (s->reloc_statement.howto);
2828 output_section_statement->bfd_section->_raw_size += size;
2832 case lang_wild_statement_enum:
2834 dot = lang_size_sections (s->wild_statement.children.head,
2835 output_section_statement,
2836 &s->wild_statement.children.head,
2842 case lang_object_symbols_statement_enum:
2843 link_info.create_object_symbols_section =
2844 output_section_statement->bfd_section;
2846 case lang_output_statement_enum:
2847 case lang_target_statement_enum:
2849 case lang_input_section_enum:
2853 i = (*prev)->input_section.section;
2856 if (i->_cooked_size == 0)
2857 i->_cooked_size = i->_raw_size;
2863 if (! bfd_relax_section (i->owner, i, &link_info, &again))
2864 einfo (_("%P%F: can't relax section: %E\n"));
2868 dot = size_input_section (prev,
2869 output_section_statement,
2870 output_section_statement->fill,
2874 case lang_input_statement_enum:
2876 case lang_fill_statement_enum:
2877 s->fill_statement.output_section = output_section_statement->bfd_section;
2879 fill = s->fill_statement.fill;
2881 case lang_assignment_statement_enum:
2883 bfd_vma newdot = dot;
2885 exp_fold_tree (s->assignment_statement.exp,
2886 output_section_statement,
2887 lang_allocating_phase_enum,
2893 /* The assignment changed dot. Insert a pad. */
2894 if (output_section_statement == abs_output_section)
2896 /* If we don't have an output section, then just adjust
2897 the default memory address. */
2898 lang_memory_region_lookup ("*default*")->current = newdot;
2902 lang_statement_union_type *new =
2903 ((lang_statement_union_type *)
2904 stat_alloc (sizeof (lang_padding_statement_type)));
2906 /* Link into existing chain. */
2907 new->header.next = *prev;
2909 new->header.type = lang_padding_statement_enum;
2910 new->padding_statement.output_section =
2911 output_section_statement->bfd_section;
2912 new->padding_statement.output_offset =
2913 dot - output_section_statement->bfd_section->vma;
2914 new->padding_statement.fill = fill;
2915 new->padding_statement.size = newdot - dot;
2916 output_section_statement->bfd_section->_raw_size +=
2917 new->padding_statement.size;
2925 case lang_padding_statement_enum:
2926 /* If we are relaxing, and this is not the first pass, some
2927 padding statements may have been inserted during previous
2928 passes. We may have to move the padding statement to a new
2929 location if dot has a different value at this point in this
2930 pass than it did at this point in the previous pass. */
2931 s->padding_statement.output_offset =
2932 dot - output_section_statement->bfd_section->vma;
2933 dot += s->padding_statement.size;
2934 output_section_statement->bfd_section->_raw_size +=
2935 s->padding_statement.size;
2938 case lang_group_statement_enum:
2939 dot = lang_size_sections (s->group_statement.children.head,
2940 output_section_statement,
2941 &s->group_statement.children.head,
2949 /* This can only get here when relaxing is turned on. */
2951 case lang_address_statement_enum:
2954 prev = &s->header.next;
2960 lang_do_assignments (s, output_section_statement, fill, dot)
2961 lang_statement_union_type * s;
2962 lang_output_section_statement_type * output_section_statement;
2966 for (; s != (lang_statement_union_type *) NULL; s = s->next)
2968 switch (s->header.type)
2970 case lang_constructors_statement_enum:
2971 dot = lang_do_assignments (constructor_list.head,
2972 output_section_statement,
2977 case lang_output_section_statement_enum:
2979 lang_output_section_statement_type *os =
2980 &(s->output_section_statement);
2982 if (os->bfd_section != NULL)
2984 dot = os->bfd_section->vma;
2985 (void) lang_do_assignments (os->children.head, os,
2987 dot = os->bfd_section->vma + os->bfd_section->_raw_size;
2991 /* If nothing has been placed into the output section then
2992 it won't have a bfd_section. */
2993 if (os->bfd_section)
2995 os->bfd_section->lma
2996 = exp_get_abs_int(os->load_base, 0,"load base", lang_final_phase_enum);
3001 case lang_wild_statement_enum:
3003 dot = lang_do_assignments (s->wild_statement.children.head,
3004 output_section_statement,
3009 case lang_object_symbols_statement_enum:
3010 case lang_output_statement_enum:
3011 case lang_target_statement_enum:
3013 case lang_common_statement_enum:
3016 case lang_data_statement_enum:
3018 etree_value_type value;
3020 value = exp_fold_tree (s->data_statement.exp,
3022 lang_final_phase_enum, dot, &dot);
3023 s->data_statement.value = value.value;
3024 if (value.valid_p == false)
3025 einfo (_("%F%P: invalid data statement\n"));
3027 switch (s->data_statement.type)
3045 case lang_reloc_statement_enum:
3047 etree_value_type value;
3049 value = exp_fold_tree (s->reloc_statement.addend_exp,
3051 lang_final_phase_enum, dot, &dot);
3052 s->reloc_statement.addend_value = value.value;
3053 if (value.valid_p == false)
3054 einfo (_("%F%P: invalid reloc statement\n"));
3056 dot += bfd_get_reloc_size (s->reloc_statement.howto);
3059 case lang_input_section_enum:
3061 asection *in = s->input_section.section;
3063 if (in->_cooked_size != 0)
3064 dot += in->_cooked_size;
3066 dot += in->_raw_size;
3070 case lang_input_statement_enum:
3072 case lang_fill_statement_enum:
3073 fill = s->fill_statement.fill;
3075 case lang_assignment_statement_enum:
3077 exp_fold_tree (s->assignment_statement.exp,
3078 output_section_statement,
3079 lang_final_phase_enum,
3085 case lang_padding_statement_enum:
3086 dot += s->padding_statement.size;
3089 case lang_group_statement_enum:
3090 dot = lang_do_assignments (s->group_statement.children.head,
3091 output_section_statement,
3099 case lang_address_statement_enum:
3107 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3108 operator .startof. (section_name), it produces an undefined symbol
3109 .startof.section_name. Similarly, when it sees
3110 .sizeof. (section_name), it produces an undefined symbol
3111 .sizeof.section_name. For all the output sections, we look for
3112 such symbols, and set them to the correct value. */
3119 if (link_info.relocateable)
3122 for (s = output_bfd->sections; s != NULL; s = s->next)
3124 const char *secname;
3126 struct bfd_link_hash_entry *h;
3128 secname = bfd_get_section_name (output_bfd, s);
3129 buf = xmalloc (10 + strlen (secname));
3131 sprintf (buf, ".startof.%s", secname);
3132 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3133 if (h != NULL && h->type == bfd_link_hash_undefined)
3135 h->type = bfd_link_hash_defined;
3136 h->u.def.value = bfd_get_section_vma (output_bfd, s);
3137 h->u.def.section = bfd_abs_section_ptr;
3140 sprintf (buf, ".sizeof.%s", secname);
3141 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3142 if (h != NULL && h->type == bfd_link_hash_undefined)
3144 h->type = bfd_link_hash_defined;
3145 if (s->_cooked_size != 0)
3146 h->u.def.value = s->_cooked_size;
3148 h->u.def.value = s->_raw_size;
3149 h->u.def.section = bfd_abs_section_ptr;
3159 struct bfd_link_hash_entry *h;
3162 if (link_info.relocateable || link_info.shared)
3167 if (entry_symbol == (char *) NULL)
3169 /* No entry has been specified. Look for start, but don't warn
3170 if we don't find it. */
3171 entry_symbol = "start";
3175 h = bfd_link_hash_lookup (link_info.hash, entry_symbol, false, false, true);
3176 if (h != (struct bfd_link_hash_entry *) NULL
3177 && (h->type == bfd_link_hash_defined
3178 || h->type == bfd_link_hash_defweak)
3179 && h->u.def.section->output_section != NULL)
3183 val = (h->u.def.value
3184 + bfd_get_section_vma (output_bfd,
3185 h->u.def.section->output_section)
3186 + h->u.def.section->output_offset);
3187 if (! bfd_set_start_address (output_bfd, val))
3188 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol);
3195 /* We couldn't find the entry symbol. Try parsing it as a
3197 val = bfd_scan_vma (entry_symbol, &send, 0);
3200 if (! bfd_set_start_address (output_bfd, val))
3201 einfo (_("%P%F: can't set start address\n"));
3207 /* Can't find the entry symbol, and it's not a number. Use
3208 the first address in the text section. */
3209 ts = bfd_get_section_by_name (output_bfd, ".text");
3210 if (ts != (asection *) NULL)
3213 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3214 entry_symbol, bfd_get_section_vma (output_bfd, ts));
3215 if (! bfd_set_start_address (output_bfd,
3216 bfd_get_section_vma (output_bfd,
3218 einfo (_("%P%F: can't set start address\n"));
3223 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3230 /* This is a small function used when we want to ignore errors from
3234 #ifdef ANSI_PROTOTYPES
3235 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
3237 ignore_bfd_errors (s)
3238 const char *s ATTRIBUTE_UNUSED;
3241 /* Don't do anything. */
3244 /* Check that the architecture of all the input files is compatible
3245 with the output file. Also call the backend to let it do any
3246 other checking that is needed. */
3251 lang_statement_union_type *file;
3253 CONST bfd_arch_info_type *compatible;
3255 for (file = file_chain.head;
3256 file != (lang_statement_union_type *) NULL;
3257 file = file->input_statement.next)
3259 input_bfd = file->input_statement.the_bfd;
3260 compatible = bfd_arch_get_compatible (input_bfd,
3262 if (compatible == NULL)
3264 if (command_line.warn_mismatch)
3265 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3266 bfd_printable_name (input_bfd), input_bfd,
3267 bfd_printable_name (output_bfd));
3271 bfd_error_handler_type pfn = NULL;
3273 /* If we aren't supposed to warn about mismatched input
3274 files, temporarily set the BFD error handler to a
3275 function which will do nothing. We still want to call
3276 bfd_merge_private_bfd_data, since it may set up
3277 information which is needed in the output file. */
3278 if (! command_line.warn_mismatch)
3279 pfn = bfd_set_error_handler (ignore_bfd_errors);
3280 if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
3282 if (command_line.warn_mismatch)
3283 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3286 if (! command_line.warn_mismatch)
3287 bfd_set_error_handler (pfn);
3292 /* Look through all the global common symbols and attach them to the
3293 correct section. The -sort-common command line switch may be used
3294 to roughly sort the entries by size. */
3299 if (link_info.relocateable
3300 && ! command_line.force_common_definition)
3303 if (! config.sort_common)
3304 bfd_link_hash_traverse (link_info.hash, lang_one_common, (PTR) NULL);
3309 for (power = 4; power >= 0; power--)
3310 bfd_link_hash_traverse (link_info.hash, lang_one_common,
3315 /* Place one common symbol in the correct section. */
3318 lang_one_common (h, info)
3319 struct bfd_link_hash_entry *h;
3322 unsigned int power_of_two;
3326 if (h->type != bfd_link_hash_common)
3330 power_of_two = h->u.c.p->alignment_power;
3332 if (config.sort_common
3333 && power_of_two < (unsigned int) *(int *) info)
3336 section = h->u.c.p->section;
3338 /* Increase the size of the section. */
3339 section->_cooked_size = ALIGN_N (section->_cooked_size,
3340 (bfd_size_type) (1 << power_of_two));
3342 /* Adjust the alignment if necessary. */
3343 if (power_of_two > section->alignment_power)
3344 section->alignment_power = power_of_two;
3346 /* Change the symbol from common to defined. */
3347 h->type = bfd_link_hash_defined;
3348 h->u.def.section = section;
3349 h->u.def.value = section->_cooked_size;
3351 /* Increase the size of the section. */
3352 section->_cooked_size += size;
3354 /* Make sure the section is allocated in memory, and make sure that
3355 it is no longer a common section. */
3356 section->flags |= SEC_ALLOC;
3357 section->flags &= ~ SEC_IS_COMMON;
3359 if (config.map_file != NULL)
3361 static boolean header_printed;
3366 if (! header_printed)
3368 minfo (_("\nAllocating common symbols\n"));
3369 minfo (_("Common symbol size file\n\n"));
3370 header_printed = true;
3373 name = demangle (h->root.string);
3375 len = strlen (name);
3390 if (size <= 0xffffffff)
3391 sprintf (buf, "%lx", (unsigned long) size);
3393 sprintf_vma (buf, size);
3403 minfo ("%B\n", section->owner);
3410 run through the input files and ensure that every input
3411 section has somewhere to go. If one is found without
3412 a destination then create an input request and place it
3413 into the statement tree.
3417 lang_place_orphans ()
3419 LANG_FOR_EACH_INPUT_STATEMENT (file)
3423 for (s = file->the_bfd->sections;
3424 s != (asection *) NULL;
3427 if (s->output_section == (asection *) NULL)
3429 /* This section of the file is not attatched, root
3430 around for a sensible place for it to go */
3432 if (file->just_syms_flag)
3434 /* We are only retrieving symbol values from this
3435 file. We want the symbols to act as though the
3436 values in the file are absolute. */
3437 s->output_section = bfd_abs_section_ptr;
3438 s->output_offset = s->vma;
3440 else if (strcmp (s->name, "COMMON") == 0)
3442 /* This is a lonely common section which must have
3443 come from an archive. We attach to the section
3444 with the wildcard. */
3445 if (! link_info.relocateable
3446 || command_line.force_common_definition)
3448 if (default_common_section == NULL)
3451 /* This message happens when using the
3452 svr3.ifile linker script, so I have
3454 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3456 default_common_section =
3457 lang_output_section_statement_lookup (".bss");
3460 wild_doit (&default_common_section->children, s,
3461 default_common_section, file);
3464 else if (ldemul_place_orphan (file, s))
3468 lang_output_section_statement_type *os =
3469 lang_output_section_statement_lookup (s->name);
3471 wild_doit (&os->children, s, os, file);
3480 lang_set_flags (ptr, flags, invert)
3481 lang_memory_region_type *ptr;
3485 flagword *ptr_flags;
3487 ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
3493 *ptr_flags |= SEC_ALLOC;
3497 *ptr_flags |= SEC_READONLY;
3501 *ptr_flags |= SEC_DATA;
3505 *ptr_flags |= SEC_CODE;
3510 *ptr_flags |= SEC_LOAD;
3514 einfo (_("%P%F: invalid syntax in flags\n"));
3521 /* Call a function on each input file. This function will be called
3522 on an archive, but not on the elements. */
3525 lang_for_each_input_file (func)
3526 void (*func) PARAMS ((lang_input_statement_type *));
3528 lang_input_statement_type *f;
3530 for (f = (lang_input_statement_type *) input_file_chain.head;
3532 f = (lang_input_statement_type *) f->next_real_file)
3536 /* Call a function on each file. The function will be called on all
3537 the elements of an archive which are included in the link, but will
3538 not be called on the archive file itself. */
3541 lang_for_each_file (func)
3542 void (*func) PARAMS ((lang_input_statement_type *));
3544 LANG_FOR_EACH_INPUT_STATEMENT (f)
3555 lang_for_each_input_section (func)
3556 void (*func) PARAMS ((bfd * ab, asection * as));
3558 LANG_FOR_EACH_INPUT_STATEMENT (f)
3562 for (s = f->the_bfd->sections;
3563 s != (asection *) NULL;
3566 func (f->the_bfd, s);
3574 ldlang_add_file (entry)
3575 lang_input_statement_type * entry;
3579 lang_statement_append (&file_chain,
3580 (lang_statement_union_type *) entry,
3583 /* The BFD linker needs to have a list of all input BFDs involved in
3585 ASSERT (entry->the_bfd->link_next == (bfd *) NULL);
3586 ASSERT (entry->the_bfd != output_bfd);
3587 for (pp = &link_info.input_bfds;
3588 *pp != (bfd *) NULL;
3589 pp = &(*pp)->link_next)
3591 *pp = entry->the_bfd;
3592 entry->the_bfd->usrdata = (PTR) entry;
3593 bfd_set_gp_size (entry->the_bfd, g_switch_value);
3595 /* Look through the sections and check for any which should not be
3596 included in the link. We need to do this now, so that we can
3597 notice when the backend linker tries to report multiple
3598 definition errors for symbols which are in sections we aren't
3599 going to link. FIXME: It might be better to entirely ignore
3600 symbols which are defined in sections which are going to be
3601 discarded. This would require modifying the backend linker for
3602 each backend which might set the SEC_LINK_ONCE flag. If we do
3603 this, we should probably handle SEC_EXCLUDE in the same way. */
3605 bfd_map_over_sections (entry->the_bfd, section_already_linked, (PTR) entry);
3609 lang_add_output (name, from_script)
3613 /* Make -o on command line override OUTPUT in script. */
3614 if (had_output_filename == false || !from_script)
3616 output_filename = name;
3617 had_output_filename = true;
3622 static lang_output_section_statement_type *current_section;
3634 for (l = 0; l < 32; l++)
3636 if (i >= (unsigned int) x)
3645 lang_enter_output_section_statement (output_section_statement_name,
3646 address_exp, sectype, block_value,
3647 align, subalign, ebase)
3648 const char *output_section_statement_name;
3649 etree_type * address_exp;
3650 enum section_type sectype;
3651 bfd_vma block_value;
3653 etree_type *subalign;
3656 lang_output_section_statement_type *os;
3660 lang_output_section_statement_lookup (output_section_statement_name);
3664 /* Add this statement to tree */
3665 /* add_statement(lang_output_section_statement_enum,
3666 output_section_statement);*/
3667 /* Make next things chain into subchain of this */
3669 if (os->addr_tree ==
3670 (etree_type *) NULL)
3675 os->sectype = sectype;
3676 if (sectype != noload_section)
3677 os->flags = SEC_NO_FLAGS;
3679 os->flags = SEC_NEVER_LOAD;
3680 os->block_value = block_value ? block_value : 1;
3681 stat_ptr = &os->children;
3683 os->subsection_alignment = topower(
3684 exp_get_value_int(subalign, -1,
3685 "subsection alignment",
3687 os->section_alignment = topower(
3688 exp_get_value_int(align, -1,
3689 "section alignment", 0));
3691 os->load_base = ebase;
3698 lang_output_statement_type *new =
3699 new_stat (lang_output_statement, stat_ptr);
3701 new->name = output_filename;
3704 /* Reset the current counters in the regions */
3706 reset_memory_regions ()
3708 lang_memory_region_type *p = lang_memory_region_list;
3710 for (p = lang_memory_region_list;
3711 p != (lang_memory_region_type *) NULL;
3714 p->old_length = (bfd_size_type) (p->current - p->origin);
3715 p->current = p->origin;
3719 /* Expand a wild statement for a particular FILE, marking its sections KEEP
3720 as needed. SECTION may be NULL, in which case it is a wild card. */
3723 gc_section_callback (ptr, section, file, data)
3724 lang_wild_statement_type *ptr;
3726 lang_input_statement_type *file ATTRIBUTE_UNUSED;
3727 void *data ATTRIBUTE_UNUSED;
3729 /* If the wild pattern was marked KEEP, the member sections
3730 should be as well. */
3731 if (ptr->keep_sections)
3732 section->flags |= SEC_KEEP;
3735 /* Handle a wild statement, marking it against GC. SECTION or FILE or both
3736 may be NULL, indicating that it is a wildcard. */
3739 lang_gc_wild (s, section, file)
3740 lang_wild_statement_type *s;
3741 const char *section;
3744 walk_wild (s, section, file, gc_section_callback, NULL);
3747 /* Iterate over sections marking them against GC. */
3750 lang_gc_sections_1 (s)
3751 lang_statement_union_type * s;
3753 for (; s != (lang_statement_union_type *) NULL; s = s->next)
3755 switch (s->header.type)
3757 case lang_wild_statement_enum:
3758 lang_gc_wild (&s->wild_statement,
3759 s->wild_statement.section_name,
3760 s->wild_statement.filename);
3762 case lang_constructors_statement_enum:
3763 lang_gc_sections_1 (constructor_list.head);
3765 case lang_output_section_statement_enum:
3766 lang_gc_sections_1 (s->output_section_statement.children.head);
3768 case lang_group_statement_enum:
3769 lang_gc_sections_1 (s->group_statement.children.head);
3780 struct bfd_link_hash_entry *h;
3781 ldlang_undef_chain_list_type *ulist, fake_list_start;
3783 /* Keep all sections so marked in the link script. */
3785 lang_gc_sections_1 (statement_list.head);
3787 /* Keep all sections containing symbols undefined on the command-line.
3788 Handle the entry symbol at the same time. */
3790 fake_list_start.next = ldlang_undef_chain_list_head;
3791 if (entry_symbol == NULL)
3792 fake_list_start.name = "start";
3794 fake_list_start.name = (char *) entry_symbol;
3796 for (ulist = &fake_list_start; ulist; ulist = ulist->next)
3798 h = bfd_link_hash_lookup (link_info.hash, ulist->name,
3799 false, false, false);
3801 if (h != (struct bfd_link_hash_entry *) NULL
3802 && (h->type == bfd_link_hash_defined
3803 || h->type == bfd_link_hash_defweak)
3804 && ! bfd_is_abs_section (h->u.def.section))
3806 h->u.def.section->flags |= SEC_KEEP;
3810 bfd_gc_sections (output_bfd, &link_info);
3816 lang_reasonable_defaults ();
3817 current_target = default_target;
3819 lang_for_each_statement (ldlang_open_output); /* Open the output file */
3821 ldemul_create_output_section_statements ();
3823 /* Add to the hash table all undefineds on the command line */
3824 lang_place_undefineds ();
3826 /* Create a bfd for each input file */
3827 current_target = default_target;
3828 open_input_bfds (statement_list.head, false);
3830 ldemul_after_open ();
3832 /* Make sure that we're not mixing architectures. We call this
3833 after all the input files have been opened, but before we do any
3834 other processing, so that any operations merge_private_bfd_data
3835 does on the output file will be known during the rest of the
3839 /* Handle .exports instead of a version script if we're told to do so. */
3840 if (command_line.version_exports_section)
3841 lang_do_version_exports_section ();
3843 /* Build all sets based on the information gathered from the input
3845 ldctor_build_sets ();
3847 /* Remove unreferenced sections if asked to. */
3848 if (command_line.gc_sections)
3849 lang_gc_sections ();
3851 /* Size up the common data */
3854 /* Run through the contours of the script and attach input sections
3855 to the correct output sections
3857 map_input_to_output_sections (statement_list.head, (char *) NULL,
3858 (lang_output_section_statement_type *) NULL);
3861 /* Find any sections not attached explicitly and handle them */
3862 lang_place_orphans ();
3864 ldemul_before_allocation ();
3866 /* We must record the program headers before we try to fix the
3867 section positions, since they will affect SIZEOF_HEADERS. */
3868 lang_record_phdrs ();
3870 /* Now run around and relax if we can */
3871 if (command_line.relax)
3873 /* First time round is a trial run to get the 'worst case'
3874 addresses of the objects if there was no relaxing. */
3875 lang_size_sections (statement_list.head,
3877 &(statement_list.head), 0, (bfd_vma) 0, false);
3879 /* Keep relaxing until bfd_relax_section gives up. */
3882 reset_memory_regions ();
3884 relax_again = false;
3886 /* Note: pe-dll.c does something like this also. If you find
3887 you need to change this code, you probably need to change
3888 pe-dll.c also. DJ */
3890 /* Do all the assignments with our current guesses as to
3892 lang_do_assignments (statement_list.head,
3894 (fill_type) 0, (bfd_vma) 0);
3896 /* Perform another relax pass - this time we know where the
3897 globals are, so can make better guess. */
3898 lang_size_sections (statement_list.head,
3900 &(statement_list.head), 0, (bfd_vma) 0, true);
3902 while (relax_again);
3906 /* Size up the sections. */
3907 lang_size_sections (statement_list.head,
3909 &(statement_list.head), 0, (bfd_vma) 0, false);
3912 /* See if anything special should be done now we know how big
3914 ldemul_after_allocation ();
3916 /* Fix any .startof. or .sizeof. symbols. */
3917 lang_set_startof ();
3919 /* Do all the assignments, now that we know the final restingplaces
3920 of all the symbols */
3922 lang_do_assignments (statement_list.head,
3924 (fill_type) 0, (bfd_vma) 0);
3926 /* Make sure that the section addresses make sense. */
3927 if (! link_info.relocateable
3928 && command_line.check_section_addresses)
3929 lang_check_section_addresses ();
3937 /* EXPORTED TO YACC */
3940 lang_add_wild (section_name, sections_sorted, filename, filenames_sorted,
3941 keep_sections, exclude_filename)
3942 const char *const section_name;
3943 boolean sections_sorted;
3944 const char *const filename;
3945 boolean filenames_sorted;
3946 boolean keep_sections;
3947 const char *exclude_filename;
3949 lang_wild_statement_type *new = new_stat (lang_wild_statement,
3952 if (section_name != (char *) NULL && strcmp (section_name, "COMMON") == 0)
3954 placed_commons = true;
3956 if (filename != NULL && ! wildcardp (filename))
3958 lang_has_input_file = true;
3960 new->section_name = section_name;
3961 new->sections_sorted = sections_sorted;
3962 new->filename = filename;
3963 new->filenames_sorted = filenames_sorted;
3964 new->keep_sections = keep_sections;
3965 new->exclude_filename = exclude_filename;
3966 lang_list_init (&new->children);
3970 lang_section_start (name, address)
3972 etree_type * address;
3974 lang_address_statement_type *ad = new_stat (lang_address_statement, stat_ptr);
3976 ad->section_name = name;
3977 ad->address = address;
3980 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
3981 because of a -e argument on the command line, or zero if this is
3982 called by ENTRY in a linker script. Command line arguments take
3986 lang_add_entry (name, cmdline)
3990 if (entry_symbol == NULL
3992 || ! entry_from_cmdline)
3994 entry_symbol = name;
3995 entry_from_cmdline = cmdline;
4000 lang_add_target (name)
4003 lang_target_statement_type *new = new_stat (lang_target_statement,
4019 map_option_f = true;
4030 lang_fill_statement_type *new = new_stat (lang_fill_statement,
4037 lang_add_data (type, exp)
4039 union etree_union *exp;
4042 lang_data_statement_type *new = new_stat (lang_data_statement,
4050 /* Create a new reloc statement. RELOC is the BFD relocation type to
4051 generate. HOWTO is the corresponding howto structure (we could
4052 look this up, but the caller has already done so). SECTION is the
4053 section to generate a reloc against, or NAME is the name of the
4054 symbol to generate a reloc against. Exactly one of SECTION and
4055 NAME must be NULL. ADDEND is an expression for the addend. */
4058 lang_add_reloc (reloc, howto, section, name, addend)
4059 bfd_reloc_code_real_type reloc;
4060 reloc_howto_type *howto;
4063 union etree_union *addend;
4065 lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
4069 p->section = section;
4071 p->addend_exp = addend;
4073 p->addend_value = 0;
4074 p->output_section = NULL;
4078 lang_assignment_statement_type *
4079 lang_add_assignment (exp)
4082 lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
4090 lang_add_attribute (attribute)
4091 enum statement_enum attribute;
4093 new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
4100 if (startup_file != (char *) NULL)
4102 einfo (_("%P%Fmultiple STARTUP files\n"));
4104 first_file->filename = name;
4105 first_file->local_sym_name = name;
4106 first_file->real = true;
4108 startup_file = name;
4115 lang_float_flag = maybe;
4119 lang_leave_output_section_statement (fill, memspec, phdrs)
4121 const char *memspec;
4122 struct lang_output_section_phdr_list *phdrs;
4124 current_section->fill = fill;
4125 current_section->region = lang_memory_region_lookup (memspec);
4126 current_section->phdrs = phdrs;
4127 stat_ptr = &statement_list;
4131 Create an absolute symbol with the given name with the value of the
4132 address of first byte of the section named.
4134 If the symbol already exists, then do nothing.
4137 lang_abs_symbol_at_beginning_of (secname, name)
4138 const char *secname;
4141 struct bfd_link_hash_entry *h;
4143 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4144 if (h == (struct bfd_link_hash_entry *) NULL)
4145 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4147 if (h->type == bfd_link_hash_new
4148 || h->type == bfd_link_hash_undefined)
4152 h->type = bfd_link_hash_defined;
4154 sec = bfd_get_section_by_name (output_bfd, secname);
4155 if (sec == (asection *) NULL)
4158 h->u.def.value = bfd_get_section_vma (output_bfd, sec);
4160 h->u.def.section = bfd_abs_section_ptr;
4165 Create an absolute symbol with the given name with the value of the
4166 address of the first byte after the end of the section named.
4168 If the symbol already exists, then do nothing.
4171 lang_abs_symbol_at_end_of (secname, name)
4172 const char *secname;
4175 struct bfd_link_hash_entry *h;
4177 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4178 if (h == (struct bfd_link_hash_entry *) NULL)
4179 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4181 if (h->type == bfd_link_hash_new
4182 || h->type == bfd_link_hash_undefined)
4186 h->type = bfd_link_hash_defined;
4188 sec = bfd_get_section_by_name (output_bfd, secname);
4189 if (sec == (asection *) NULL)
4192 h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
4193 + bfd_section_size (output_bfd, sec));
4195 h->u.def.section = bfd_abs_section_ptr;
4200 lang_statement_append (list, element, field)
4201 lang_statement_list_type * list;
4202 lang_statement_union_type * element;
4203 lang_statement_union_type ** field;
4205 *(list->tail) = element;
4209 /* Set the output format type. -oformat overrides scripts. */
4212 lang_add_output_format (format, big, little, from_script)
4218 if (output_target == NULL || !from_script)
4220 if (command_line.endian == ENDIAN_BIG
4223 else if (command_line.endian == ENDIAN_LITTLE
4227 output_target = format;
4231 /* Enter a group. This creates a new lang_group_statement, and sets
4232 stat_ptr to build new statements within the group. */
4237 lang_group_statement_type *g;
4239 g = new_stat (lang_group_statement, stat_ptr);
4240 lang_list_init (&g->children);
4241 stat_ptr = &g->children;
4244 /* Leave a group. This just resets stat_ptr to start writing to the
4245 regular list of statements again. Note that this will not work if
4246 groups can occur inside anything else which can adjust stat_ptr,
4247 but currently they can't. */
4252 stat_ptr = &statement_list;
4255 /* Add a new program header. This is called for each entry in a PHDRS
4256 command in a linker script. */
4259 lang_new_phdr (name, type, filehdr, phdrs, at, flags)
4267 struct lang_phdr *n, **pp;
4269 n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));
4272 n->type = exp_get_value_int (type, 0, "program header type",
4273 lang_final_phase_enum);
4274 n->filehdr = filehdr;
4279 for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
4284 /* Record the program header information in the output BFD. FIXME: We
4285 should not be calling an ELF specific function here. */
4288 lang_record_phdrs ()
4292 struct lang_output_section_phdr_list *last;
4293 struct lang_phdr *l;
4294 lang_statement_union_type *u;
4297 secs = (asection **) xmalloc (alc * sizeof (asection *));
4299 for (l = lang_phdr_list; l != NULL; l = l->next)
4306 for (u = lang_output_section_statement.head;
4308 u = u->output_section_statement.next)
4310 lang_output_section_statement_type *os;
4311 struct lang_output_section_phdr_list *pl;
4313 os = &u->output_section_statement;
4320 if (os->sectype == noload_section
4321 || os->bfd_section == NULL
4322 || (os->bfd_section->flags & SEC_ALLOC) == 0)
4327 if (os->bfd_section == NULL)
4330 for (; pl != NULL; pl = pl->next)
4332 if (strcmp (pl->name, l->name) == 0)
4337 secs = ((asection **)
4338 xrealloc (secs, alc * sizeof (asection *)));
4340 secs[c] = os->bfd_section;
4347 if (l->flags == NULL)
4350 flags = exp_get_vma (l->flags, 0, "phdr flags",
4351 lang_final_phase_enum);
4356 at = exp_get_vma (l->at, 0, "phdr load address",
4357 lang_final_phase_enum);
4359 if (! bfd_record_phdr (output_bfd, l->type,
4360 l->flags == NULL ? false : true,
4362 l->at == NULL ? false : true,
4363 at, l->filehdr, l->phdrs, c, secs))
4364 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4369 /* Make sure all the phdr assignments succeeded. */
4370 for (u = lang_output_section_statement.head;
4372 u = u->output_section_statement.next)
4374 struct lang_output_section_phdr_list *pl;
4376 if (u->output_section_statement.bfd_section == NULL)
4379 for (pl = u->output_section_statement.phdrs;
4382 if (! pl->used && strcmp (pl->name, "NONE") != 0)
4383 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4384 u->output_section_statement.name, pl->name);
4388 /* Record a list of sections which may not be cross referenced. */
4391 lang_add_nocrossref (l)
4392 struct lang_nocrossref *l;
4394 struct lang_nocrossrefs *n;
4396 n = (struct lang_nocrossrefs *) xmalloc (sizeof *n);
4397 n->next = nocrossref_list;
4399 nocrossref_list = n;
4401 /* Set notice_all so that we get informed about all symbols. */
4402 link_info.notice_all = true;
4405 /* Overlay handling. We handle overlays with some static variables. */
4407 /* The overlay virtual address. */
4408 static etree_type *overlay_vma;
4410 /* The overlay load address. */
4411 static etree_type *overlay_lma;
4413 /* Whether nocrossrefs is set for this overlay. */
4414 static int overlay_nocrossrefs;
4416 /* An expression for the maximum section size seen so far. */
4417 static etree_type *overlay_max;
4419 /* A list of all the sections in this overlay. */
4423 struct overlay_list *next;
4424 lang_output_section_statement_type *os;
4427 static struct overlay_list *overlay_list;
4429 /* Start handling an overlay. */
4432 lang_enter_overlay (vma_expr, lma_expr, nocrossrefs)
4433 etree_type *vma_expr;
4434 etree_type *lma_expr;
4437 /* The grammar should prevent nested overlays from occurring. */
4438 ASSERT (overlay_vma == NULL
4439 && overlay_lma == NULL
4440 && overlay_list == NULL
4441 && overlay_max == NULL);
4443 overlay_vma = vma_expr;
4444 overlay_lma = lma_expr;
4445 overlay_nocrossrefs = nocrossrefs;
4448 /* Start a section in an overlay. We handle this by calling
4449 lang_enter_output_section_statement with the correct VMA and LMA. */
4452 lang_enter_overlay_section (name)
4455 struct overlay_list *n;
4458 lang_enter_output_section_statement (name, overlay_vma, normal_section,
4459 0, 0, 0, overlay_lma);
4461 /* If this is the first section, then base the VMA and LMA of future
4462 sections on this one. This will work correctly even if `.' is
4463 used in the addresses. */
4464 if (overlay_list == NULL)
4466 overlay_vma = exp_nameop (ADDR, name);
4467 overlay_lma = exp_nameop (LOADADDR, name);
4470 /* Remember the section. */
4471 n = (struct overlay_list *) xmalloc (sizeof *n);
4472 n->os = current_section;
4473 n->next = overlay_list;
4476 size = exp_nameop (SIZEOF, name);
4478 /* Adjust the LMA for the next section. */
4479 overlay_lma = exp_binop ('+', overlay_lma, size);
4481 /* Arrange to work out the maximum section end address. */
4482 if (overlay_max == NULL)
4485 overlay_max = exp_binop (MAX_K, overlay_max, size);
4488 /* Finish a section in an overlay. There isn't any special to do
4492 lang_leave_overlay_section (fill, phdrs)
4494 struct lang_output_section_phdr_list *phdrs;
4501 name = current_section->name;
4503 lang_leave_output_section_statement (fill, "*default*", phdrs);
4505 /* Define the magic symbols. */
4507 clean = xmalloc (strlen (name) + 1);
4509 for (s1 = name; *s1 != '\0'; s1++)
4510 if (isalnum ((unsigned char) *s1) || *s1 == '_')
4514 buf = xmalloc (strlen (clean) + sizeof "__load_start_");
4515 sprintf (buf, "__load_start_%s", clean);
4516 lang_add_assignment (exp_assop ('=', buf,
4517 exp_nameop (LOADADDR, name)));
4519 buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
4520 sprintf (buf, "__load_stop_%s", clean);
4521 lang_add_assignment (exp_assop ('=', buf,
4523 exp_nameop (LOADADDR, name),
4524 exp_nameop (SIZEOF, name))));
4529 /* Finish an overlay. If there are any overlay wide settings, this
4530 looks through all the sections in the overlay and sets them. */
4533 lang_leave_overlay (fill, memspec, phdrs)
4535 const char *memspec;
4536 struct lang_output_section_phdr_list *phdrs;
4538 lang_memory_region_type *region;
4539 struct overlay_list *l;
4540 struct lang_nocrossref *nocrossref;
4542 if (memspec == NULL)
4545 region = lang_memory_region_lookup (memspec);
4552 struct overlay_list *next;
4554 if (fill != 0 && l->os->fill == 0)
4556 if (region != NULL && l->os->region == NULL)
4557 l->os->region = region;
4558 if (phdrs != NULL && l->os->phdrs == NULL)
4559 l->os->phdrs = phdrs;
4561 if (overlay_nocrossrefs)
4563 struct lang_nocrossref *nc;
4565 nc = (struct lang_nocrossref *) xmalloc (sizeof *nc);
4566 nc->name = l->os->name;
4567 nc->next = nocrossref;
4576 if (nocrossref != NULL)
4577 lang_add_nocrossref (nocrossref);
4579 /* Update . for the end of the overlay. */
4580 lang_add_assignment (exp_assop ('=', ".",
4581 exp_binop ('+', overlay_vma, overlay_max)));
4585 overlay_nocrossrefs = 0;
4586 overlay_list = NULL;
4590 /* Version handling. This is only useful for ELF. */
4592 /* This global variable holds the version tree that we build. */
4594 struct bfd_elf_version_tree *lang_elf_version_info;
4597 lang_vers_match_lang_c (expr, sym)
4598 struct bfd_elf_version_expr *expr;
4601 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4603 return fnmatch (expr->pattern, sym, 0) == 0;
4607 lang_vers_match_lang_cplusplus (expr, sym)
4608 struct bfd_elf_version_expr *expr;
4614 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4617 alt_sym = cplus_demangle(sym, /* DMGL_NO_TPARAMS */ 0);
4620 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
4621 Should we early out false in this case? */
4622 result = fnmatch (expr->pattern, sym, 0) == 0;
4626 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
4634 lang_vers_match_lang_java (expr, sym)
4635 struct bfd_elf_version_expr *expr;
4641 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4644 alt_sym = cplus_demangle(sym, DMGL_JAVA);
4647 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
4648 Should we early out false in this case? */
4649 result = fnmatch (expr->pattern, sym, 0) == 0;
4653 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
4660 /* This is called for each variable name or match expression. */
4662 struct bfd_elf_version_expr *
4663 lang_new_vers_regex (orig, new, lang)
4664 struct bfd_elf_version_expr *orig;
4668 struct bfd_elf_version_expr *ret;
4670 ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret);
4674 if (lang == NULL || strcasecmp (lang, "C") == 0)
4675 ret->match = lang_vers_match_lang_c;
4676 else if (strcasecmp (lang, "C++") == 0)
4677 ret->match = lang_vers_match_lang_cplusplus;
4678 else if (strcasecmp (lang, "Java") == 0)
4679 ret->match = lang_vers_match_lang_java;
4682 einfo (_("%X%P: unknown language `%s' in version information\n"),
4684 ret->match = lang_vers_match_lang_c;
4690 /* This is called for each set of variable names and match
4693 struct bfd_elf_version_tree *
4694 lang_new_vers_node (globals, locals)
4695 struct bfd_elf_version_expr *globals;
4696 struct bfd_elf_version_expr *locals;
4698 struct bfd_elf_version_tree *ret;
4700 ret = (struct bfd_elf_version_tree *) xmalloc (sizeof *ret);
4704 ret->globals = globals;
4705 ret->locals = locals;
4707 ret->name_indx = (unsigned int) -1;
4712 /* This static variable keeps track of version indices. */
4714 static int version_index;
4716 /* This is called when we know the name and dependencies of the
4720 lang_register_vers_node (name, version, deps)
4722 struct bfd_elf_version_tree *version;
4723 struct bfd_elf_version_deps *deps;
4725 struct bfd_elf_version_tree *t, **pp;
4726 struct bfd_elf_version_expr *e1;
4728 /* Make sure this node has a unique name. */
4729 for (t = lang_elf_version_info; t != NULL; t = t->next)
4730 if (strcmp (t->name, name) == 0)
4731 einfo (_("%X%P: duplicate version tag `%s'\n"), name);
4733 /* Check the global and local match names, and make sure there
4734 aren't any duplicates. */
4736 for (e1 = version->globals; e1 != NULL; e1 = e1->next)
4738 for (t = lang_elf_version_info; t != NULL; t = t->next)
4740 struct bfd_elf_version_expr *e2;
4742 for (e2 = t->locals; e2 != NULL; e2 = e2->next)
4743 if (strcmp (e1->pattern, e2->pattern) == 0)
4744 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
4749 for (e1 = version->locals; e1 != NULL; e1 = e1->next)
4751 for (t = lang_elf_version_info; t != NULL; t = t->next)
4753 struct bfd_elf_version_expr *e2;
4755 for (e2 = t->globals; e2 != NULL; e2 = e2->next)
4756 if (strcmp (e1->pattern, e2->pattern) == 0)
4757 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
4762 version->deps = deps;
4763 version->name = name;
4765 version->vernum = version_index;
4767 for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
4772 /* This is called when we see a version dependency. */
4774 struct bfd_elf_version_deps *
4775 lang_add_vers_depend (list, name)
4776 struct bfd_elf_version_deps *list;
4779 struct bfd_elf_version_deps *ret;
4780 struct bfd_elf_version_tree *t;
4782 ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret);
4785 for (t = lang_elf_version_info; t != NULL; t = t->next)
4787 if (strcmp (t->name, name) == 0)
4789 ret->version_needed = t;
4794 einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
4800 lang_do_version_exports_section ()
4802 struct bfd_elf_version_expr *greg = NULL, *lreg;
4804 LANG_FOR_EACH_INPUT_STATEMENT (is)
4806 asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
4813 len = bfd_section_size (is->the_bfd, sec);
4814 contents = xmalloc (len);
4815 if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
4816 einfo (_("%X%P: unable to read .exports section contents"), sec);
4819 while (p < contents+len)
4821 greg = lang_new_vers_regex (greg, p, NULL);
4822 p = strchr (p, '\0') + 1;
4825 /* Do not free the contents, as we used them creating the regex. */
4827 /* Do not include this section in the link. */
4828 bfd_set_section_flags (is->the_bfd, sec,
4829 bfd_get_section_flags (is->the_bfd, sec) | SEC_EXCLUDE);
4832 lreg = lang_new_vers_regex (NULL, "*", NULL);
4833 lang_register_vers_node (command_line.version_exports_section,
4834 lang_new_vers_node (greg, lreg), NULL);