1 /* Linker command language support.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 Free Software Foundation, Inc.
6 This file is part of GLD, the Gnu Linker.
8 GLD is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GLD is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GLD; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
25 #include "libiberty.h"
26 #include "safe-ctype.h"
44 static lang_statement_union_type *new_statement
45 PARAMS ((enum statement_enum, size_t, lang_statement_list_type *));
48 static struct obstack stat_obstack;
50 #define obstack_chunk_alloc xmalloc
51 #define obstack_chunk_free free
52 static const char *startup_file;
53 static lang_statement_list_type input_file_chain;
54 static boolean placed_commons = false;
55 static lang_output_section_statement_type *default_common_section;
56 static boolean map_option_f;
57 static bfd_vma print_dot;
58 static lang_input_statement_type *first_file;
59 static const char *current_target;
60 static const char *output_target;
61 static lang_statement_list_type statement_list;
62 static struct lang_phdr *lang_phdr_list;
64 static void lang_for_each_statement_worker
65 PARAMS ((void (*) (lang_statement_union_type *),
66 lang_statement_union_type *));
67 static lang_input_statement_type *new_afile
68 PARAMS ((const char *, lang_input_file_enum_type, const char *, boolean));
69 static lang_memory_region_type *lang_memory_default PARAMS ((asection *));
70 static void lang_map_flags PARAMS ((flagword));
71 static void init_os PARAMS ((lang_output_section_statement_type *));
72 static void exp_init_os PARAMS ((etree_type *));
73 static void section_already_linked PARAMS ((bfd *, asection *, PTR));
74 static struct bfd_hash_entry *already_linked_newfunc
75 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
76 static void already_linked_table_init PARAMS ((void));
77 static void already_linked_table_free PARAMS ((void));
78 static boolean wildcardp PARAMS ((const char *));
79 static lang_statement_union_type *wild_sort
80 PARAMS ((lang_wild_statement_type *, struct wildcard_list *,
81 lang_input_statement_type *, asection *));
82 static void output_section_callback
83 PARAMS ((lang_wild_statement_type *, struct wildcard_list *, asection *,
84 lang_input_statement_type *, PTR));
85 static lang_input_statement_type *lookup_name PARAMS ((const char *));
86 static boolean load_symbols
87 PARAMS ((lang_input_statement_type *, lang_statement_list_type *));
89 PARAMS ((lang_wild_statement_type *,
90 const char *, lang_output_section_statement_type *));
91 static bfd *open_output PARAMS ((const char *));
92 static void ldlang_open_output PARAMS ((lang_statement_union_type *));
93 static void open_input_bfds PARAMS ((lang_statement_union_type *, boolean));
94 static void lang_reasonable_defaults PARAMS ((void));
95 static void lang_place_undefineds PARAMS ((void));
96 static void map_input_to_output_sections
97 PARAMS ((lang_statement_union_type *, const char *,
98 lang_output_section_statement_type *));
99 static void print_output_section_statement
100 PARAMS ((lang_output_section_statement_type *));
101 static void print_assignment
102 PARAMS ((lang_assignment_statement_type *,
103 lang_output_section_statement_type *));
104 static void print_input_statement PARAMS ((lang_input_statement_type *));
105 static boolean print_one_symbol PARAMS ((struct bfd_link_hash_entry *, PTR));
106 static void print_input_section PARAMS ((lang_input_section_type *));
107 static void print_fill_statement PARAMS ((lang_fill_statement_type *));
108 static void print_data_statement PARAMS ((lang_data_statement_type *));
109 static void print_address_statement PARAMS ((lang_address_statement_type *));
110 static void print_reloc_statement PARAMS ((lang_reloc_statement_type *));
111 static void print_padding_statement PARAMS ((lang_padding_statement_type *));
112 static void print_wild_statement
113 PARAMS ((lang_wild_statement_type *, lang_output_section_statement_type *));
114 static void print_group
115 PARAMS ((lang_group_statement_type *, lang_output_section_statement_type *));
116 static void print_statement
117 PARAMS ((lang_statement_union_type *, lang_output_section_statement_type *));
118 static void print_statement_list
119 PARAMS ((lang_statement_union_type *, lang_output_section_statement_type *));
120 static void print_statements PARAMS ((void));
121 static void insert_pad
122 PARAMS ((lang_statement_union_type **, fill_type *,
123 unsigned int, asection *, bfd_vma));
124 static bfd_vma size_input_section
125 PARAMS ((lang_statement_union_type **, lang_output_section_statement_type *,
126 fill_type *, bfd_vma));
127 static void lang_finish PARAMS ((void));
128 static void ignore_bfd_errors PARAMS ((const char *, ...));
129 static void lang_check PARAMS ((void));
130 static void lang_common PARAMS ((void));
131 static boolean lang_one_common PARAMS ((struct bfd_link_hash_entry *, PTR));
132 static void lang_place_orphans PARAMS ((void));
133 static int topower PARAMS ((int));
134 static void lang_set_startof PARAMS ((void));
135 static void gc_section_callback
136 PARAMS ((lang_wild_statement_type *, struct wildcard_list *, asection *,
137 lang_input_statement_type *, PTR));
138 static void lang_record_phdrs PARAMS ((void));
139 static void lang_gc_wild PARAMS ((lang_wild_statement_type *));
140 static void lang_gc_sections_1 PARAMS ((lang_statement_union_type *));
141 static void lang_gc_sections PARAMS ((void));
142 static int lang_vers_match_lang_c
143 PARAMS ((struct bfd_elf_version_expr *, const char *));
144 static int lang_vers_match_lang_cplusplus
145 PARAMS ((struct bfd_elf_version_expr *, const char *));
146 static int lang_vers_match_lang_java
147 PARAMS ((struct bfd_elf_version_expr *, const char *));
148 static void lang_do_version_exports_section PARAMS ((void));
149 static void lang_check_section_addresses PARAMS ((void));
150 static void os_region_check
151 PARAMS ((lang_output_section_statement_type *,
152 struct memory_region_struct *, etree_type *, bfd_vma));
153 static bfd_vma lang_size_sections_1
154 PARAMS ((lang_statement_union_type *, lang_output_section_statement_type *,
155 lang_statement_union_type **, fill_type *, bfd_vma, boolean *));
157 typedef void (*callback_t) PARAMS ((lang_wild_statement_type *,
158 struct wildcard_list *,
160 lang_input_statement_type *,
162 static void walk_wild
163 PARAMS ((lang_wild_statement_type *, callback_t, PTR));
164 static void walk_wild_section
165 PARAMS ((lang_wild_statement_type *, lang_input_statement_type *,
167 static void walk_wild_file
168 PARAMS ((lang_wild_statement_type *, lang_input_statement_type *,
171 static int get_target PARAMS ((const bfd_target *, PTR));
172 static void stricpy PARAMS ((char *, char *));
173 static void strcut PARAMS ((char *, char *));
174 static int name_compare PARAMS ((char *, char *));
175 static int closest_target_match PARAMS ((const bfd_target *, PTR));
176 static char * get_first_input_target PARAMS ((void));
179 lang_output_section_statement_type *abs_output_section;
180 lang_statement_list_type lang_output_section_statement;
181 lang_statement_list_type *stat_ptr = &statement_list;
182 lang_statement_list_type file_chain = { NULL, NULL };
183 const char *entry_symbol = NULL;
184 const char *entry_section = ".text";
185 boolean entry_from_cmdline;
186 boolean lang_has_input_file = false;
187 boolean had_output_filename = false;
188 boolean lang_float_flag = false;
189 boolean delete_output_file_on_failure = false;
190 struct lang_nocrossrefs *nocrossref_list;
191 struct unique_sections *unique_section_list;
193 etree_type *base; /* Relocation base - or null */
195 #if defined (__STDC__) || defined (ALMOST_STDC)
196 #define cat(a,b) a##b
198 #define cat(a,b) a/**/b
201 /* Don't beautify the line below with "innocent" whitespace, it breaks
202 the K&R C preprocessor! */
203 #define new_stat(x, y) \
204 (cat (x,_type)*) new_statement (cat (x,_enum), sizeof (cat (x,_type)), y)
206 #define outside_section_address(q) \
207 ((q)->output_offset + (q)->output_section->vma)
209 #define outside_symbol_address(q) \
210 ((q)->value + outside_section_address (q->section))
212 #define SECTION_NAME_MAP_LENGTH (16)
218 return obstack_alloc (&stat_obstack, size);
222 unique_section_p (secnam)
225 struct unique_sections *unam;
227 for (unam = unique_section_list; unam; unam = unam->next)
228 if (wildcardp (unam->name)
229 ? fnmatch (unam->name, secnam, 0) == 0
230 : strcmp (unam->name, secnam) == 0)
238 /* Generic traversal routines for finding matching sections. */
241 walk_wild_section (ptr, file, callback, data)
242 lang_wild_statement_type *ptr;
243 lang_input_statement_type *file;
249 if (file->just_syms_flag)
252 for (s = file->the_bfd->sections; s != NULL; s = s->next)
254 struct wildcard_list *sec;
256 sec = ptr->section_list;
258 (*callback) (ptr, sec, s, file, data);
262 boolean skip = false;
263 struct name_list *list_tmp;
265 /* Don't process sections from files which were
267 for (list_tmp = sec->spec.exclude_name_list;
269 list_tmp = list_tmp->next)
271 if (wildcardp (list_tmp->name))
272 skip = fnmatch (list_tmp->name, file->filename, 0) == 0;
274 skip = strcmp (list_tmp->name, file->filename) == 0;
276 /* If this file is part of an archive, and the archive is
277 excluded, exclude this file. */
278 if (! skip && file->the_bfd != NULL
279 && file->the_bfd->my_archive != NULL
280 && file->the_bfd->my_archive->filename != NULL)
282 if (wildcardp (list_tmp->name))
283 skip = fnmatch (list_tmp->name,
284 file->the_bfd->my_archive->filename,
287 skip = strcmp (list_tmp->name,
288 file->the_bfd->my_archive->filename) == 0;
295 if (!skip && sec->spec.name != NULL)
297 const char *sname = bfd_get_section_name (file->the_bfd, s);
299 if (wildcardp (sec->spec.name))
300 skip = fnmatch (sec->spec.name, sname, 0) != 0;
302 skip = strcmp (sec->spec.name, sname) != 0;
306 (*callback) (ptr, sec, s, file, data);
313 /* Handle a wild statement for a single file F. */
316 walk_wild_file (s, f, callback, data)
317 lang_wild_statement_type *s;
318 lang_input_statement_type *f;
322 if (f->the_bfd == NULL
323 || ! bfd_check_format (f->the_bfd, bfd_archive))
324 walk_wild_section (s, f, callback, data);
329 /* This is an archive file. We must map each member of the
330 archive separately. */
331 member = bfd_openr_next_archived_file (f->the_bfd, (bfd *) NULL);
332 while (member != NULL)
334 /* When lookup_name is called, it will call the add_symbols
335 entry point for the archive. For each element of the
336 archive which is included, BFD will call ldlang_add_file,
337 which will set the usrdata field of the member to the
338 lang_input_statement. */
339 if (member->usrdata != NULL)
341 walk_wild_section (s,
342 (lang_input_statement_type *) member->usrdata,
346 member = bfd_openr_next_archived_file (f->the_bfd, member);
352 walk_wild (s, callback, data)
353 lang_wild_statement_type *s;
357 const char *file_spec = s->filename;
359 if (file_spec == NULL)
361 /* Perform the iteration over all files in the list. */
362 LANG_FOR_EACH_INPUT_STATEMENT (f)
364 walk_wild_file (s, f, callback, data);
367 else if (wildcardp (file_spec))
369 LANG_FOR_EACH_INPUT_STATEMENT (f)
371 if (fnmatch (file_spec, f->filename, FNM_FILE_NAME) == 0)
372 walk_wild_file (s, f, callback, data);
377 lang_input_statement_type *f;
379 /* Perform the iteration over a single file. */
380 f = lookup_name (file_spec);
382 walk_wild_file (s, f, callback, data);
386 /* lang_for_each_statement walks the parse tree and calls the provided
387 function for each node. */
390 lang_for_each_statement_worker (func, s)
391 void (*func) PARAMS ((lang_statement_union_type *));
392 lang_statement_union_type *s;
394 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
398 switch (s->header.type)
400 case lang_constructors_statement_enum:
401 lang_for_each_statement_worker (func, constructor_list.head);
403 case lang_output_section_statement_enum:
404 lang_for_each_statement_worker
406 s->output_section_statement.children.head);
408 case lang_wild_statement_enum:
409 lang_for_each_statement_worker
411 s->wild_statement.children.head);
413 case lang_group_statement_enum:
414 lang_for_each_statement_worker (func,
415 s->group_statement.children.head);
417 case lang_data_statement_enum:
418 case lang_reloc_statement_enum:
419 case lang_object_symbols_statement_enum:
420 case lang_output_statement_enum:
421 case lang_target_statement_enum:
422 case lang_input_section_enum:
423 case lang_input_statement_enum:
424 case lang_assignment_statement_enum:
425 case lang_padding_statement_enum:
426 case lang_address_statement_enum:
427 case lang_fill_statement_enum:
437 lang_for_each_statement (func)
438 void (*func) PARAMS ((lang_statement_union_type *));
440 lang_for_each_statement_worker (func, statement_list.head);
443 /*----------------------------------------------------------------------*/
446 lang_list_init (list)
447 lang_statement_list_type *list;
449 list->head = (lang_statement_union_type *) NULL;
450 list->tail = &list->head;
453 /* Build a new statement node for the parse tree. */
455 static lang_statement_union_type *
456 new_statement (type, size, list)
457 enum statement_enum type;
459 lang_statement_list_type *list;
461 lang_statement_union_type *new = (lang_statement_union_type *)
464 new->header.type = type;
465 new->header.next = (lang_statement_union_type *) NULL;
466 lang_statement_append (list, new, &new->header.next);
470 /* Build a new input file node for the language. There are several
471 ways in which we treat an input file, eg, we only look at symbols,
472 or prefix it with a -l etc.
474 We can be supplied with requests for input files more than once;
475 they may, for example be split over serveral lines like foo.o(.text)
476 foo.o(.data) etc, so when asked for a file we check that we haven't
477 got it already so we don't duplicate the bfd. */
479 static lang_input_statement_type *
480 new_afile (name, file_type, target, add_to_list)
482 lang_input_file_enum_type file_type;
486 lang_input_statement_type *p;
489 p = new_stat (lang_input_statement, stat_ptr);
492 p = ((lang_input_statement_type *)
493 stat_alloc (sizeof (lang_input_statement_type)));
494 p->header.next = NULL;
497 lang_has_input_file = true;
501 case lang_input_file_is_symbols_only_enum:
503 p->is_archive = false;
505 p->local_sym_name = name;
506 p->just_syms_flag = true;
507 p->search_dirs_flag = false;
509 case lang_input_file_is_fake_enum:
511 p->is_archive = false;
513 p->local_sym_name = name;
514 p->just_syms_flag = false;
515 p->search_dirs_flag = false;
517 case lang_input_file_is_l_enum:
518 p->is_archive = true;
521 p->local_sym_name = concat ("-l", name, (const char *) NULL);
522 p->just_syms_flag = false;
523 p->search_dirs_flag = true;
525 case lang_input_file_is_marker_enum:
527 p->is_archive = false;
529 p->local_sym_name = name;
530 p->just_syms_flag = false;
531 p->search_dirs_flag = true;
533 case lang_input_file_is_search_file_enum:
535 p->is_archive = false;
537 p->local_sym_name = name;
538 p->just_syms_flag = false;
539 p->search_dirs_flag = true;
541 case lang_input_file_is_file_enum:
543 p->is_archive = false;
545 p->local_sym_name = name;
546 p->just_syms_flag = false;
547 p->search_dirs_flag = false;
552 p->the_bfd = (bfd *) NULL;
553 p->asymbols = (asymbol **) NULL;
554 p->next_real_file = (lang_statement_union_type *) NULL;
555 p->next = (lang_statement_union_type *) NULL;
557 p->dynamic = config.dynamic_link;
558 p->whole_archive = whole_archive;
560 lang_statement_append (&input_file_chain,
561 (lang_statement_union_type *) p,
566 lang_input_statement_type *
567 lang_add_input_file (name, file_type, target)
569 lang_input_file_enum_type file_type;
572 lang_has_input_file = true;
573 return new_afile (name, file_type, target, true);
576 /* Build enough state so that the parser can build its tree. */
581 obstack_begin (&stat_obstack, 1000);
583 stat_ptr = &statement_list;
585 lang_list_init (stat_ptr);
587 lang_list_init (&input_file_chain);
588 lang_list_init (&lang_output_section_statement);
589 lang_list_init (&file_chain);
590 first_file = lang_add_input_file ((char *) NULL,
591 lang_input_file_is_marker_enum,
594 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME);
596 abs_output_section->bfd_section = bfd_abs_section_ptr;
600 /*----------------------------------------------------------------------
601 A region is an area of memory declared with the
602 MEMORY { name:org=exp, len=exp ... }
605 We maintain a list of all the regions here.
607 If no regions are specified in the script, then the default is used
608 which is created when looked up to be the entire data space. */
610 static lang_memory_region_type *lang_memory_region_list;
611 static lang_memory_region_type **lang_memory_region_list_tail = &lang_memory_region_list;
613 lang_memory_region_type *
614 lang_memory_region_lookup (name)
615 const char *const name;
617 lang_memory_region_type *p;
619 for (p = lang_memory_region_list;
620 p != (lang_memory_region_type *) NULL;
623 if (strcmp (p->name, name) == 0)
630 /* This code used to always use the first region in the list as the
631 default region. I changed it to instead use a region
632 encompassing all of memory as the default region. This permits
633 NOLOAD sections to work reasonably without requiring a region.
634 People should specify what region they mean, if they really want
636 if (strcmp (name, "*default*") == 0)
638 if (lang_memory_region_list != (lang_memory_region_type *) NULL)
640 return lang_memory_region_list;
646 lang_memory_region_type *new =
647 (lang_memory_region_type *) stat_alloc (sizeof (lang_memory_region_type));
649 new->name = xstrdup (name);
650 new->next = (lang_memory_region_type *) NULL;
652 *lang_memory_region_list_tail = new;
653 lang_memory_region_list_tail = &new->next;
657 new->length = ~(bfd_size_type) 0;
659 new->had_full_message = false;
665 static lang_memory_region_type *
666 lang_memory_default (section)
669 lang_memory_region_type *p;
671 flagword sec_flags = section->flags;
673 /* Override SEC_DATA to mean a writable section. */
674 if ((sec_flags & (SEC_ALLOC | SEC_READONLY | SEC_CODE)) == SEC_ALLOC)
675 sec_flags |= SEC_DATA;
677 for (p = lang_memory_region_list;
678 p != (lang_memory_region_type *) NULL;
681 if ((p->flags & sec_flags) != 0
682 && (p->not_flags & sec_flags) == 0)
687 return lang_memory_region_lookup ("*default*");
690 lang_output_section_statement_type *
691 lang_output_section_find (name)
692 const char *const name;
694 lang_statement_union_type *u;
695 lang_output_section_statement_type *lookup;
697 for (u = lang_output_section_statement.head;
698 u != (lang_statement_union_type *) NULL;
701 lookup = &u->output_section_statement;
702 if (strcmp (name, lookup->name) == 0)
707 return (lang_output_section_statement_type *) NULL;
710 lang_output_section_statement_type *
711 lang_output_section_statement_lookup (name)
712 const char *const name;
714 lang_output_section_statement_type *lookup;
716 lookup = lang_output_section_find (name);
717 if (lookup == (lang_output_section_statement_type *) NULL)
720 lookup = (lang_output_section_statement_type *)
721 new_stat (lang_output_section_statement, stat_ptr);
722 lookup->region = (lang_memory_region_type *) NULL;
723 lookup->lma_region = (lang_memory_region_type *) NULL;
724 lookup->fill = (fill_type *) 0;
725 lookup->block_value = 1;
728 lookup->next = (lang_statement_union_type *) NULL;
729 lookup->bfd_section = (asection *) NULL;
730 lookup->processed = false;
731 lookup->sectype = normal_section;
732 lookup->addr_tree = (etree_type *) NULL;
733 lang_list_init (&lookup->children);
735 lookup->memspec = (const char *) NULL;
737 lookup->subsection_alignment = -1;
738 lookup->section_alignment = -1;
739 lookup->load_base = (union etree_union *) NULL;
740 lookup->phdrs = NULL;
742 lang_statement_append (&lang_output_section_statement,
743 (lang_statement_union_type *) lookup,
750 lang_map_flags (flag)
753 if (flag & SEC_ALLOC)
759 if (flag & SEC_READONLY)
772 lang_memory_region_type *m;
774 minfo (_("\nMemory Configuration\n\n"));
775 fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
776 _("Name"), _("Origin"), _("Length"), _("Attributes"));
778 for (m = lang_memory_region_list;
779 m != (lang_memory_region_type *) NULL;
785 fprintf (config.map_file, "%-16s ", m->name);
787 sprintf_vma (buf, m->origin);
788 minfo ("0x%s ", buf);
796 minfo ("0x%V", m->length);
797 if (m->flags || m->not_flags)
805 lang_map_flags (m->flags);
811 lang_map_flags (m->not_flags);
818 fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
823 /* Initialize an output section. */
827 lang_output_section_statement_type *s;
829 section_userdata_type *new;
831 if (s->bfd_section != NULL)
834 if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
835 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME);
837 new = ((section_userdata_type *)
838 stat_alloc (sizeof (section_userdata_type)));
840 s->bfd_section = bfd_get_section_by_name (output_bfd, s->name);
841 if (s->bfd_section == (asection *) NULL)
842 s->bfd_section = bfd_make_section (output_bfd, s->name);
843 if (s->bfd_section == (asection *) NULL)
845 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
846 output_bfd->xvec->name, s->name);
848 s->bfd_section->output_section = s->bfd_section;
850 /* We initialize an output sections output offset to minus its own
851 vma to allow us to output a section through itself. */
852 s->bfd_section->output_offset = 0;
853 get_userdata (s->bfd_section) = (PTR) new;
855 /* If there is a base address, make sure that any sections it might
856 mention are initialized. */
857 if (s->addr_tree != NULL)
858 exp_init_os (s->addr_tree);
861 /* Make sure that all output sections mentioned in an expression are
868 switch (exp->type.node_class)
871 exp_init_os (exp->assign.src);
875 exp_init_os (exp->binary.lhs);
876 exp_init_os (exp->binary.rhs);
880 exp_init_os (exp->trinary.cond);
881 exp_init_os (exp->trinary.lhs);
882 exp_init_os (exp->trinary.rhs);
886 exp_init_os (exp->unary.child);
890 switch (exp->type.node_code)
896 lang_output_section_statement_type *os;
898 os = lang_output_section_find (exp->name.name);
899 if (os != NULL && os->bfd_section == NULL)
910 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
911 once into the output. This routine checks each section, and
912 arrange to discard it if a section of the same name has already
913 been linked. If the section has COMDAT information, then it uses
914 that to decide whether the section should be included. This code
915 assumes that all relevant sections have the SEC_LINK_ONCE flag set;
916 that is, it does not depend solely upon the section name.
917 section_already_linked is called via bfd_map_over_sections. */
919 /* This is the shape of the elements inside the already_linked hash
920 table. It maps a name onto a list of already_linked elements with
921 the same name. It's possible to get more than one element in a
922 list if the COMDAT sections have different names. */
924 struct already_linked_hash_entry
926 struct bfd_hash_entry root;
927 struct already_linked *entry;
930 struct already_linked
932 struct already_linked *next;
936 /* The hash table. */
938 static struct bfd_hash_table already_linked_table;
941 section_already_linked (abfd, sec, data)
946 lang_input_statement_type *entry = (lang_input_statement_type *) data;
949 struct already_linked *l;
950 struct already_linked_hash_entry *already_linked_list;
952 /* If we are only reading symbols from this object, then we want to
953 discard all sections. */
954 if (entry->just_syms_flag)
956 sec->output_section = bfd_abs_section_ptr;
957 sec->output_offset = sec->vma;
961 flags = bfd_get_section_flags (abfd, sec);
963 if ((flags & SEC_LINK_ONCE) == 0)
966 /* FIXME: When doing a relocatable link, we may have trouble
967 copying relocations in other sections that refer to local symbols
968 in the section being discarded. Those relocations will have to
969 be converted somehow; as of this writing I'm not sure that any of
970 the backends handle that correctly.
972 It is tempting to instead not discard link once sections when
973 doing a relocatable link (technically, they should be discarded
974 whenever we are building constructors). However, that fails,
975 because the linker winds up combining all the link once sections
976 into a single large link once section, which defeats the purpose
977 of having link once sections in the first place.
979 Also, not merging link once sections in a relocatable link
980 causes trouble for MIPS ELF, which relies in link once semantics
981 to handle the .reginfo section correctly. */
983 name = bfd_get_section_name (abfd, sec);
985 already_linked_list =
986 ((struct already_linked_hash_entry *)
987 bfd_hash_lookup (&already_linked_table, name, true, false));
989 for (l = already_linked_list->entry; l != NULL; l = l->next)
991 if (sec->comdat == NULL
992 || l->sec->comdat == NULL
993 || strcmp (sec->comdat->name, l->sec->comdat->name) == 0)
995 /* The section has already been linked. See if we should
997 switch (flags & SEC_LINK_DUPLICATES)
1002 case SEC_LINK_DUPLICATES_DISCARD:
1005 case SEC_LINK_DUPLICATES_ONE_ONLY:
1006 if (sec->comdat == NULL)
1007 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
1010 einfo (_("%P: %B: warning: ignoring duplicate `%s' section symbol `%s'\n"),
1011 abfd, name, sec->comdat->name);
1014 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
1015 /* FIXME: We should really dig out the contents of both
1016 sections and memcmp them. The COFF/PE spec says that
1017 the Microsoft linker does not implement this
1018 correctly, so I'm not going to bother doing it
1021 case SEC_LINK_DUPLICATES_SAME_SIZE:
1022 if (bfd_section_size (abfd, sec)
1023 != bfd_section_size (l->sec->owner, l->sec))
1024 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
1029 /* Set the output_section field so that lang_add_section
1030 does not create a lang_input_section structure for this
1032 sec->output_section = bfd_abs_section_ptr;
1038 /* This is the first section with this name. Record it. Allocate
1039 the memory from the same obstack as the hash table is kept in. */
1041 l = ((struct already_linked *)
1042 bfd_hash_allocate (&already_linked_table, sizeof *l));
1045 l->next = already_linked_list->entry;
1046 already_linked_list->entry = l;
1049 /* Support routines for the hash table used by section_already_linked,
1050 initialize the table, fill in an entry and remove the table. */
1052 static struct bfd_hash_entry *
1053 already_linked_newfunc (entry, table, string)
1054 struct bfd_hash_entry *entry ATTRIBUTE_UNUSED;
1055 struct bfd_hash_table *table;
1056 const char *string ATTRIBUTE_UNUSED;
1058 struct already_linked_hash_entry *ret =
1059 bfd_hash_allocate (table, sizeof (struct already_linked_hash_entry));
1063 return (struct bfd_hash_entry *) ret;
1067 already_linked_table_init ()
1069 if (! bfd_hash_table_init_n (&already_linked_table,
1070 already_linked_newfunc,
1072 einfo (_("%P%F: Failed to create hash table\n"));
1076 already_linked_table_free ()
1078 bfd_hash_table_free (&already_linked_table);
1081 /* The wild routines.
1083 These expand statements like *(.text) and foo.o to a list of
1084 explicit actions, like foo.o(.text), bar.o(.text) and
1085 foo.o(.text, .data). */
1087 /* Return true if the PATTERN argument is a wildcard pattern.
1088 Although backslashes are treated specially if a pattern contains
1089 wildcards, we do not consider the mere presence of a backslash to
1090 be enough to cause the pattern to be treated as a wildcard.
1091 That lets us handle DOS filenames more naturally. */
1095 const char *pattern;
1099 for (s = pattern; *s != '\0'; ++s)
1107 /* Add SECTION to the output section OUTPUT. Do this by creating a
1108 lang_input_section statement which is placed at PTR. FILE is the
1109 input file which holds SECTION. */
1112 lang_add_section (ptr, section, output, file)
1113 lang_statement_list_type *ptr;
1115 lang_output_section_statement_type *output;
1116 lang_input_statement_type *file;
1121 flags = bfd_get_section_flags (section->owner, section);
1125 /* If we are doing a final link, discard sections marked with
1127 if (! link_info.relocateable
1128 && (flags & SEC_EXCLUDE) != 0)
1131 /* Discard input sections which are assigned to a section named
1132 DISCARD_SECTION_NAME. */
1133 if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
1136 /* Discard debugging sections if we are stripping debugging
1138 if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
1139 && (flags & SEC_DEBUGGING) != 0)
1144 if (section->output_section == NULL)
1146 /* This prevents future calls from assigning this section. */
1147 section->output_section = bfd_abs_section_ptr;
1152 if (section->output_section == NULL)
1155 lang_input_section_type *new;
1158 if (output->bfd_section == NULL)
1161 first = ! output->bfd_section->linker_has_input;
1162 output->bfd_section->linker_has_input = 1;
1164 /* Add a section reference to the list. */
1165 new = new_stat (lang_input_section, ptr);
1167 new->section = section;
1169 section->output_section = output->bfd_section;
1171 flags = section->flags;
1173 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1174 to an output section, because we want to be able to include a
1175 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1176 section (I don't know why we want to do this, but we do).
1177 build_link_order in ldwrite.c handles this case by turning
1178 the embedded SEC_NEVER_LOAD section into a fill. */
1180 flags &= ~ SEC_NEVER_LOAD;
1182 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1183 already been processed. One reason to do this is that on pe
1184 format targets, .text$foo sections go into .text and it's odd
1185 to see .text with SEC_LINK_ONCE set. */
1187 if (! link_info.relocateable)
1188 flags &= ~ (SEC_LINK_ONCE | SEC_LINK_DUPLICATES);
1190 /* If this is not the first input section, and the SEC_READONLY
1191 flag is not currently set, then don't set it just because the
1192 input section has it set. */
1194 if (! first && (section->output_section->flags & SEC_READONLY) == 0)
1195 flags &= ~ SEC_READONLY;
1197 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
1199 && ((section->output_section->flags & (SEC_MERGE | SEC_STRINGS))
1200 != (flags & (SEC_MERGE | SEC_STRINGS))
1201 || ((flags & SEC_MERGE)
1202 && section->output_section->entsize != section->entsize)))
1204 section->output_section->flags &= ~ (SEC_MERGE | SEC_STRINGS);
1205 flags &= ~ (SEC_MERGE | SEC_STRINGS);
1208 section->output_section->flags |= flags;
1210 if (flags & SEC_MERGE)
1211 section->output_section->entsize = section->entsize;
1213 /* If SEC_READONLY is not set in the input section, then clear
1214 it from the output section. */
1215 if ((section->flags & SEC_READONLY) == 0)
1216 section->output_section->flags &= ~SEC_READONLY;
1218 switch (output->sectype)
1220 case normal_section:
1225 case overlay_section:
1226 output->bfd_section->flags &= ~SEC_ALLOC;
1228 case noload_section:
1229 output->bfd_section->flags &= ~SEC_LOAD;
1230 output->bfd_section->flags |= SEC_NEVER_LOAD;
1234 /* Copy over SEC_SMALL_DATA. */
1235 if (section->flags & SEC_SMALL_DATA)
1236 section->output_section->flags |= SEC_SMALL_DATA;
1238 if (section->alignment_power > output->bfd_section->alignment_power)
1239 output->bfd_section->alignment_power = section->alignment_power;
1241 /* If supplied an aligment, then force it. */
1242 if (output->section_alignment != -1)
1243 output->bfd_section->alignment_power = output->section_alignment;
1245 if (section->flags & SEC_BLOCK)
1247 section->output_section->flags |= SEC_BLOCK;
1248 /* FIXME: This value should really be obtained from the bfd... */
1249 output->block_value = 128;
1254 /* Handle wildcard sorting. This returns the lang_input_section which
1255 should follow the one we are going to create for SECTION and FILE,
1256 based on the sorting requirements of WILD. It returns NULL if the
1257 new section should just go at the end of the current list. */
1259 static lang_statement_union_type *
1260 wild_sort (wild, sec, file, section)
1261 lang_wild_statement_type *wild;
1262 struct wildcard_list *sec;
1263 lang_input_statement_type *file;
1266 const char *section_name;
1267 lang_statement_union_type *l;
1269 if (!wild->filenames_sorted && (sec == NULL || !sec->spec.sorted))
1272 section_name = bfd_get_section_name (file->the_bfd, section);
1273 for (l = wild->children.head; l != NULL; l = l->header.next)
1275 lang_input_section_type *ls;
1277 if (l->header.type != lang_input_section_enum)
1279 ls = &l->input_section;
1281 /* Sorting by filename takes precedence over sorting by section
1284 if (wild->filenames_sorted)
1286 const char *fn, *ln;
1290 /* The PE support for the .idata section as generated by
1291 dlltool assumes that files will be sorted by the name of
1292 the archive and then the name of the file within the
1295 if (file->the_bfd != NULL
1296 && bfd_my_archive (file->the_bfd) != NULL)
1298 fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
1303 fn = file->filename;
1307 if (ls->ifile->the_bfd != NULL
1308 && bfd_my_archive (ls->ifile->the_bfd) != NULL)
1310 ln = bfd_get_filename (bfd_my_archive (ls->ifile->the_bfd));
1315 ln = ls->ifile->filename;
1319 i = strcmp (fn, ln);
1328 fn = file->filename;
1330 ln = ls->ifile->filename;
1332 i = strcmp (fn, ln);
1340 /* Here either the files are not sorted by name, or we are
1341 looking at the sections for this file. */
1343 if (sec != NULL && sec->spec.sorted)
1345 if (strcmp (section_name,
1346 bfd_get_section_name (ls->ifile->the_bfd,
1356 /* Expand a wild statement for a particular FILE. SECTION may be
1357 NULL, in which case it is a wild card. */
1360 output_section_callback (ptr, sec, section, file, output)
1361 lang_wild_statement_type *ptr;
1362 struct wildcard_list *sec;
1364 lang_input_statement_type *file;
1367 lang_statement_union_type *before;
1369 /* Exclude sections that match UNIQUE_SECTION_LIST. */
1370 if (unique_section_p (bfd_get_section_name (file->the_bfd, section)))
1373 /* If the wild pattern was marked KEEP, the member sections
1374 should be as well. */
1375 if (ptr->keep_sections)
1376 section->flags |= SEC_KEEP;
1378 before = wild_sort (ptr, sec, file, section);
1380 /* Here BEFORE points to the lang_input_section which
1381 should follow the one we are about to add. If BEFORE
1382 is NULL, then the section should just go at the end
1383 of the current list. */
1386 lang_add_section (&ptr->children, section,
1387 (lang_output_section_statement_type *) output,
1391 lang_statement_list_type list;
1392 lang_statement_union_type **pp;
1394 lang_list_init (&list);
1395 lang_add_section (&list, section,
1396 (lang_output_section_statement_type *) output,
1399 /* If we are discarding the section, LIST.HEAD will
1401 if (list.head != NULL)
1403 ASSERT (list.head->header.next == NULL);
1405 for (pp = &ptr->children.head;
1407 pp = &(*pp)->header.next)
1408 ASSERT (*pp != NULL);
1410 list.head->header.next = *pp;
1416 /* This is passed a file name which must have been seen already and
1417 added to the statement tree. We will see if it has been opened
1418 already and had its symbols read. If not then we'll read it. */
1420 static lang_input_statement_type *
1424 lang_input_statement_type *search;
1426 for (search = (lang_input_statement_type *) input_file_chain.head;
1427 search != (lang_input_statement_type *) NULL;
1428 search = (lang_input_statement_type *) search->next_real_file)
1430 if (search->filename == (char *) NULL && name == (char *) NULL)
1432 if (search->filename != (char *) NULL
1433 && name != (char *) NULL
1434 && strcmp (search->filename, name) == 0)
1438 if (search == (lang_input_statement_type *) NULL)
1439 search = new_afile (name, lang_input_file_is_file_enum, default_target,
1442 /* If we have already added this file, or this file is not real
1443 (FIXME: can that ever actually happen?) or the name is NULL
1444 (FIXME: can that ever actually happen?) don't add this file. */
1447 || search->filename == (const char *) NULL)
1450 if (! load_symbols (search, (lang_statement_list_type *) NULL))
1456 /* Get the symbols for an input file. */
1459 load_symbols (entry, place)
1460 lang_input_statement_type *entry;
1461 lang_statement_list_type *place;
1468 ldfile_open_file (entry);
1470 if (! bfd_check_format (entry->the_bfd, bfd_archive)
1471 && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
1474 lang_statement_list_type *hold;
1475 boolean bad_load = true;
1477 err = bfd_get_error ();
1479 /* See if the emulation has some special knowledge. */
1480 if (ldemul_unrecognized_file (entry))
1483 if (err == bfd_error_file_ambiguously_recognized)
1487 einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
1488 einfo (_("%B: matching formats:"), entry->the_bfd);
1489 for (p = matching; *p != NULL; p++)
1493 else if (err != bfd_error_file_not_recognized
1495 einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
1499 bfd_close (entry->the_bfd);
1500 entry->the_bfd = NULL;
1502 /* Try to interpret the file as a linker script. */
1503 ldfile_open_command_file (entry->filename);
1508 ldfile_assumed_script = true;
1509 parser_input = input_script;
1511 ldfile_assumed_script = false;
1518 if (ldemul_recognized_file (entry))
1521 /* We don't call ldlang_add_file for an archive. Instead, the
1522 add_symbols entry point will call ldlang_add_file, via the
1523 add_archive_element callback, for each element of the archive
1525 switch (bfd_get_format (entry->the_bfd))
1531 ldlang_add_file (entry);
1532 if (trace_files || trace_file_tries)
1533 info_msg ("%I\n", entry);
1537 if (entry->whole_archive)
1539 bfd * member = NULL;
1540 boolean loaded = true;
1544 member = bfd_openr_next_archived_file (entry->the_bfd, member);
1549 if (! bfd_check_format (member, bfd_object))
1551 einfo (_("%F%B: member %B in archive is not an object\n"),
1552 entry->the_bfd, member);
1556 if (! ((*link_info.callbacks->add_archive_element)
1557 (&link_info, member, "--whole-archive")))
1560 if (! bfd_link_add_symbols (member, &link_info))
1562 einfo (_("%F%B: could not read symbols: %E\n"), member);
1567 entry->loaded = loaded;
1573 if (bfd_link_add_symbols (entry->the_bfd, &link_info))
1574 entry->loaded = true;
1576 einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
1578 return entry->loaded;
1581 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
1582 may be NULL, indicating that it is a wildcard. Separate
1583 lang_input_section statements are created for each part of the
1584 expansion; they are added after the wild statement S. OUTPUT is
1585 the output section. */
1588 wild (s, target, output)
1589 lang_wild_statement_type *s;
1590 const char *target ATTRIBUTE_UNUSED;
1591 lang_output_section_statement_type *output;
1593 struct wildcard_list *sec;
1595 walk_wild (s, output_section_callback, (PTR) output);
1597 for (sec = s->section_list; sec != NULL; sec = sec->next)
1599 if (default_common_section != NULL)
1601 if (sec->spec.name != NULL && strcmp (sec->spec.name, "COMMON") == 0)
1603 /* Remember the section that common is going to in case we
1604 later get something which doesn't know where to put it. */
1605 default_common_section = output;
1610 /* Return true iff target is the sought target. */
1613 get_target (target, data)
1614 const bfd_target *target;
1617 const char *sought = (const char *) data;
1619 return strcmp (target->name, sought) == 0;
1622 /* Like strcpy() but convert to lower case as well. */
1631 while ((c = *src++) != 0)
1632 *dest++ = TOLOWER (c);
1637 /* Remove the first occurance of needle (if any) in haystack
1641 strcut (haystack, needle)
1645 haystack = strstr (haystack, needle);
1651 for (src = haystack + strlen (needle); *src;)
1652 *haystack++ = *src++;
1658 /* Compare two target format name strings.
1659 Return a value indicating how "similar" they are. */
1662 name_compare (first, second)
1670 copy1 = xmalloc (strlen (first) + 1);
1671 copy2 = xmalloc (strlen (second) + 1);
1673 /* Convert the names to lower case. */
1674 stricpy (copy1, first);
1675 stricpy (copy2, second);
1677 /* Remove and endian strings from the name. */
1678 strcut (copy1, "big");
1679 strcut (copy1, "little");
1680 strcut (copy2, "big");
1681 strcut (copy2, "little");
1683 /* Return a value based on how many characters match,
1684 starting from the beginning. If both strings are
1685 the same then return 10 * their length. */
1686 for (result = 0; copy1[result] == copy2[result]; result++)
1687 if (copy1[result] == 0)
1699 /* Set by closest_target_match() below. */
1700 static const bfd_target *winner;
1702 /* Scan all the valid bfd targets looking for one that has the endianness
1703 requirement that was specified on the command line, and is the nearest
1704 match to the original output target. */
1707 closest_target_match (target, data)
1708 const bfd_target *target;
1711 const bfd_target *original = (const bfd_target *) data;
1713 if (command_line.endian == ENDIAN_BIG
1714 && target->byteorder != BFD_ENDIAN_BIG)
1717 if (command_line.endian == ENDIAN_LITTLE
1718 && target->byteorder != BFD_ENDIAN_LITTLE)
1721 /* Must be the same flavour. */
1722 if (target->flavour != original->flavour)
1725 /* If we have not found a potential winner yet, then record this one. */
1732 /* Oh dear, we now have two potential candidates for a successful match.
1733 Compare their names and choose the better one. */
1734 if (name_compare (target->name, original->name)
1735 > name_compare (winner->name, original->name))
1738 /* Keep on searching until wqe have checked them all. */
1742 /* Return the BFD target format of the first input file. */
1745 get_first_input_target ()
1747 char *target = NULL;
1749 LANG_FOR_EACH_INPUT_STATEMENT (s)
1751 if (s->header.type == lang_input_statement_enum
1754 ldfile_open_file (s);
1756 if (s->the_bfd != NULL
1757 && bfd_check_format (s->the_bfd, bfd_object))
1759 target = bfd_get_target (s->the_bfd);
1770 /* Open the output file. */
1778 /* Has the user told us which output format to use? */
1779 if (output_target == (char *) NULL)
1781 /* No - has the current target been set to something other than
1783 if (current_target != default_target)
1784 output_target = current_target;
1786 /* No - can we determine the format of the first input file? */
1789 output_target = get_first_input_target ();
1791 /* Failed - use the default output target. */
1792 if (output_target == NULL)
1793 output_target = default_target;
1797 /* Has the user requested a particular endianness on the command
1799 if (command_line.endian != ENDIAN_UNSET)
1801 const bfd_target *target;
1802 enum bfd_endian desired_endian;
1804 /* Get the chosen target. */
1805 target = bfd_search_for_target (get_target, (PTR) output_target);
1807 /* If the target is not supported, we cannot do anything. */
1810 if (command_line.endian == ENDIAN_BIG)
1811 desired_endian = BFD_ENDIAN_BIG;
1813 desired_endian = BFD_ENDIAN_LITTLE;
1815 /* See if the target has the wrong endianness. This should
1816 not happen if the linker script has provided big and
1817 little endian alternatives, but some scrips don't do
1819 if (target->byteorder != desired_endian)
1821 /* If it does, then see if the target provides
1822 an alternative with the correct endianness. */
1823 if (target->alternative_target != NULL
1824 && (target->alternative_target->byteorder == desired_endian))
1825 output_target = target->alternative_target->name;
1828 /* Try to find a target as similar as possible to
1829 the default target, but which has the desired
1830 endian characteristic. */
1831 (void) bfd_search_for_target (closest_target_match,
1834 /* Oh dear - we could not find any targets that
1835 satisfy our requirements. */
1837 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1839 output_target = winner->name;
1845 output = bfd_openw (name, output_target);
1847 if (output == (bfd *) NULL)
1849 if (bfd_get_error () == bfd_error_invalid_target)
1850 einfo (_("%P%F: target %s not found\n"), output_target);
1852 einfo (_("%P%F: cannot open output file %s: %E\n"), name);
1855 delete_output_file_on_failure = true;
1858 output->flags |= D_PAGED;
1861 if (! bfd_set_format (output, bfd_object))
1862 einfo (_("%P%F:%s: can not make object file: %E\n"), name);
1863 if (! bfd_set_arch_mach (output,
1864 ldfile_output_architecture,
1865 ldfile_output_machine))
1866 einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
1868 link_info.hash = bfd_link_hash_table_create (output);
1869 if (link_info.hash == (struct bfd_link_hash_table *) NULL)
1870 einfo (_("%P%F: can not create link hash table: %E\n"));
1872 bfd_set_gp_size (output, g_switch_value);
1877 ldlang_open_output (statement)
1878 lang_statement_union_type *statement;
1880 switch (statement->header.type)
1882 case lang_output_statement_enum:
1883 ASSERT (output_bfd == (bfd *) NULL);
1884 output_bfd = open_output (statement->output_statement.name);
1885 ldemul_set_output_arch ();
1886 if (config.magic_demand_paged && !link_info.relocateable)
1887 output_bfd->flags |= D_PAGED;
1889 output_bfd->flags &= ~D_PAGED;
1890 if (config.text_read_only)
1891 output_bfd->flags |= WP_TEXT;
1893 output_bfd->flags &= ~WP_TEXT;
1894 if (link_info.traditional_format)
1895 output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
1897 output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
1900 case lang_target_statement_enum:
1901 current_target = statement->target_statement.target;
1908 /* Open all the input files. */
1911 open_input_bfds (s, force)
1912 lang_statement_union_type *s;
1915 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
1917 switch (s->header.type)
1919 case lang_constructors_statement_enum:
1920 open_input_bfds (constructor_list.head, force);
1922 case lang_output_section_statement_enum:
1923 open_input_bfds (s->output_section_statement.children.head, force);
1925 case lang_wild_statement_enum:
1926 /* Maybe we should load the file's symbols. */
1927 if (s->wild_statement.filename
1928 && ! wildcardp (s->wild_statement.filename))
1929 (void) lookup_name (s->wild_statement.filename);
1930 open_input_bfds (s->wild_statement.children.head, force);
1932 case lang_group_statement_enum:
1934 struct bfd_link_hash_entry *undefs;
1936 /* We must continually search the entries in the group
1937 until no new symbols are added to the list of undefined
1942 undefs = link_info.hash->undefs_tail;
1943 open_input_bfds (s->group_statement.children.head, true);
1945 while (undefs != link_info.hash->undefs_tail);
1948 case lang_target_statement_enum:
1949 current_target = s->target_statement.target;
1951 case lang_input_statement_enum:
1952 if (s->input_statement.real)
1954 lang_statement_list_type add;
1956 s->input_statement.target = current_target;
1958 /* If we are being called from within a group, and this
1959 is an archive which has already been searched, then
1960 force it to be researched unless the whole archive
1961 has been loaded already. */
1963 && !s->input_statement.whole_archive
1964 && s->input_statement.loaded
1965 && bfd_check_format (s->input_statement.the_bfd,
1967 s->input_statement.loaded = false;
1969 lang_list_init (&add);
1971 if (! load_symbols (&s->input_statement, &add))
1972 config.make_executable = false;
1974 if (add.head != NULL)
1976 *add.tail = s->header.next;
1977 s->header.next = add.head;
1987 /* If there are [COMMONS] statements, put a wild one into the bss
1991 lang_reasonable_defaults ()
1994 lang_output_section_statement_lookup (".text");
1995 lang_output_section_statement_lookup (".data");
1997 default_common_section = lang_output_section_statement_lookup (".bss");
1999 if (placed_commons == false)
2001 lang_wild_statement_type *new =
2002 new_stat (lang_wild_statement,
2003 &default_common_section->children);
2005 new->section_name = "COMMON";
2006 new->filename = (char *) NULL;
2007 lang_list_init (&new->children);
2012 /* Add the supplied name to the symbol table as an undefined reference.
2013 Remove items from the chain as we open input bfds. */
2014 typedef struct ldlang_undef_chain_list
2016 struct ldlang_undef_chain_list *next;
2018 } ldlang_undef_chain_list_type;
2020 static ldlang_undef_chain_list_type *ldlang_undef_chain_list_head;
2023 ldlang_add_undef (name)
2024 const char *const name;
2026 ldlang_undef_chain_list_type *new =
2027 ((ldlang_undef_chain_list_type *)
2028 stat_alloc (sizeof (ldlang_undef_chain_list_type)));
2030 new->next = ldlang_undef_chain_list_head;
2031 ldlang_undef_chain_list_head = new;
2033 new->name = xstrdup (name);
2036 /* Run through the list of undefineds created above and place them
2037 into the linker hash table as undefined symbols belonging to the
2041 lang_place_undefineds ()
2043 ldlang_undef_chain_list_type *ptr;
2045 for (ptr = ldlang_undef_chain_list_head;
2046 ptr != (ldlang_undef_chain_list_type *) NULL;
2049 struct bfd_link_hash_entry *h;
2051 h = bfd_link_hash_lookup (link_info.hash, ptr->name, true, false, true);
2052 if (h == (struct bfd_link_hash_entry *) NULL)
2053 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2054 if (h->type == bfd_link_hash_new)
2056 h->type = bfd_link_hash_undefined;
2057 h->u.undef.abfd = NULL;
2058 bfd_link_add_undef (link_info.hash, h);
2063 /* Open input files and attatch to output sections. */
2066 map_input_to_output_sections (s, target, output_section_statement)
2067 lang_statement_union_type *s;
2069 lang_output_section_statement_type *output_section_statement;
2071 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
2073 switch (s->header.type)
2075 case lang_wild_statement_enum:
2076 wild (&s->wild_statement, target, output_section_statement);
2078 case lang_constructors_statement_enum:
2079 map_input_to_output_sections (constructor_list.head,
2081 output_section_statement);
2083 case lang_output_section_statement_enum:
2084 map_input_to_output_sections (s->output_section_statement.children.head,
2086 &s->output_section_statement);
2088 case lang_output_statement_enum:
2090 case lang_target_statement_enum:
2091 target = s->target_statement.target;
2093 case lang_group_statement_enum:
2094 map_input_to_output_sections (s->group_statement.children.head,
2096 output_section_statement);
2098 case lang_fill_statement_enum:
2099 case lang_input_section_enum:
2100 case lang_object_symbols_statement_enum:
2101 case lang_data_statement_enum:
2102 case lang_reloc_statement_enum:
2103 case lang_padding_statement_enum:
2104 case lang_input_statement_enum:
2105 if (output_section_statement != NULL
2106 && output_section_statement->bfd_section == NULL)
2107 init_os (output_section_statement);
2109 case lang_assignment_statement_enum:
2110 if (output_section_statement != NULL
2111 && output_section_statement->bfd_section == NULL)
2112 init_os (output_section_statement);
2114 /* Make sure that any sections mentioned in the assignment
2116 exp_init_os (s->assignment_statement.exp);
2118 case lang_afile_asection_pair_statement_enum:
2121 case lang_address_statement_enum:
2122 /* Mark the specified section with the supplied address. */
2124 lang_output_section_statement_type *os =
2125 lang_output_section_statement_lookup
2126 (s->address_statement.section_name);
2128 if (os->bfd_section == NULL)
2130 os->addr_tree = s->address_statement.address;
2138 print_output_section_statement (output_section_statement)
2139 lang_output_section_statement_type *output_section_statement;
2141 asection *section = output_section_statement->bfd_section;
2144 if (output_section_statement != abs_output_section)
2146 minfo ("\n%s", output_section_statement->name);
2148 if (section != NULL)
2150 print_dot = section->vma;
2152 len = strlen (output_section_statement->name);
2153 if (len >= SECTION_NAME_MAP_LENGTH - 1)
2158 while (len < SECTION_NAME_MAP_LENGTH)
2164 minfo ("0x%V %W", section->vma, section->_raw_size);
2166 if (output_section_statement->load_base != NULL)
2170 addr = exp_get_abs_int (output_section_statement->load_base, 0,
2171 "load base", lang_final_phase_enum);
2172 minfo (_(" load address 0x%V"), addr);
2179 print_statement_list (output_section_statement->children.head,
2180 output_section_statement);
2184 print_assignment (assignment, output_section)
2185 lang_assignment_statement_type *assignment;
2186 lang_output_section_statement_type *output_section;
2189 etree_value_type result;
2191 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2194 result = exp_fold_tree (assignment->exp->assign.src, output_section,
2195 lang_final_phase_enum, print_dot, &print_dot);
2197 minfo ("0x%V", result.value + result.section->bfd_section->vma);
2208 exp_print_tree (assignment->exp);
2214 print_input_statement (statm)
2215 lang_input_statement_type *statm;
2217 if (statm->filename != (char *) NULL)
2219 fprintf (config.map_file, "LOAD %s\n", statm->filename);
2223 /* Print all symbols defined in a particular section. This is called
2224 via bfd_link_hash_traverse. */
2227 print_one_symbol (hash_entry, ptr)
2228 struct bfd_link_hash_entry *hash_entry;
2231 asection *sec = (asection *) ptr;
2233 if ((hash_entry->type == bfd_link_hash_defined
2234 || hash_entry->type == bfd_link_hash_defweak)
2235 && sec == hash_entry->u.def.section)
2239 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2242 (hash_entry->u.def.value
2243 + hash_entry->u.def.section->output_offset
2244 + hash_entry->u.def.section->output_section->vma));
2246 minfo (" %T\n", hash_entry->root.string);
2252 /* Print information about an input section to the map file. */
2255 print_input_section (in)
2256 lang_input_section_type *in;
2258 asection *i = in->section;
2259 bfd_size_type size = i->_cooked_size != 0 ? i->_cooked_size : i->_raw_size;
2260 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2261 ldfile_output_machine);
2266 minfo ("%s", i->name);
2268 if (i->output_section != NULL)
2272 len = 1 + strlen (i->name);
2273 if (len >= SECTION_NAME_MAP_LENGTH - 1)
2278 while (len < SECTION_NAME_MAP_LENGTH)
2284 minfo ("0x%V %W %B\n",
2285 i->output_section->vma + i->output_offset, size / opb,
2288 if (i->_cooked_size != 0 && i->_cooked_size != i->_raw_size)
2290 len = SECTION_NAME_MAP_LENGTH + 3;
2302 minfo (_("%W (size before relaxing)\n"), i->_raw_size);
2305 bfd_link_hash_traverse (link_info.hash, print_one_symbol, (PTR) i);
2307 print_dot = i->output_section->vma + i->output_offset + size / opb;
2313 print_fill_statement (fill)
2314 lang_fill_statement_type *fill;
2318 fputs (" FILL mask 0x", config.map_file);
2319 for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--)
2320 fprintf (config.map_file, "%02x", *p);
2321 fputs ("\n", config.map_file);
2325 print_data_statement (data)
2326 lang_data_statement_type *data;
2332 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2333 ldfile_output_machine);
2335 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2338 addr = data->output_vma;
2339 if (data->output_section != NULL)
2340 addr += data->output_section->vma;
2368 minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
2370 if (data->exp->type.node_class != etree_value)
2373 exp_print_tree (data->exp);
2378 print_dot = addr + size / opb;
2382 /* Print an address statement. These are generated by options like
2386 print_address_statement (address)
2387 lang_address_statement_type *address;
2389 minfo (_("Address of section %s set to "), address->section_name);
2390 exp_print_tree (address->address);
2394 /* Print a reloc statement. */
2397 print_reloc_statement (reloc)
2398 lang_reloc_statement_type *reloc;
2403 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2404 ldfile_output_machine);
2406 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2409 addr = reloc->output_vma;
2410 if (reloc->output_section != NULL)
2411 addr += reloc->output_section->vma;
2413 size = bfd_get_reloc_size (reloc->howto);
2415 minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
2417 if (reloc->name != NULL)
2418 minfo ("%s+", reloc->name);
2420 minfo ("%s+", reloc->section->name);
2422 exp_print_tree (reloc->addend_exp);
2426 print_dot = addr + size / opb;
2430 print_padding_statement (s)
2431 lang_padding_statement_type *s;
2435 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2436 ldfile_output_machine);
2440 len = sizeof " *fill*" - 1;
2441 while (len < SECTION_NAME_MAP_LENGTH)
2447 addr = s->output_offset;
2448 if (s->output_section != NULL)
2449 addr += s->output_section->vma;
2450 minfo ("0x%V %W ", addr, s->size);
2452 if (s->fill->size != 0)
2456 for (p = s->fill->data, size = s->fill->size; size != 0; p++, size--)
2457 fprintf (config.map_file, "%02x", *p);
2462 print_dot = addr + s->size / opb;
2466 print_wild_statement (w, os)
2467 lang_wild_statement_type *w;
2468 lang_output_section_statement_type *os;
2470 struct wildcard_list *sec;
2474 if (w->filenames_sorted)
2476 if (w->filename != NULL)
2477 minfo ("%s", w->filename);
2480 if (w->filenames_sorted)
2484 for (sec = w->section_list; sec; sec = sec->next)
2486 if (sec->spec.sorted)
2488 if (sec->spec.exclude_name_list != NULL)
2491 minfo ("EXCLUDE_FILE ( %s", sec->spec.exclude_name_list->name);
2492 for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next)
2493 minfo (", %s", tmp->name);
2496 if (sec->spec.name != NULL)
2497 minfo ("%s", sec->spec.name);
2500 if (sec->spec.sorted)
2507 print_statement_list (w->children.head, os);
2510 /* Print a group statement. */
2514 lang_group_statement_type *s;
2515 lang_output_section_statement_type *os;
2517 fprintf (config.map_file, "START GROUP\n");
2518 print_statement_list (s->children.head, os);
2519 fprintf (config.map_file, "END GROUP\n");
2522 /* Print the list of statements in S.
2523 This can be called for any statement type. */
2526 print_statement_list (s, os)
2527 lang_statement_union_type *s;
2528 lang_output_section_statement_type *os;
2532 print_statement (s, os);
2537 /* Print the first statement in statement list S.
2538 This can be called for any statement type. */
2541 print_statement (s, os)
2542 lang_statement_union_type *s;
2543 lang_output_section_statement_type *os;
2545 switch (s->header.type)
2548 fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
2551 case lang_constructors_statement_enum:
2552 if (constructor_list.head != NULL)
2554 if (constructors_sorted)
2555 minfo (" SORT (CONSTRUCTORS)\n");
2557 minfo (" CONSTRUCTORS\n");
2558 print_statement_list (constructor_list.head, os);
2561 case lang_wild_statement_enum:
2562 print_wild_statement (&s->wild_statement, os);
2564 case lang_address_statement_enum:
2565 print_address_statement (&s->address_statement);
2567 case lang_object_symbols_statement_enum:
2568 minfo (" CREATE_OBJECT_SYMBOLS\n");
2570 case lang_fill_statement_enum:
2571 print_fill_statement (&s->fill_statement);
2573 case lang_data_statement_enum:
2574 print_data_statement (&s->data_statement);
2576 case lang_reloc_statement_enum:
2577 print_reloc_statement (&s->reloc_statement);
2579 case lang_input_section_enum:
2580 print_input_section (&s->input_section);
2582 case lang_padding_statement_enum:
2583 print_padding_statement (&s->padding_statement);
2585 case lang_output_section_statement_enum:
2586 print_output_section_statement (&s->output_section_statement);
2588 case lang_assignment_statement_enum:
2589 print_assignment (&s->assignment_statement, os);
2591 case lang_target_statement_enum:
2592 fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
2594 case lang_output_statement_enum:
2595 minfo ("OUTPUT(%s", s->output_statement.name);
2596 if (output_target != NULL)
2597 minfo (" %s", output_target);
2600 case lang_input_statement_enum:
2601 print_input_statement (&s->input_statement);
2603 case lang_group_statement_enum:
2604 print_group (&s->group_statement, os);
2606 case lang_afile_asection_pair_statement_enum:
2615 print_statement_list (statement_list.head, abs_output_section);
2618 /* Print the first N statements in statement list S to STDERR.
2619 If N == 0, nothing is printed.
2620 If N < 0, the entire list is printed.
2621 Intended to be called from GDB. */
2624 dprint_statement (s, n)
2625 lang_statement_union_type *s;
2628 FILE *map_save = config.map_file;
2630 config.map_file = stderr;
2633 print_statement_list (s, abs_output_section);
2636 while (s && --n >= 0)
2638 print_statement (s, abs_output_section);
2643 config.map_file = map_save;
2647 insert_pad (ptr, fill, alignment_needed, output_section, dot)
2648 lang_statement_union_type **ptr;
2650 unsigned int alignment_needed;
2651 asection *output_section;
2654 static fill_type zero_fill = { 1, { 0 } };
2655 lang_statement_union_type *pad;
2657 pad = ((lang_statement_union_type *)
2658 ((char *) ptr - offsetof (lang_statement_union_type, header.next)));
2659 if (ptr != &statement_list.head
2660 && pad->header.type == lang_padding_statement_enum
2661 && pad->padding_statement.output_section == output_section)
2663 /* Use the existing pad statement. The above test on output
2664 section is probably redundant, but it doesn't hurt to check. */
2668 /* Make a new padding statement, linked into existing chain. */
2669 pad = ((lang_statement_union_type *)
2670 stat_alloc (sizeof (lang_padding_statement_type)));
2671 pad->header.next = *ptr;
2673 pad->header.type = lang_padding_statement_enum;
2674 pad->padding_statement.output_section = output_section;
2675 if (fill == (fill_type *) 0)
2677 pad->padding_statement.fill = fill;
2679 pad->padding_statement.output_offset = dot - output_section->vma;
2680 pad->padding_statement.size = alignment_needed;
2681 output_section->_raw_size += alignment_needed;
2684 /* Work out how much this section will move the dot point. */
2687 size_input_section (this_ptr, output_section_statement, fill, dot)
2688 lang_statement_union_type **this_ptr;
2689 lang_output_section_statement_type *output_section_statement;
2693 lang_input_section_type *is = &((*this_ptr)->input_section);
2694 asection *i = is->section;
2696 if (is->ifile->just_syms_flag == false)
2698 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2699 ldfile_output_machine);
2700 unsigned int alignment_needed;
2703 /* Align this section first to the input sections requirement,
2704 then to the output section's requirement. If this alignment
2705 is greater than any seen before, then record it too. Perform
2706 the alignment by inserting a magic 'padding' statement. */
2708 if (output_section_statement->subsection_alignment != -1)
2709 i->alignment_power = output_section_statement->subsection_alignment;
2711 o = output_section_statement->bfd_section;
2712 if (o->alignment_power < i->alignment_power)
2713 o->alignment_power = i->alignment_power;
2715 alignment_needed = align_power (dot, i->alignment_power) - dot;
2717 if (alignment_needed != 0)
2719 insert_pad (this_ptr, fill, alignment_needed * opb, o, dot);
2720 dot += alignment_needed;
2723 /* Remember where in the output section this input section goes. */
2725 i->output_offset = dot - o->vma;
2727 /* Mark how big the output section must be to contain this now. */
2728 if (i->_cooked_size != 0)
2729 dot += i->_cooked_size / opb;
2731 dot += i->_raw_size / opb;
2732 o->_raw_size = (dot - o->vma) * opb;
2736 i->output_offset = i->vma - output_section_statement->bfd_section->vma;
2742 #define IGNORE_SECTION(bfd, s) \
2743 (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD)) \
2744 != (SEC_ALLOC | SEC_LOAD)) \
2745 || bfd_section_size (bfd, s) == 0)
2747 /* Check to see if any allocated sections overlap with other allocated
2748 sections. This can happen when the linker script specifically specifies
2749 the output section addresses of the two sections. */
2752 lang_check_section_addresses ()
2755 unsigned opb = bfd_octets_per_byte (output_bfd);
2757 /* Scan all sections in the output list. */
2758 for (s = output_bfd->sections; s != NULL; s = s->next)
2762 /* Ignore sections which are not loaded or which have no contents. */
2763 if (IGNORE_SECTION (output_bfd, s))
2766 /* Once we reach section 's' stop our seach. This prevents two
2767 warning messages from being produced, one for 'section A overlaps
2768 section B' and one for 'section B overlaps section A'. */
2769 for (os = output_bfd->sections; os != s; os = os->next)
2776 /* Only consider loadable sections with real contents. */
2777 if (IGNORE_SECTION (output_bfd, os))
2780 /* We must check the sections' LMA addresses not their
2781 VMA addresses because overlay sections can have
2782 overlapping VMAs but they must have distinct LMAs. */
2783 s_start = bfd_section_lma (output_bfd, s);
2784 os_start = bfd_section_lma (output_bfd, os);
2785 s_end = s_start + bfd_section_size (output_bfd, s) / opb - 1;
2786 os_end = os_start + bfd_section_size (output_bfd, os) / opb - 1;
2788 /* Look for an overlap. */
2789 if ((s_end < os_start) || (s_start > os_end))
2793 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2794 s->name, s_start, s_end, os->name, os_start, os_end);
2796 /* Once we have found one overlap for this section,
2797 stop looking for others. */
2803 /* Make sure the new address is within the region. We explicitly permit the
2804 current address to be at the exact end of the region when the address is
2805 non-zero, in case the region is at the end of addressable memory and the
2806 calculation wraps around. */
2809 os_region_check (os, region, tree, base)
2810 lang_output_section_statement_type *os;
2811 struct memory_region_struct *region;
2815 if ((region->current < region->origin
2816 || (region->current - region->origin > region->length))
2817 && ((region->current != region->origin + region->length)
2820 if (tree != (etree_type *) NULL)
2822 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2824 os->bfd_section->owner,
2825 os->bfd_section->name,
2830 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2832 os->bfd_section->owner,
2833 os->bfd_section->name);
2835 /* Reset the region pointer. */
2836 region->current = region->origin;
2840 /* Set the sizes for all the output sections. */
2843 lang_size_sections_1 (s, output_section_statement, prev, fill, dot, relax)
2844 lang_statement_union_type *s;
2845 lang_output_section_statement_type *output_section_statement;
2846 lang_statement_union_type **prev;
2851 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2852 ldfile_output_machine);
2854 /* Size up the sections from their constituent parts. */
2855 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
2857 switch (s->header.type)
2859 case lang_output_section_statement_enum:
2862 lang_output_section_statement_type *os;
2864 os = &s->output_section_statement;
2865 if (os->bfd_section == NULL)
2866 /* This section was never actually created. */
2869 /* If this is a COFF shared library section, use the size and
2870 address from the input section. FIXME: This is COFF
2871 specific; it would be cleaner if there were some other way
2872 to do this, but nothing simple comes to mind. */
2873 if ((os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
2877 if (os->children.head == NULL
2878 || os->children.head->header.next != NULL
2879 || os->children.head->header.type != lang_input_section_enum)
2880 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2883 input = os->children.head->input_section.section;
2884 bfd_set_section_vma (os->bfd_section->owner,
2886 bfd_section_vma (input->owner, input));
2887 os->bfd_section->_raw_size = input->_raw_size;
2891 if (bfd_is_abs_section (os->bfd_section))
2893 /* No matter what happens, an abs section starts at zero. */
2894 ASSERT (os->bfd_section->vma == 0);
2898 if (os->addr_tree == (etree_type *) NULL)
2900 /* No address specified for this section, get one
2901 from the region specification. */
2902 if (os->region == (lang_memory_region_type *) NULL
2903 || (((bfd_get_section_flags (output_bfd, os->bfd_section)
2904 & (SEC_ALLOC | SEC_LOAD)) != 0)
2905 && os->region->name[0] == '*'
2906 && strcmp (os->region->name, "*default*") == 0))
2908 os->region = lang_memory_default (os->bfd_section);
2911 /* If a loadable section is using the default memory
2912 region, and some non default memory regions were
2913 defined, issue a warning. */
2914 if ((bfd_get_section_flags (output_bfd, os->bfd_section)
2915 & (SEC_ALLOC | SEC_LOAD)) != 0
2916 && ! link_info.relocateable
2917 && strcmp (os->region->name, "*default*") == 0
2918 && lang_memory_region_list != NULL
2919 && (strcmp (lang_memory_region_list->name,
2921 || lang_memory_region_list->next != NULL))
2922 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2923 bfd_get_section_name (output_bfd,
2926 dot = os->region->current;
2928 if (os->section_alignment == -1)
2933 dot = align_power (dot,
2934 os->bfd_section->alignment_power);
2936 if (dot != olddot && config.warn_section_align)
2937 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2938 os->name, (unsigned int) (dot - olddot));
2945 r = exp_fold_tree (os->addr_tree,
2947 lang_allocating_phase_enum,
2949 if (r.valid_p == false)
2951 einfo (_("%F%S: non constant address expression for section %s\n"),
2954 dot = r.value + r.section->bfd_section->vma;
2957 /* The section starts here.
2958 First, align to what the section needs. */
2960 if (os->section_alignment != -1)
2961 dot = align_power (dot, os->section_alignment);
2963 bfd_set_section_vma (0, os->bfd_section, dot);
2965 os->bfd_section->output_offset = 0;
2968 lang_size_sections_1 (os->children.head, os, &os->children.head,
2969 os->fill, dot, relax);
2971 /* Put the section within the requested block size, or
2972 align at the block boundary. */
2973 after = ALIGN_N (os->bfd_section->vma
2974 + os->bfd_section->_raw_size / opb,
2975 /* The coercion here is important, see ld.h. */
2976 (bfd_vma) os->block_value);
2978 if (bfd_is_abs_section (os->bfd_section))
2979 ASSERT (after == os->bfd_section->vma);
2981 os->bfd_section->_raw_size =
2982 (after - os->bfd_section->vma) * opb;
2983 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
2984 os->processed = true;
2986 /* Update dot in the region ?
2987 We only do this if the section is going to be allocated,
2988 since unallocated sections do not contribute to the region's
2989 overall size in memory.
2991 If the SEC_NEVER_LOAD bit is not set, it will affect the
2992 addresses of sections after it. We have to update
2994 if (os->region != (lang_memory_region_type *) NULL
2995 && ((bfd_get_section_flags (output_bfd, os->bfd_section)
2996 & SEC_NEVER_LOAD) == 0
2997 || (bfd_get_section_flags (output_bfd, os->bfd_section)
2998 & (SEC_ALLOC | SEC_LOAD))))
3000 os->region->current = dot;
3002 /* Make sure the new address is within the region. */
3003 os_region_check (os, os->region, os->addr_tree,
3004 os->bfd_section->vma);
3006 /* If there's no load address specified, use the run
3007 region as the load region. */
3008 if (os->lma_region == NULL && os->load_base == NULL)
3009 os->lma_region = os->region;
3011 if (os->lma_region != NULL)
3013 if (os->load_base != NULL)
3015 einfo (_("%X%P: use an absolute load address or a load memory region, not both\n"));
3019 /* Don't allocate twice. */
3020 if (os->lma_region != os->region)
3022 /* Set load_base, which will be handled later. */
3024 exp_intop (os->lma_region->current);
3025 os->lma_region->current +=
3026 os->bfd_section->_raw_size / opb;
3027 os_region_check (os, os->lma_region, NULL,
3028 os->bfd_section->lma);
3036 case lang_constructors_statement_enum:
3037 dot = lang_size_sections_1 (constructor_list.head,
3038 output_section_statement,
3039 &s->wild_statement.children.head,
3043 case lang_data_statement_enum:
3045 unsigned int size = 0;
3047 s->data_statement.output_vma =
3048 dot - output_section_statement->bfd_section->vma;
3049 s->data_statement.output_section =
3050 output_section_statement->bfd_section;
3052 switch (s->data_statement.type)
3073 output_section_statement->bfd_section->_raw_size += size;
3074 /* The output section gets contents, and then we inspect for
3075 any flags set in the input script which override any ALLOC. */
3076 output_section_statement->bfd_section->flags |= SEC_HAS_CONTENTS;
3077 if (!(output_section_statement->flags & SEC_NEVER_LOAD))
3079 output_section_statement->bfd_section->flags |=
3080 SEC_ALLOC | SEC_LOAD;
3085 case lang_reloc_statement_enum:
3089 s->reloc_statement.output_vma =
3090 dot - output_section_statement->bfd_section->vma;
3091 s->reloc_statement.output_section =
3092 output_section_statement->bfd_section;
3093 size = bfd_get_reloc_size (s->reloc_statement.howto);
3095 output_section_statement->bfd_section->_raw_size += size;
3099 case lang_wild_statement_enum:
3101 dot = lang_size_sections_1 (s->wild_statement.children.head,
3102 output_section_statement,
3103 &s->wild_statement.children.head,
3108 case lang_object_symbols_statement_enum:
3109 link_info.create_object_symbols_section =
3110 output_section_statement->bfd_section;
3112 case lang_output_statement_enum:
3113 case lang_target_statement_enum:
3115 case lang_input_section_enum:
3119 i = (*prev)->input_section.section;
3122 if (i->_cooked_size == 0)
3123 i->_cooked_size = i->_raw_size;
3129 if (! bfd_relax_section (i->owner, i, &link_info, &again))
3130 einfo (_("%P%F: can't relax section: %E\n"));
3134 dot = size_input_section (prev, output_section_statement,
3135 output_section_statement->fill, dot);
3138 case lang_input_statement_enum:
3140 case lang_fill_statement_enum:
3141 s->fill_statement.output_section =
3142 output_section_statement->bfd_section;
3144 fill = s->fill_statement.fill;
3146 case lang_assignment_statement_enum:
3148 bfd_vma newdot = dot;
3150 exp_fold_tree (s->assignment_statement.exp,
3151 output_section_statement,
3152 lang_allocating_phase_enum,
3158 if (output_section_statement == abs_output_section)
3160 /* If we don't have an output section, then just adjust
3161 the default memory address. */
3162 lang_memory_region_lookup ("*default*")->current = newdot;
3166 /* Insert a pad after this statement. We can't
3167 put the pad before when relaxing, in case the
3168 assignment references dot. */
3169 insert_pad (&s->header.next, fill, (newdot - dot) * opb,
3170 output_section_statement->bfd_section, dot);
3172 /* Don't neuter the pad below when relaxing. */
3181 case lang_padding_statement_enum:
3182 /* If this is the first time lang_size_sections is called,
3183 we won't have any padding statements. If this is the
3184 second or later passes when relaxing, we should allow
3185 padding to shrink. If padding is needed on this pass, it
3186 will be added back in. */
3187 s->padding_statement.size = 0;
3189 /* Make sure output_offset is valid. If relaxation shrinks
3190 the section and this pad isn't needed, it's possible to
3191 have output_offset larger than the final size of the
3192 section. bfd_set_section_contents will complain even for
3193 a pad size of zero. */
3194 s->padding_statement.output_offset
3195 = dot - output_section_statement->bfd_section->vma;
3198 case lang_group_statement_enum:
3199 dot = lang_size_sections_1 (s->group_statement.children.head,
3200 output_section_statement,
3201 &s->group_statement.children.head,
3209 /* We can only get here when relaxing is turned on. */
3210 case lang_address_statement_enum:
3213 prev = &s->header.next;
3219 lang_size_sections (s, output_section_statement, prev, fill, dot, relax)
3220 lang_statement_union_type *s;
3221 lang_output_section_statement_type *output_section_statement;
3222 lang_statement_union_type **prev;
3229 exp_data_seg.phase = exp_dataseg_none;
3230 result = lang_size_sections_1 (s, output_section_statement, prev, fill,
3232 if (exp_data_seg.phase == exp_dataseg_end_seen)
3234 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
3235 a page could be saved in the data segment. */
3236 bfd_vma first, last;
3238 first = -exp_data_seg.base & (exp_data_seg.pagesize - 1);
3239 last = exp_data_seg.end & (exp_data_seg.pagesize - 1);
3241 && ((exp_data_seg.base & ~(exp_data_seg.pagesize - 1))
3242 != (exp_data_seg.end & ~(exp_data_seg.pagesize - 1)))
3243 && first + last <= exp_data_seg.pagesize)
3245 exp_data_seg.phase = exp_dataseg_adjust;
3246 result = lang_size_sections_1 (s, output_section_statement, prev,
3255 lang_do_assignments (s, output_section_statement, fill, dot)
3256 lang_statement_union_type *s;
3257 lang_output_section_statement_type *output_section_statement;
3261 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3262 ldfile_output_machine);
3264 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
3266 switch (s->header.type)
3268 case lang_constructors_statement_enum:
3269 dot = lang_do_assignments (constructor_list.head,
3270 output_section_statement,
3275 case lang_output_section_statement_enum:
3277 lang_output_section_statement_type *os;
3279 os = &(s->output_section_statement);
3280 if (os->bfd_section != NULL)
3282 dot = os->bfd_section->vma;
3283 (void) lang_do_assignments (os->children.head, os,
3285 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
3290 /* If nothing has been placed into the output section then
3291 it won't have a bfd_section. */
3292 if (os->bfd_section)
3294 os->bfd_section->lma
3295 = exp_get_abs_int (os->load_base, 0, "load base",
3296 lang_final_phase_enum);
3301 case lang_wild_statement_enum:
3303 dot = lang_do_assignments (s->wild_statement.children.head,
3304 output_section_statement,
3309 case lang_object_symbols_statement_enum:
3310 case lang_output_statement_enum:
3311 case lang_target_statement_enum:
3313 case lang_common_statement_enum:
3316 case lang_data_statement_enum:
3318 etree_value_type value;
3320 value = exp_fold_tree (s->data_statement.exp,
3322 lang_final_phase_enum, dot, &dot);
3323 s->data_statement.value = value.value;
3324 if (value.valid_p == false)
3325 einfo (_("%F%P: invalid data statement\n"));
3329 switch (s->data_statement.type)
3353 case lang_reloc_statement_enum:
3355 etree_value_type value;
3357 value = exp_fold_tree (s->reloc_statement.addend_exp,
3359 lang_final_phase_enum, dot, &dot);
3360 s->reloc_statement.addend_value = value.value;
3361 if (value.valid_p == false)
3362 einfo (_("%F%P: invalid reloc statement\n"));
3364 dot += bfd_get_reloc_size (s->reloc_statement.howto) / opb;
3367 case lang_input_section_enum:
3369 asection *in = s->input_section.section;
3371 if (in->_cooked_size != 0)
3372 dot += in->_cooked_size / opb;
3374 dot += in->_raw_size / opb;
3378 case lang_input_statement_enum:
3380 case lang_fill_statement_enum:
3381 fill = s->fill_statement.fill;
3383 case lang_assignment_statement_enum:
3385 exp_fold_tree (s->assignment_statement.exp,
3386 output_section_statement,
3387 lang_final_phase_enum,
3393 case lang_padding_statement_enum:
3394 dot += s->padding_statement.size / opb;
3397 case lang_group_statement_enum:
3398 dot = lang_do_assignments (s->group_statement.children.head,
3399 output_section_statement,
3407 case lang_address_statement_enum:
3415 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3416 operator .startof. (section_name), it produces an undefined symbol
3417 .startof.section_name. Similarly, when it sees
3418 .sizeof. (section_name), it produces an undefined symbol
3419 .sizeof.section_name. For all the output sections, we look for
3420 such symbols, and set them to the correct value. */
3427 if (link_info.relocateable)
3430 for (s = output_bfd->sections; s != NULL; s = s->next)
3432 const char *secname;
3434 struct bfd_link_hash_entry *h;
3436 secname = bfd_get_section_name (output_bfd, s);
3437 buf = xmalloc (10 + strlen (secname));
3439 sprintf (buf, ".startof.%s", secname);
3440 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3441 if (h != NULL && h->type == bfd_link_hash_undefined)
3443 h->type = bfd_link_hash_defined;
3444 h->u.def.value = bfd_get_section_vma (output_bfd, s);
3445 h->u.def.section = bfd_abs_section_ptr;
3448 sprintf (buf, ".sizeof.%s", secname);
3449 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3450 if (h != NULL && h->type == bfd_link_hash_undefined)
3454 opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3455 ldfile_output_machine);
3456 h->type = bfd_link_hash_defined;
3457 if (s->_cooked_size != 0)
3458 h->u.def.value = s->_cooked_size / opb;
3460 h->u.def.value = s->_raw_size / opb;
3461 h->u.def.section = bfd_abs_section_ptr;
3471 struct bfd_link_hash_entry *h;
3474 if (link_info.relocateable || link_info.shared)
3479 if (entry_symbol == (char *) NULL)
3481 /* No entry has been specified. Look for start, but don't warn
3482 if we don't find it. */
3483 entry_symbol = "start";
3487 h = bfd_link_hash_lookup (link_info.hash, entry_symbol, false, false, true);
3488 if (h != (struct bfd_link_hash_entry *) NULL
3489 && (h->type == bfd_link_hash_defined
3490 || h->type == bfd_link_hash_defweak)
3491 && h->u.def.section->output_section != NULL)
3495 val = (h->u.def.value
3496 + bfd_get_section_vma (output_bfd,
3497 h->u.def.section->output_section)
3498 + h->u.def.section->output_offset);
3499 if (! bfd_set_start_address (output_bfd, val))
3500 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol);
3507 /* We couldn't find the entry symbol. Try parsing it as a
3509 val = bfd_scan_vma (entry_symbol, &send, 0);
3512 if (! bfd_set_start_address (output_bfd, val))
3513 einfo (_("%P%F: can't set start address\n"));
3519 /* Can't find the entry symbol, and it's not a number. Use
3520 the first address in the text section. */
3521 ts = bfd_get_section_by_name (output_bfd, entry_section);
3522 if (ts != (asection *) NULL)
3525 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3526 entry_symbol, bfd_get_section_vma (output_bfd, ts));
3527 if (! bfd_set_start_address (output_bfd,
3528 bfd_get_section_vma (output_bfd,
3530 einfo (_("%P%F: can't set start address\n"));
3535 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3542 /* This is a small function used when we want to ignore errors from
3546 #ifdef ANSI_PROTOTYPES
3547 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
3549 ignore_bfd_errors (s)
3550 const char *s ATTRIBUTE_UNUSED;
3553 /* Don't do anything. */
3556 /* Check that the architecture of all the input files is compatible
3557 with the output file. Also call the backend to let it do any
3558 other checking that is needed. */
3563 lang_statement_union_type *file;
3565 const bfd_arch_info_type *compatible;
3567 for (file = file_chain.head;
3568 file != (lang_statement_union_type *) NULL;
3569 file = file->input_statement.next)
3571 input_bfd = file->input_statement.the_bfd;
3572 compatible = bfd_arch_get_compatible (input_bfd, output_bfd);
3574 /* In general it is not possible to perform a relocatable
3575 link between differing object formats when the input
3576 file has relocations, because the relocations in the
3577 input format may not have equivalent representations in
3578 the output format (and besides BFD does not translate
3579 relocs for other link purposes than a final link). */
3580 if ((link_info.relocateable || link_info.emitrelocations)
3581 && (compatible == NULL
3582 || bfd_get_flavour (input_bfd) != bfd_get_flavour (output_bfd))
3583 && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
3585 einfo (_("%P%F: Relocatable linking with relocations from format %s (%B) to format %s (%B) is not supported\n"),
3586 bfd_get_target (input_bfd), input_bfd,
3587 bfd_get_target (output_bfd), output_bfd);
3588 /* einfo with %F exits. */
3591 if (compatible == NULL)
3593 if (command_line.warn_mismatch)
3594 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3595 bfd_printable_name (input_bfd), input_bfd,
3596 bfd_printable_name (output_bfd));
3598 else if (bfd_count_sections (input_bfd))
3600 /* If the input bfd has no contents, it shouldn't set the
3601 private data of the output bfd. */
3603 bfd_error_handler_type pfn = NULL;
3605 /* If we aren't supposed to warn about mismatched input
3606 files, temporarily set the BFD error handler to a
3607 function which will do nothing. We still want to call
3608 bfd_merge_private_bfd_data, since it may set up
3609 information which is needed in the output file. */
3610 if (! command_line.warn_mismatch)
3611 pfn = bfd_set_error_handler (ignore_bfd_errors);
3612 if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
3614 if (command_line.warn_mismatch)
3615 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3618 if (! command_line.warn_mismatch)
3619 bfd_set_error_handler (pfn);
3624 /* Look through all the global common symbols and attach them to the
3625 correct section. The -sort-common command line switch may be used
3626 to roughly sort the entries by size. */
3631 if (command_line.inhibit_common_definition)
3633 if (link_info.relocateable
3634 && ! command_line.force_common_definition)
3637 if (! config.sort_common)
3638 bfd_link_hash_traverse (link_info.hash, lang_one_common, (PTR) NULL);
3643 for (power = 4; power >= 0; power--)
3644 bfd_link_hash_traverse (link_info.hash, lang_one_common,
3649 /* Place one common symbol in the correct section. */
3652 lang_one_common (h, info)
3653 struct bfd_link_hash_entry *h;
3656 unsigned int power_of_two;
3659 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3660 ldfile_output_machine);
3662 if (h->type != bfd_link_hash_common)
3666 power_of_two = h->u.c.p->alignment_power;
3668 if (config.sort_common
3669 && power_of_two < (unsigned int) *(int *) info)
3672 section = h->u.c.p->section;
3674 /* Increase the size of the section. */
3675 section->_cooked_size = ALIGN_N ((section->_cooked_size + opb - 1) / opb,
3676 (bfd_size_type) (1 << power_of_two)) * opb;
3678 /* Adjust the alignment if necessary. */
3679 if (power_of_two > section->alignment_power)
3680 section->alignment_power = power_of_two;
3682 /* Change the symbol from common to defined. */
3683 h->type = bfd_link_hash_defined;
3684 h->u.def.section = section;
3685 h->u.def.value = section->_cooked_size;
3687 /* Increase the size of the section. */
3688 section->_cooked_size += size;
3690 /* Make sure the section is allocated in memory, and make sure that
3691 it is no longer a common section. */
3692 section->flags |= SEC_ALLOC;
3693 section->flags &= ~SEC_IS_COMMON;
3695 if (config.map_file != NULL)
3697 static boolean header_printed;
3702 if (! header_printed)
3704 minfo (_("\nAllocating common symbols\n"));
3705 minfo (_("Common symbol size file\n\n"));
3706 header_printed = true;
3709 name = demangle (h->root.string);
3711 len = strlen (name);
3726 if (size <= 0xffffffff)
3727 sprintf (buf, "%lx", (unsigned long) size);
3729 sprintf_vma (buf, size);
3739 minfo ("%B\n", section->owner);
3745 /* Run through the input files and ensure that every input section has
3746 somewhere to go. If one is found without a destination then create
3747 an input request and place it into the statement tree. */
3750 lang_place_orphans ()
3752 LANG_FOR_EACH_INPUT_STATEMENT (file)
3756 for (s = file->the_bfd->sections;
3757 s != (asection *) NULL;
3760 if (s->output_section == (asection *) NULL)
3762 /* This section of the file is not attatched, root
3763 around for a sensible place for it to go. */
3765 if (file->just_syms_flag)
3767 /* We are only retrieving symbol values from this
3768 file. We want the symbols to act as though the
3769 values in the file are absolute. */
3770 s->output_section = bfd_abs_section_ptr;
3771 s->output_offset = s->vma;
3773 else if (strcmp (s->name, "COMMON") == 0)
3775 /* This is a lonely common section which must have
3776 come from an archive. We attach to the section
3777 with the wildcard. */
3778 if (! link_info.relocateable
3779 || command_line.force_common_definition)
3781 if (default_common_section == NULL)
3784 /* This message happens when using the
3785 svr3.ifile linker script, so I have
3787 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3789 default_common_section =
3790 lang_output_section_statement_lookup (".bss");
3793 lang_add_section (&default_common_section->children, s,
3794 default_common_section, file);
3797 else if (ldemul_place_orphan (file, s))
3801 lang_output_section_statement_type *os;
3803 os = lang_output_section_statement_lookup (s->name);
3804 lang_add_section (&os->children, s, os, file);
3812 lang_set_flags (ptr, flags, invert)
3813 lang_memory_region_type *ptr;
3817 flagword *ptr_flags;
3819 ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
3825 *ptr_flags |= SEC_ALLOC;
3829 *ptr_flags |= SEC_READONLY;
3833 *ptr_flags |= SEC_DATA;
3837 *ptr_flags |= SEC_CODE;
3842 *ptr_flags |= SEC_LOAD;
3846 einfo (_("%P%F: invalid syntax in flags\n"));
3853 /* Call a function on each input file. This function will be called
3854 on an archive, but not on the elements. */
3857 lang_for_each_input_file (func)
3858 void (*func) PARAMS ((lang_input_statement_type *));
3860 lang_input_statement_type *f;
3862 for (f = (lang_input_statement_type *) input_file_chain.head;
3864 f = (lang_input_statement_type *) f->next_real_file)
3868 /* Call a function on each file. The function will be called on all
3869 the elements of an archive which are included in the link, but will
3870 not be called on the archive file itself. */
3873 lang_for_each_file (func)
3874 void (*func) PARAMS ((lang_input_statement_type *));
3876 LANG_FOR_EACH_INPUT_STATEMENT (f)
3887 lang_for_each_input_section (func)
3888 void (*func) PARAMS ((bfd *ab, asection *as));
3890 LANG_FOR_EACH_INPUT_STATEMENT (f)
3894 for (s = f->the_bfd->sections;
3895 s != (asection *) NULL;
3898 func (f->the_bfd, s);
3906 ldlang_add_file (entry)
3907 lang_input_statement_type *entry;
3911 lang_statement_append (&file_chain,
3912 (lang_statement_union_type *) entry,
3915 /* The BFD linker needs to have a list of all input BFDs involved in
3917 ASSERT (entry->the_bfd->link_next == (bfd *) NULL);
3918 ASSERT (entry->the_bfd != output_bfd);
3919 for (pp = &link_info.input_bfds;
3920 *pp != (bfd *) NULL;
3921 pp = &(*pp)->link_next)
3923 *pp = entry->the_bfd;
3924 entry->the_bfd->usrdata = (PTR) entry;
3925 bfd_set_gp_size (entry->the_bfd, g_switch_value);
3927 /* Look through the sections and check for any which should not be
3928 included in the link. We need to do this now, so that we can
3929 notice when the backend linker tries to report multiple
3930 definition errors for symbols which are in sections we aren't
3931 going to link. FIXME: It might be better to entirely ignore
3932 symbols which are defined in sections which are going to be
3933 discarded. This would require modifying the backend linker for
3934 each backend which might set the SEC_LINK_ONCE flag. If we do
3935 this, we should probably handle SEC_EXCLUDE in the same way. */
3937 bfd_map_over_sections (entry->the_bfd, section_already_linked, (PTR) entry);
3941 lang_add_output (name, from_script)
3945 /* Make -o on command line override OUTPUT in script. */
3946 if (had_output_filename == false || !from_script)
3948 output_filename = name;
3949 had_output_filename = true;
3953 static lang_output_section_statement_type *current_section;
3965 for (l = 0; l < 32; l++)
3967 if (i >= (unsigned int) x)
3975 lang_output_section_statement_type *
3976 lang_enter_output_section_statement (output_section_statement_name,
3977 address_exp, sectype, block_value,
3978 align, subalign, ebase)
3979 const char *output_section_statement_name;
3980 etree_type *address_exp;
3981 enum section_type sectype;
3982 bfd_vma block_value;
3984 etree_type *subalign;
3987 lang_output_section_statement_type *os;
3991 lang_output_section_statement_lookup (output_section_statement_name);
3993 /* Add this statement to tree. */
3995 add_statement (lang_output_section_statement_enum,
3996 output_section_statement);
3998 /* Make next things chain into subchain of this. */
4000 if (os->addr_tree == (etree_type *) NULL)
4002 os->addr_tree = address_exp;
4004 os->sectype = sectype;
4005 if (sectype != noload_section)
4006 os->flags = SEC_NO_FLAGS;
4008 os->flags = SEC_NEVER_LOAD;
4009 os->block_value = block_value ? block_value : 1;
4010 stat_ptr = &os->children;
4012 os->subsection_alignment =
4013 topower (exp_get_value_int (subalign, -1, "subsection alignment", 0));
4014 os->section_alignment =
4015 topower (exp_get_value_int (align, -1, "section alignment", 0));
4017 os->load_base = ebase;
4024 lang_output_statement_type *new =
4025 new_stat (lang_output_statement, stat_ptr);
4027 new->name = output_filename;
4030 /* Reset the current counters in the regions. */
4033 lang_reset_memory_regions ()
4035 lang_memory_region_type *p = lang_memory_region_list;
4038 for (p = lang_memory_region_list;
4039 p != (lang_memory_region_type *) NULL;
4042 p->old_length = (bfd_size_type) (p->current - p->origin);
4043 p->current = p->origin;
4046 for (o = output_bfd->sections; o != NULL; o = o->next)
4050 /* If the wild pattern was marked KEEP, the member sections
4051 should be as well. */
4054 gc_section_callback (ptr, sec, section, file, data)
4055 lang_wild_statement_type *ptr;
4056 struct wildcard_list *sec ATTRIBUTE_UNUSED;
4058 lang_input_statement_type *file ATTRIBUTE_UNUSED;
4059 PTR data ATTRIBUTE_UNUSED;
4061 if (ptr->keep_sections)
4062 section->flags |= SEC_KEEP;
4065 /* Handle a wild statement, marking it against GC. */
4069 lang_wild_statement_type *s;
4071 walk_wild (s, gc_section_callback, NULL);
4074 /* Iterate over sections marking them against GC. */
4077 lang_gc_sections_1 (s)
4078 lang_statement_union_type *s;
4080 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
4082 switch (s->header.type)
4084 case lang_wild_statement_enum:
4085 lang_gc_wild (&s->wild_statement);
4087 case lang_constructors_statement_enum:
4088 lang_gc_sections_1 (constructor_list.head);
4090 case lang_output_section_statement_enum:
4091 lang_gc_sections_1 (s->output_section_statement.children.head);
4093 case lang_group_statement_enum:
4094 lang_gc_sections_1 (s->group_statement.children.head);
4105 struct bfd_link_hash_entry *h;
4106 ldlang_undef_chain_list_type *ulist, fake_list_start;
4108 /* Keep all sections so marked in the link script. */
4110 lang_gc_sections_1 (statement_list.head);
4112 /* Keep all sections containing symbols undefined on the command-line.
4113 Handle the entry symbol at the same time. */
4115 if (entry_symbol != NULL)
4117 fake_list_start.next = ldlang_undef_chain_list_head;
4118 fake_list_start.name = (char *) entry_symbol;
4119 ulist = &fake_list_start;
4122 ulist = ldlang_undef_chain_list_head;
4124 for (; ulist; ulist = ulist->next)
4126 h = bfd_link_hash_lookup (link_info.hash, ulist->name,
4127 false, false, false);
4129 if (h != (struct bfd_link_hash_entry *) NULL
4130 && (h->type == bfd_link_hash_defined
4131 || h->type == bfd_link_hash_defweak)
4132 && ! bfd_is_abs_section (h->u.def.section))
4134 h->u.def.section->flags |= SEC_KEEP;
4138 bfd_gc_sections (output_bfd, &link_info);
4144 lang_reasonable_defaults ();
4145 current_target = default_target;
4147 /* Open the output file. */
4148 lang_for_each_statement (ldlang_open_output);
4150 ldemul_create_output_section_statements ();
4152 /* Add to the hash table all undefineds on the command line. */
4153 lang_place_undefineds ();
4155 already_linked_table_init ();
4157 /* Create a bfd for each input file. */
4158 current_target = default_target;
4159 open_input_bfds (statement_list.head, false);
4161 ldemul_after_open ();
4163 already_linked_table_free ();
4165 /* Make sure that we're not mixing architectures. We call this
4166 after all the input files have been opened, but before we do any
4167 other processing, so that any operations merge_private_bfd_data
4168 does on the output file will be known during the rest of the
4172 /* Handle .exports instead of a version script if we're told to do so. */
4173 if (command_line.version_exports_section)
4174 lang_do_version_exports_section ();
4176 /* Build all sets based on the information gathered from the input
4178 ldctor_build_sets ();
4180 /* Remove unreferenced sections if asked to. */
4181 if (command_line.gc_sections)
4182 lang_gc_sections ();
4184 /* If there were any SEC_MERGE sections, finish their merging, so that
4185 section sizes can be computed. This has to be done after GC of sections,
4186 so that GCed sections are not merged, but before assigning output
4187 sections, since removing whole input sections is hard then. */
4188 bfd_merge_sections (output_bfd, &link_info);
4190 /* Size up the common data. */
4193 /* Run through the contours of the script and attach input sections
4194 to the correct output sections. */
4195 map_input_to_output_sections (statement_list.head, (char *) NULL,
4196 (lang_output_section_statement_type *) NULL);
4198 /* Find any sections not attached explicitly and handle them. */
4199 lang_place_orphans ();
4201 if (! link_info.relocateable)
4203 /* Look for a text section and set the readonly attribute in it. */
4204 asection *found = bfd_get_section_by_name (output_bfd, ".text");
4206 if (found != (asection *) NULL)
4208 if (config.text_read_only)
4209 found->flags |= SEC_READONLY;
4211 found->flags &= ~SEC_READONLY;
4215 /* Do anything special before sizing sections. This is where ELF
4216 and other back-ends size dynamic sections. */
4217 ldemul_before_allocation ();
4219 /* We must record the program headers before we try to fix the
4220 section positions, since they will affect SIZEOF_HEADERS. */
4221 lang_record_phdrs ();
4223 /* Size up the sections. */
4224 lang_size_sections (statement_list.head,
4226 &statement_list.head, 0, (bfd_vma) 0, NULL);
4228 /* Now run around and relax if we can. */
4229 if (command_line.relax)
4231 /* Keep relaxing until bfd_relax_section gives up. */
4232 boolean relax_again;
4236 lang_reset_memory_regions ();
4238 relax_again = false;
4240 /* Note: pe-dll.c does something like this also. If you find
4241 you need to change this code, you probably need to change
4242 pe-dll.c also. DJ */
4244 /* Do all the assignments with our current guesses as to
4246 lang_do_assignments (statement_list.head,
4248 (fill_type *) 0, (bfd_vma) 0);
4250 /* Perform another relax pass - this time we know where the
4251 globals are, so can make better guess. */
4252 lang_size_sections (statement_list.head,
4254 &(statement_list.head), 0, (bfd_vma) 0,
4257 while (relax_again);
4260 /* See if anything special should be done now we know how big
4262 ldemul_after_allocation ();
4264 /* Fix any .startof. or .sizeof. symbols. */
4265 lang_set_startof ();
4267 /* Do all the assignments, now that we know the final resting places
4268 of all the symbols. */
4270 lang_do_assignments (statement_list.head,
4272 (fill_type *) 0, (bfd_vma) 0);
4274 /* Make sure that the section addresses make sense. */
4275 if (! link_info.relocateable
4276 && command_line.check_section_addresses)
4277 lang_check_section_addresses ();
4285 /* EXPORTED TO YACC */
4288 lang_add_wild (filespec, section_list, keep_sections)
4289 struct wildcard_spec *filespec;
4290 struct wildcard_list *section_list;
4291 boolean keep_sections;
4293 struct wildcard_list *curr, *next;
4294 lang_wild_statement_type *new;
4296 /* Reverse the list as the parser puts it back to front. */
4297 for (curr = section_list, section_list = NULL;
4299 section_list = curr, curr = next)
4301 if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
4302 placed_commons = true;
4305 curr->next = section_list;
4308 if (filespec != NULL && filespec->name != NULL)
4310 if (strcmp (filespec->name, "*") == 0)
4311 filespec->name = NULL;
4312 else if (! wildcardp (filespec->name))
4313 lang_has_input_file = true;
4316 new = new_stat (lang_wild_statement, stat_ptr);
4317 new->filename = NULL;
4318 new->filenames_sorted = false;
4319 if (filespec != NULL)
4321 new->filename = filespec->name;
4322 new->filenames_sorted = filespec->sorted;
4324 new->section_list = section_list;
4325 new->keep_sections = keep_sections;
4326 lang_list_init (&new->children);
4330 lang_section_start (name, address)
4332 etree_type *address;
4334 lang_address_statement_type *ad;
4336 ad = new_stat (lang_address_statement, stat_ptr);
4337 ad->section_name = name;
4338 ad->address = address;
4341 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4342 because of a -e argument on the command line, or zero if this is
4343 called by ENTRY in a linker script. Command line arguments take
4347 lang_add_entry (name, cmdline)
4351 if (entry_symbol == NULL
4353 || ! entry_from_cmdline)
4355 entry_symbol = name;
4356 entry_from_cmdline = cmdline;
4361 lang_add_target (name)
4364 lang_target_statement_type *new = new_stat (lang_target_statement,
4380 map_option_f = true;
4388 lang_add_fill (fill)
4391 lang_fill_statement_type *new = new_stat (lang_fill_statement,
4398 lang_add_data (type, exp)
4400 union etree_union *exp;
4403 lang_data_statement_type *new = new_stat (lang_data_statement,
4411 /* Create a new reloc statement. RELOC is the BFD relocation type to
4412 generate. HOWTO is the corresponding howto structure (we could
4413 look this up, but the caller has already done so). SECTION is the
4414 section to generate a reloc against, or NAME is the name of the
4415 symbol to generate a reloc against. Exactly one of SECTION and
4416 NAME must be NULL. ADDEND is an expression for the addend. */
4419 lang_add_reloc (reloc, howto, section, name, addend)
4420 bfd_reloc_code_real_type reloc;
4421 reloc_howto_type *howto;
4424 union etree_union *addend;
4426 lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
4430 p->section = section;
4432 p->addend_exp = addend;
4434 p->addend_value = 0;
4435 p->output_section = NULL;
4439 lang_assignment_statement_type *
4440 lang_add_assignment (exp)
4443 lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
4451 lang_add_attribute (attribute)
4452 enum statement_enum attribute;
4454 new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
4461 if (startup_file != (char *) NULL)
4463 einfo (_("%P%Fmultiple STARTUP files\n"));
4465 first_file->filename = name;
4466 first_file->local_sym_name = name;
4467 first_file->real = true;
4469 startup_file = name;
4476 lang_float_flag = maybe;
4480 lang_leave_output_section_statement (fill, memspec, phdrs, lma_memspec)
4482 const char *memspec;
4483 struct lang_output_section_phdr_list *phdrs;
4484 const char *lma_memspec;
4486 current_section->fill = fill;
4487 current_section->region = lang_memory_region_lookup (memspec);
4488 if (strcmp (lma_memspec, "*default*") != 0)
4490 current_section->lma_region = lang_memory_region_lookup (lma_memspec);
4491 /* If no runtime region has been given, but the load region has
4492 been, use the load region. */
4493 if (strcmp (memspec, "*default*") == 0)
4494 current_section->region = lang_memory_region_lookup (lma_memspec);
4496 current_section->phdrs = phdrs;
4497 stat_ptr = &statement_list;
4500 /* Create an absolute symbol with the given name with the value of the
4501 address of first byte of the section named.
4503 If the symbol already exists, then do nothing. */
4506 lang_abs_symbol_at_beginning_of (secname, name)
4507 const char *secname;
4510 struct bfd_link_hash_entry *h;
4512 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4513 if (h == (struct bfd_link_hash_entry *) NULL)
4514 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4516 if (h->type == bfd_link_hash_new
4517 || h->type == bfd_link_hash_undefined)
4521 h->type = bfd_link_hash_defined;
4523 sec = bfd_get_section_by_name (output_bfd, secname);
4524 if (sec == (asection *) NULL)
4527 h->u.def.value = bfd_get_section_vma (output_bfd, sec);
4529 h->u.def.section = bfd_abs_section_ptr;
4533 /* Create an absolute symbol with the given name with the value of the
4534 address of the first byte after the end of the section named.
4536 If the symbol already exists, then do nothing. */
4539 lang_abs_symbol_at_end_of (secname, name)
4540 const char *secname;
4543 struct bfd_link_hash_entry *h;
4545 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4546 if (h == (struct bfd_link_hash_entry *) NULL)
4547 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4549 if (h->type == bfd_link_hash_new
4550 || h->type == bfd_link_hash_undefined)
4554 h->type = bfd_link_hash_defined;
4556 sec = bfd_get_section_by_name (output_bfd, secname);
4557 if (sec == (asection *) NULL)
4560 h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
4561 + bfd_section_size (output_bfd, sec) /
4562 bfd_octets_per_byte (output_bfd));
4564 h->u.def.section = bfd_abs_section_ptr;
4569 lang_statement_append (list, element, field)
4570 lang_statement_list_type *list;
4571 lang_statement_union_type *element;
4572 lang_statement_union_type **field;
4574 *(list->tail) = element;
4578 /* Set the output format type. -oformat overrides scripts. */
4581 lang_add_output_format (format, big, little, from_script)
4587 if (output_target == NULL || !from_script)
4589 if (command_line.endian == ENDIAN_BIG
4592 else if (command_line.endian == ENDIAN_LITTLE
4596 output_target = format;
4600 /* Enter a group. This creates a new lang_group_statement, and sets
4601 stat_ptr to build new statements within the group. */
4606 lang_group_statement_type *g;
4608 g = new_stat (lang_group_statement, stat_ptr);
4609 lang_list_init (&g->children);
4610 stat_ptr = &g->children;
4613 /* Leave a group. This just resets stat_ptr to start writing to the
4614 regular list of statements again. Note that this will not work if
4615 groups can occur inside anything else which can adjust stat_ptr,
4616 but currently they can't. */
4621 stat_ptr = &statement_list;
4624 /* Add a new program header. This is called for each entry in a PHDRS
4625 command in a linker script. */
4628 lang_new_phdr (name, type, filehdr, phdrs, at, flags)
4636 struct lang_phdr *n, **pp;
4638 n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));
4641 n->type = exp_get_value_int (type, 0, "program header type",
4642 lang_final_phase_enum);
4643 n->filehdr = filehdr;
4648 for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
4653 /* Record the program header information in the output BFD. FIXME: We
4654 should not be calling an ELF specific function here. */
4657 lang_record_phdrs ()
4661 struct lang_output_section_phdr_list *last;
4662 struct lang_phdr *l;
4663 lang_statement_union_type *u;
4666 secs = (asection **) xmalloc (alc * sizeof (asection *));
4668 for (l = lang_phdr_list; l != NULL; l = l->next)
4675 for (u = lang_output_section_statement.head;
4677 u = u->output_section_statement.next)
4679 lang_output_section_statement_type *os;
4680 struct lang_output_section_phdr_list *pl;
4682 os = &u->output_section_statement;
4689 if (os->sectype == noload_section
4690 || os->bfd_section == NULL
4691 || (os->bfd_section->flags & SEC_ALLOC) == 0)
4696 if (os->bfd_section == NULL)
4699 for (; pl != NULL; pl = pl->next)
4701 if (strcmp (pl->name, l->name) == 0)
4706 secs = ((asection **)
4707 xrealloc (secs, alc * sizeof (asection *)));
4709 secs[c] = os->bfd_section;
4716 if (l->flags == NULL)
4719 flags = exp_get_vma (l->flags, 0, "phdr flags",
4720 lang_final_phase_enum);
4725 at = exp_get_vma (l->at, 0, "phdr load address",
4726 lang_final_phase_enum);
4728 if (! bfd_record_phdr (output_bfd, l->type,
4729 l->flags != NULL, flags, l->at != NULL,
4730 at, l->filehdr, l->phdrs, c, secs))
4731 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4736 /* Make sure all the phdr assignments succeeded. */
4737 for (u = lang_output_section_statement.head;
4739 u = u->output_section_statement.next)
4741 struct lang_output_section_phdr_list *pl;
4743 if (u->output_section_statement.bfd_section == NULL)
4746 for (pl = u->output_section_statement.phdrs;
4749 if (! pl->used && strcmp (pl->name, "NONE") != 0)
4750 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4751 u->output_section_statement.name, pl->name);
4755 /* Record a list of sections which may not be cross referenced. */
4758 lang_add_nocrossref (l)
4759 struct lang_nocrossref *l;
4761 struct lang_nocrossrefs *n;
4763 n = (struct lang_nocrossrefs *) xmalloc (sizeof *n);
4764 n->next = nocrossref_list;
4766 nocrossref_list = n;
4768 /* Set notice_all so that we get informed about all symbols. */
4769 link_info.notice_all = true;
4772 /* Overlay handling. We handle overlays with some static variables. */
4774 /* The overlay virtual address. */
4775 static etree_type *overlay_vma;
4777 /* The overlay load address. */
4778 static etree_type *overlay_lma;
4780 /* Whether nocrossrefs is set for this overlay. */
4781 static int overlay_nocrossrefs;
4783 /* An expression for the maximum section size seen so far. */
4784 static etree_type *overlay_max;
4786 /* A list of all the sections in this overlay. */
4788 struct overlay_list {
4789 struct overlay_list *next;
4790 lang_output_section_statement_type *os;
4793 static struct overlay_list *overlay_list;
4795 /* Start handling an overlay. */
4798 lang_enter_overlay (vma_expr, lma_expr, nocrossrefs)
4799 etree_type *vma_expr;
4800 etree_type *lma_expr;
4803 /* The grammar should prevent nested overlays from occurring. */
4804 ASSERT (overlay_vma == NULL
4805 && overlay_lma == NULL
4806 && overlay_list == NULL
4807 && overlay_max == NULL);
4809 overlay_vma = vma_expr;
4810 overlay_lma = lma_expr;
4811 overlay_nocrossrefs = nocrossrefs;
4814 /* Start a section in an overlay. We handle this by calling
4815 lang_enter_output_section_statement with the correct VMA and LMA. */
4818 lang_enter_overlay_section (name)
4821 struct overlay_list *n;
4824 lang_enter_output_section_statement (name, overlay_vma, normal_section,
4825 0, 0, 0, overlay_lma);
4827 /* If this is the first section, then base the VMA and LMA of future
4828 sections on this one. This will work correctly even if `.' is
4829 used in the addresses. */
4830 if (overlay_list == NULL)
4832 overlay_vma = exp_nameop (ADDR, name);
4833 overlay_lma = exp_nameop (LOADADDR, name);
4836 /* Remember the section. */
4837 n = (struct overlay_list *) xmalloc (sizeof *n);
4838 n->os = current_section;
4839 n->next = overlay_list;
4842 size = exp_nameop (SIZEOF, name);
4844 /* Adjust the LMA for the next section. */
4845 overlay_lma = exp_binop ('+', overlay_lma, size);
4847 /* Arrange to work out the maximum section end address. */
4848 if (overlay_max == NULL)
4851 overlay_max = exp_binop (MAX_K, overlay_max, size);
4854 /* Finish a section in an overlay. There isn't any special to do
4858 lang_leave_overlay_section (fill, phdrs)
4860 struct lang_output_section_phdr_list *phdrs;
4867 name = current_section->name;
4869 lang_leave_output_section_statement (fill, "*default*",
4870 phdrs, "*default*");
4872 /* Define the magic symbols. */
4874 clean = xmalloc (strlen (name) + 1);
4876 for (s1 = name; *s1 != '\0'; s1++)
4877 if (ISALNUM (*s1) || *s1 == '_')
4881 buf = xmalloc (strlen (clean) + sizeof "__load_start_");
4882 sprintf (buf, "__load_start_%s", clean);
4883 lang_add_assignment (exp_assop ('=', buf,
4884 exp_nameop (LOADADDR, name)));
4886 buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
4887 sprintf (buf, "__load_stop_%s", clean);
4888 lang_add_assignment (exp_assop ('=', buf,
4890 exp_nameop (LOADADDR, name),
4891 exp_nameop (SIZEOF, name))));
4896 /* Finish an overlay. If there are any overlay wide settings, this
4897 looks through all the sections in the overlay and sets them. */
4900 lang_leave_overlay (fill, memspec, phdrs, lma_memspec)
4902 const char *memspec;
4903 struct lang_output_section_phdr_list *phdrs;
4904 const char *lma_memspec;
4906 lang_memory_region_type *region;
4907 lang_memory_region_type * default_region;
4908 lang_memory_region_type *lma_region;
4909 struct overlay_list *l;
4910 struct lang_nocrossref *nocrossref;
4912 default_region = lang_memory_region_lookup ("*default*");
4914 if (memspec == NULL)
4917 region = lang_memory_region_lookup (memspec);
4919 if (lma_memspec == NULL)
4922 lma_region = lang_memory_region_lookup (lma_memspec);
4929 struct overlay_list *next;
4931 if (fill != (fill_type *) 0 && l->os->fill == (fill_type *) 0)
4934 /* Assign a region to the sections, if one has been specified.
4935 Override the assignment of the default section, but not
4937 if (region != NULL &&
4938 (l->os->region == NULL ||
4939 l->os->region == default_region))
4940 l->os->region = region;
4942 /* We only set lma_region for the first overlay section, as
4943 subsequent overlay sections will have load_base set relative
4944 to the first section. Also, don't set lma_region if
4945 load_base is specified. FIXME: There should really be a test
4946 that `AT ( LDADDR )' doesn't conflict with `AT >LMA_REGION'
4947 rather than letting LDADDR simply override LMA_REGION. */
4948 if (lma_region != NULL && l->os->lma_region == NULL
4949 && l->next == NULL && l->os->load_base == NULL)
4950 l->os->lma_region = lma_region;
4952 if (phdrs != NULL && l->os->phdrs == NULL)
4953 l->os->phdrs = phdrs;
4955 if (overlay_nocrossrefs)
4957 struct lang_nocrossref *nc;
4959 nc = (struct lang_nocrossref *) xmalloc (sizeof *nc);
4960 nc->name = l->os->name;
4961 nc->next = nocrossref;
4970 if (nocrossref != NULL)
4971 lang_add_nocrossref (nocrossref);
4973 /* Update . for the end of the overlay. */
4974 lang_add_assignment (exp_assop ('=', ".",
4975 exp_binop ('+', overlay_vma, overlay_max)));
4979 overlay_nocrossrefs = 0;
4980 overlay_list = NULL;
4984 /* Version handling. This is only useful for ELF. */
4986 /* This global variable holds the version tree that we build. */
4988 struct bfd_elf_version_tree *lang_elf_version_info;
4991 lang_vers_match_lang_c (expr, sym)
4992 struct bfd_elf_version_expr *expr;
4995 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4997 return fnmatch (expr->pattern, sym, 0) == 0;
5001 lang_vers_match_lang_cplusplus (expr, sym)
5002 struct bfd_elf_version_expr *expr;
5008 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5011 alt_sym = cplus_demangle (sym, /* DMGL_NO_TPARAMS */ 0);
5014 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
5015 Should we early out false in this case? */
5016 result = fnmatch (expr->pattern, sym, 0) == 0;
5020 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
5028 lang_vers_match_lang_java (expr, sym)
5029 struct bfd_elf_version_expr *expr;
5035 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5038 alt_sym = cplus_demangle (sym, DMGL_JAVA);
5041 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
5042 Should we early out false in this case? */
5043 result = fnmatch (expr->pattern, sym, 0) == 0;
5047 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
5054 /* This is called for each variable name or match expression. */
5056 struct bfd_elf_version_expr *
5057 lang_new_vers_pattern (orig, new, lang)
5058 struct bfd_elf_version_expr *orig;
5062 struct bfd_elf_version_expr *ret;
5064 ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret);
5068 if (lang == NULL || strcasecmp (lang, "C") == 0)
5069 ret->match = lang_vers_match_lang_c;
5070 else if (strcasecmp (lang, "C++") == 0)
5071 ret->match = lang_vers_match_lang_cplusplus;
5072 else if (strcasecmp (lang, "Java") == 0)
5073 ret->match = lang_vers_match_lang_java;
5076 einfo (_("%X%P: unknown language `%s' in version information\n"),
5078 ret->match = lang_vers_match_lang_c;
5084 /* This is called for each set of variable names and match
5087 struct bfd_elf_version_tree *
5088 lang_new_vers_node (globals, locals)
5089 struct bfd_elf_version_expr *globals;
5090 struct bfd_elf_version_expr *locals;
5092 struct bfd_elf_version_tree *ret;
5094 ret = (struct bfd_elf_version_tree *) xmalloc (sizeof *ret);
5098 ret->globals = globals;
5099 ret->locals = locals;
5101 ret->name_indx = (unsigned int) -1;
5106 /* This static variable keeps track of version indices. */
5108 static int version_index;
5110 /* This is called when we know the name and dependencies of the
5114 lang_register_vers_node (name, version, deps)
5116 struct bfd_elf_version_tree *version;
5117 struct bfd_elf_version_deps *deps;
5119 struct bfd_elf_version_tree *t, **pp;
5120 struct bfd_elf_version_expr *e1;
5125 if ((name[0] == '\0' && lang_elf_version_info != NULL)
5126 || (lang_elf_version_info && lang_elf_version_info->name[0] == '\0'))
5128 einfo (_("%X%P: anonymous version tag cannot be combined with other version tags\n"));
5132 /* Make sure this node has a unique name. */
5133 for (t = lang_elf_version_info; t != NULL; t = t->next)
5134 if (strcmp (t->name, name) == 0)
5135 einfo (_("%X%P: duplicate version tag `%s'\n"), name);
5137 /* Check the global and local match names, and make sure there
5138 aren't any duplicates. */
5140 for (e1 = version->globals; e1 != NULL; e1 = e1->next)
5142 for (t = lang_elf_version_info; t != NULL; t = t->next)
5144 struct bfd_elf_version_expr *e2;
5146 for (e2 = t->locals; e2 != NULL; e2 = e2->next)
5147 if (strcmp (e1->pattern, e2->pattern) == 0)
5148 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5153 for (e1 = version->locals; e1 != NULL; e1 = e1->next)
5155 for (t = lang_elf_version_info; t != NULL; t = t->next)
5157 struct bfd_elf_version_expr *e2;
5159 for (e2 = t->globals; e2 != NULL; e2 = e2->next)
5160 if (strcmp (e1->pattern, e2->pattern) == 0)
5161 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5166 version->deps = deps;
5167 version->name = name;
5168 if (name[0] != '\0')
5171 version->vernum = version_index;
5174 version->vernum = 0;
5176 for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
5181 /* This is called when we see a version dependency. */
5183 struct bfd_elf_version_deps *
5184 lang_add_vers_depend (list, name)
5185 struct bfd_elf_version_deps *list;
5188 struct bfd_elf_version_deps *ret;
5189 struct bfd_elf_version_tree *t;
5191 ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret);
5194 for (t = lang_elf_version_info; t != NULL; t = t->next)
5196 if (strcmp (t->name, name) == 0)
5198 ret->version_needed = t;
5203 einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
5209 lang_do_version_exports_section ()
5211 struct bfd_elf_version_expr *greg = NULL, *lreg;
5213 LANG_FOR_EACH_INPUT_STATEMENT (is)
5215 asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
5222 len = bfd_section_size (is->the_bfd, sec);
5223 contents = xmalloc (len);
5224 if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
5225 einfo (_("%X%P: unable to read .exports section contents\n"), sec);
5228 while (p < contents + len)
5230 greg = lang_new_vers_pattern (greg, p, NULL);
5231 p = strchr (p, '\0') + 1;
5234 /* Do not free the contents, as we used them creating the regex. */
5236 /* Do not include this section in the link. */
5237 bfd_set_section_flags (is->the_bfd, sec,
5238 bfd_get_section_flags (is->the_bfd, sec) | SEC_EXCLUDE);
5241 lreg = lang_new_vers_pattern (NULL, "*", NULL);
5242 lang_register_vers_node (command_line.version_exports_section,
5243 lang_new_vers_node (greg, lreg), NULL);
5247 lang_add_unique (name)
5250 struct unique_sections *ent;
5252 for (ent = unique_section_list; ent; ent = ent->next)
5253 if (strcmp (ent->name, name) == 0)
5256 ent = (struct unique_sections *) xmalloc (sizeof *ent);
5257 ent->name = xstrdup (name);
5258 ent->next = unique_section_list;
5259 unique_section_list = ent;