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 insert_undefined PARAMS ((const char *));
96 static void lang_place_undefineds PARAMS ((void));
97 static void map_input_to_output_sections
98 PARAMS ((lang_statement_union_type *, const char *,
99 lang_output_section_statement_type *));
100 static void print_output_section_statement
101 PARAMS ((lang_output_section_statement_type *));
102 static void print_assignment
103 PARAMS ((lang_assignment_statement_type *,
104 lang_output_section_statement_type *));
105 static void print_input_statement PARAMS ((lang_input_statement_type *));
106 static boolean print_one_symbol PARAMS ((struct bfd_link_hash_entry *, PTR));
107 static void print_input_section PARAMS ((lang_input_section_type *));
108 static void print_fill_statement PARAMS ((lang_fill_statement_type *));
109 static void print_data_statement PARAMS ((lang_data_statement_type *));
110 static void print_address_statement PARAMS ((lang_address_statement_type *));
111 static void print_reloc_statement PARAMS ((lang_reloc_statement_type *));
112 static void print_padding_statement PARAMS ((lang_padding_statement_type *));
113 static void print_wild_statement
114 PARAMS ((lang_wild_statement_type *, lang_output_section_statement_type *));
115 static void print_group
116 PARAMS ((lang_group_statement_type *, lang_output_section_statement_type *));
117 static void print_statement
118 PARAMS ((lang_statement_union_type *, lang_output_section_statement_type *));
119 static void print_statement_list
120 PARAMS ((lang_statement_union_type *, lang_output_section_statement_type *));
121 static void print_statements PARAMS ((void));
122 static void insert_pad
123 PARAMS ((lang_statement_union_type **, fill_type *,
124 unsigned int, asection *, bfd_vma));
125 static bfd_vma size_input_section
126 PARAMS ((lang_statement_union_type **, lang_output_section_statement_type *,
127 fill_type *, bfd_vma));
128 static void lang_finish PARAMS ((void));
129 static void ignore_bfd_errors PARAMS ((const char *, ...));
130 static void lang_check PARAMS ((void));
131 static void lang_common PARAMS ((void));
132 static boolean lang_one_common PARAMS ((struct bfd_link_hash_entry *, PTR));
133 static void lang_place_orphans PARAMS ((void));
134 static int topower PARAMS ((int));
135 static void lang_set_startof PARAMS ((void));
136 static void gc_section_callback
137 PARAMS ((lang_wild_statement_type *, struct wildcard_list *, asection *,
138 lang_input_statement_type *, PTR));
139 static void lang_record_phdrs PARAMS ((void));
140 static void lang_gc_wild PARAMS ((lang_wild_statement_type *));
141 static void lang_gc_sections_1 PARAMS ((lang_statement_union_type *));
142 static void lang_gc_sections PARAMS ((void));
143 static int lang_vers_match_lang_c
144 PARAMS ((struct bfd_elf_version_expr *, const char *));
145 static int lang_vers_match_lang_cplusplus
146 PARAMS ((struct bfd_elf_version_expr *, const char *));
147 static int lang_vers_match_lang_java
148 PARAMS ((struct bfd_elf_version_expr *, const char *));
149 static void lang_do_version_exports_section PARAMS ((void));
150 static void lang_check_section_addresses PARAMS ((void));
151 static void os_region_check
152 PARAMS ((lang_output_section_statement_type *,
153 struct memory_region_struct *, etree_type *, bfd_vma));
154 static bfd_vma lang_size_sections_1
155 PARAMS ((lang_statement_union_type *, lang_output_section_statement_type *,
156 lang_statement_union_type **, fill_type *, bfd_vma, boolean *));
158 typedef void (*callback_t) PARAMS ((lang_wild_statement_type *,
159 struct wildcard_list *,
161 lang_input_statement_type *,
163 static void walk_wild
164 PARAMS ((lang_wild_statement_type *, callback_t, PTR));
165 static void walk_wild_section
166 PARAMS ((lang_wild_statement_type *, lang_input_statement_type *,
168 static void walk_wild_file
169 PARAMS ((lang_wild_statement_type *, lang_input_statement_type *,
172 static int get_target PARAMS ((const bfd_target *, PTR));
173 static void stricpy PARAMS ((char *, char *));
174 static void strcut PARAMS ((char *, char *));
175 static int name_compare PARAMS ((char *, char *));
176 static int closest_target_match PARAMS ((const bfd_target *, PTR));
177 static char * get_first_input_target PARAMS ((void));
180 lang_output_section_statement_type *abs_output_section;
181 lang_statement_list_type lang_output_section_statement;
182 lang_statement_list_type *stat_ptr = &statement_list;
183 lang_statement_list_type file_chain = { NULL, NULL };
184 const char *entry_symbol = NULL;
185 const char *entry_section = ".text";
186 boolean entry_from_cmdline;
187 boolean lang_has_input_file = false;
188 boolean had_output_filename = false;
189 boolean lang_float_flag = false;
190 boolean delete_output_file_on_failure = false;
191 struct lang_nocrossrefs *nocrossref_list;
192 struct unique_sections *unique_section_list;
194 etree_type *base; /* Relocation base - or null */
196 #if defined (__STDC__) || defined (ALMOST_STDC)
197 #define cat(a,b) a##b
199 #define cat(a,b) a/**/b
202 /* Don't beautify the line below with "innocent" whitespace, it breaks
203 the K&R C preprocessor! */
204 #define new_stat(x, y) \
205 (cat (x,_type)*) new_statement (cat (x,_enum), sizeof (cat (x,_type)), y)
207 #define outside_section_address(q) \
208 ((q)->output_offset + (q)->output_section->vma)
210 #define outside_symbol_address(q) \
211 ((q)->value + outside_section_address (q->section))
213 #define SECTION_NAME_MAP_LENGTH (16)
219 return obstack_alloc (&stat_obstack, size);
223 unique_section_p (secnam)
226 struct unique_sections *unam;
228 for (unam = unique_section_list; unam; unam = unam->next)
229 if (wildcardp (unam->name)
230 ? fnmatch (unam->name, secnam, 0) == 0
231 : strcmp (unam->name, secnam) == 0)
239 /* Generic traversal routines for finding matching sections. */
242 walk_wild_section (ptr, file, callback, data)
243 lang_wild_statement_type *ptr;
244 lang_input_statement_type *file;
250 if (file->just_syms_flag)
253 for (s = file->the_bfd->sections; s != NULL; s = s->next)
255 struct wildcard_list *sec;
257 sec = ptr->section_list;
259 (*callback) (ptr, sec, s, file, data);
263 boolean skip = false;
264 struct name_list *list_tmp;
266 /* Don't process sections from files which were
268 for (list_tmp = sec->spec.exclude_name_list;
270 list_tmp = list_tmp->next)
272 if (wildcardp (list_tmp->name))
273 skip = fnmatch (list_tmp->name, file->filename, 0) == 0;
275 skip = strcmp (list_tmp->name, file->filename) == 0;
277 /* If this file is part of an archive, and the archive is
278 excluded, exclude this file. */
279 if (! skip && file->the_bfd != NULL
280 && file->the_bfd->my_archive != NULL
281 && file->the_bfd->my_archive->filename != NULL)
283 if (wildcardp (list_tmp->name))
284 skip = fnmatch (list_tmp->name,
285 file->the_bfd->my_archive->filename,
288 skip = strcmp (list_tmp->name,
289 file->the_bfd->my_archive->filename) == 0;
296 if (!skip && sec->spec.name != NULL)
298 const char *sname = bfd_get_section_name (file->the_bfd, s);
300 if (wildcardp (sec->spec.name))
301 skip = fnmatch (sec->spec.name, sname, 0) != 0;
303 skip = strcmp (sec->spec.name, sname) != 0;
307 (*callback) (ptr, sec, s, file, data);
314 /* Handle a wild statement for a single file F. */
317 walk_wild_file (s, f, callback, data)
318 lang_wild_statement_type *s;
319 lang_input_statement_type *f;
323 if (f->the_bfd == NULL
324 || ! bfd_check_format (f->the_bfd, bfd_archive))
325 walk_wild_section (s, f, callback, data);
330 /* This is an archive file. We must map each member of the
331 archive separately. */
332 member = bfd_openr_next_archived_file (f->the_bfd, (bfd *) NULL);
333 while (member != NULL)
335 /* When lookup_name is called, it will call the add_symbols
336 entry point for the archive. For each element of the
337 archive which is included, BFD will call ldlang_add_file,
338 which will set the usrdata field of the member to the
339 lang_input_statement. */
340 if (member->usrdata != NULL)
342 walk_wild_section (s,
343 (lang_input_statement_type *) member->usrdata,
347 member = bfd_openr_next_archived_file (f->the_bfd, member);
353 walk_wild (s, callback, data)
354 lang_wild_statement_type *s;
358 const char *file_spec = s->filename;
360 if (file_spec == NULL)
362 /* Perform the iteration over all files in the list. */
363 LANG_FOR_EACH_INPUT_STATEMENT (f)
365 walk_wild_file (s, f, callback, data);
368 else if (wildcardp (file_spec))
370 LANG_FOR_EACH_INPUT_STATEMENT (f)
372 if (fnmatch (file_spec, f->filename, FNM_FILE_NAME) == 0)
373 walk_wild_file (s, f, callback, data);
378 lang_input_statement_type *f;
380 /* Perform the iteration over a single file. */
381 f = lookup_name (file_spec);
383 walk_wild_file (s, f, callback, data);
387 /* lang_for_each_statement walks the parse tree and calls the provided
388 function for each node. */
391 lang_for_each_statement_worker (func, s)
392 void (*func) PARAMS ((lang_statement_union_type *));
393 lang_statement_union_type *s;
395 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
399 switch (s->header.type)
401 case lang_constructors_statement_enum:
402 lang_for_each_statement_worker (func, constructor_list.head);
404 case lang_output_section_statement_enum:
405 lang_for_each_statement_worker
407 s->output_section_statement.children.head);
409 case lang_wild_statement_enum:
410 lang_for_each_statement_worker
412 s->wild_statement.children.head);
414 case lang_group_statement_enum:
415 lang_for_each_statement_worker (func,
416 s->group_statement.children.head);
418 case lang_data_statement_enum:
419 case lang_reloc_statement_enum:
420 case lang_object_symbols_statement_enum:
421 case lang_output_statement_enum:
422 case lang_target_statement_enum:
423 case lang_input_section_enum:
424 case lang_input_statement_enum:
425 case lang_assignment_statement_enum:
426 case lang_padding_statement_enum:
427 case lang_address_statement_enum:
428 case lang_fill_statement_enum:
438 lang_for_each_statement (func)
439 void (*func) PARAMS ((lang_statement_union_type *));
441 lang_for_each_statement_worker (func, statement_list.head);
444 /*----------------------------------------------------------------------*/
447 lang_list_init (list)
448 lang_statement_list_type *list;
450 list->head = (lang_statement_union_type *) NULL;
451 list->tail = &list->head;
454 /* Build a new statement node for the parse tree. */
456 static lang_statement_union_type *
457 new_statement (type, size, list)
458 enum statement_enum type;
460 lang_statement_list_type *list;
462 lang_statement_union_type *new = (lang_statement_union_type *)
465 new->header.type = type;
466 new->header.next = (lang_statement_union_type *) NULL;
467 lang_statement_append (list, new, &new->header.next);
471 /* Build a new input file node for the language. There are several
472 ways in which we treat an input file, eg, we only look at symbols,
473 or prefix it with a -l etc.
475 We can be supplied with requests for input files more than once;
476 they may, for example be split over serveral lines like foo.o(.text)
477 foo.o(.data) etc, so when asked for a file we check that we haven't
478 got it already so we don't duplicate the bfd. */
480 static lang_input_statement_type *
481 new_afile (name, file_type, target, add_to_list)
483 lang_input_file_enum_type file_type;
487 lang_input_statement_type *p;
490 p = new_stat (lang_input_statement, stat_ptr);
493 p = ((lang_input_statement_type *)
494 stat_alloc (sizeof (lang_input_statement_type)));
495 p->header.next = NULL;
498 lang_has_input_file = true;
502 case lang_input_file_is_symbols_only_enum:
504 p->is_archive = false;
506 p->local_sym_name = name;
507 p->just_syms_flag = true;
508 p->search_dirs_flag = false;
510 case lang_input_file_is_fake_enum:
512 p->is_archive = false;
514 p->local_sym_name = name;
515 p->just_syms_flag = false;
516 p->search_dirs_flag = false;
518 case lang_input_file_is_l_enum:
519 p->is_archive = true;
522 p->local_sym_name = concat ("-l", name, (const char *) NULL);
523 p->just_syms_flag = false;
524 p->search_dirs_flag = true;
526 case lang_input_file_is_marker_enum:
528 p->is_archive = false;
530 p->local_sym_name = name;
531 p->just_syms_flag = false;
532 p->search_dirs_flag = true;
534 case lang_input_file_is_search_file_enum:
536 p->is_archive = false;
538 p->local_sym_name = name;
539 p->just_syms_flag = false;
540 p->search_dirs_flag = true;
542 case lang_input_file_is_file_enum:
544 p->is_archive = false;
546 p->local_sym_name = name;
547 p->just_syms_flag = false;
548 p->search_dirs_flag = false;
553 p->the_bfd = (bfd *) NULL;
554 p->asymbols = (asymbol **) NULL;
555 p->next_real_file = (lang_statement_union_type *) NULL;
556 p->next = (lang_statement_union_type *) NULL;
558 p->dynamic = config.dynamic_link;
559 p->whole_archive = whole_archive;
561 lang_statement_append (&input_file_chain,
562 (lang_statement_union_type *) p,
567 lang_input_statement_type *
568 lang_add_input_file (name, file_type, target)
570 lang_input_file_enum_type file_type;
573 lang_has_input_file = true;
574 return new_afile (name, file_type, target, true);
577 /* Build enough state so that the parser can build its tree. */
582 obstack_begin (&stat_obstack, 1000);
584 stat_ptr = &statement_list;
586 lang_list_init (stat_ptr);
588 lang_list_init (&input_file_chain);
589 lang_list_init (&lang_output_section_statement);
590 lang_list_init (&file_chain);
591 first_file = lang_add_input_file ((char *) NULL,
592 lang_input_file_is_marker_enum,
595 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME);
597 abs_output_section->bfd_section = bfd_abs_section_ptr;
601 /*----------------------------------------------------------------------
602 A region is an area of memory declared with the
603 MEMORY { name:org=exp, len=exp ... }
606 We maintain a list of all the regions here.
608 If no regions are specified in the script, then the default is used
609 which is created when looked up to be the entire data space. */
611 static lang_memory_region_type *lang_memory_region_list;
612 static lang_memory_region_type **lang_memory_region_list_tail = &lang_memory_region_list;
614 lang_memory_region_type *
615 lang_memory_region_lookup (name)
616 const char *const name;
618 lang_memory_region_type *p;
620 /* NAME is NULL for LMA memspecs if no region was specified. */
624 for (p = lang_memory_region_list;
625 p != (lang_memory_region_type *) NULL;
628 if (strcmp (p->name, name) == 0)
635 /* This code used to always use the first region in the list as the
636 default region. I changed it to instead use a region
637 encompassing all of memory as the default region. This permits
638 NOLOAD sections to work reasonably without requiring a region.
639 People should specify what region they mean, if they really want
641 if (strcmp (name, "*default*") == 0)
643 if (lang_memory_region_list != (lang_memory_region_type *) NULL)
645 return lang_memory_region_list;
651 lang_memory_region_type *new =
652 (lang_memory_region_type *) stat_alloc (sizeof (lang_memory_region_type));
654 new->name = xstrdup (name);
655 new->next = (lang_memory_region_type *) NULL;
657 *lang_memory_region_list_tail = new;
658 lang_memory_region_list_tail = &new->next;
662 new->length = ~(bfd_size_type) 0;
664 new->had_full_message = false;
670 static lang_memory_region_type *
671 lang_memory_default (section)
674 lang_memory_region_type *p;
676 flagword sec_flags = section->flags;
678 /* Override SEC_DATA to mean a writable section. */
679 if ((sec_flags & (SEC_ALLOC | SEC_READONLY | SEC_CODE)) == SEC_ALLOC)
680 sec_flags |= SEC_DATA;
682 for (p = lang_memory_region_list;
683 p != (lang_memory_region_type *) NULL;
686 if ((p->flags & sec_flags) != 0
687 && (p->not_flags & sec_flags) == 0)
692 return lang_memory_region_lookup ("*default*");
695 lang_output_section_statement_type *
696 lang_output_section_find (name)
697 const char *const name;
699 lang_statement_union_type *u;
700 lang_output_section_statement_type *lookup;
702 for (u = lang_output_section_statement.head;
703 u != (lang_statement_union_type *) NULL;
706 lookup = &u->output_section_statement;
707 if (strcmp (name, lookup->name) == 0)
712 return (lang_output_section_statement_type *) NULL;
715 lang_output_section_statement_type *
716 lang_output_section_statement_lookup (name)
717 const char *const name;
719 lang_output_section_statement_type *lookup;
721 lookup = lang_output_section_find (name);
722 if (lookup == (lang_output_section_statement_type *) NULL)
725 lookup = (lang_output_section_statement_type *)
726 new_stat (lang_output_section_statement, stat_ptr);
727 lookup->region = (lang_memory_region_type *) NULL;
728 lookup->lma_region = (lang_memory_region_type *) NULL;
729 lookup->fill = (fill_type *) 0;
730 lookup->block_value = 1;
733 lookup->next = (lang_statement_union_type *) NULL;
734 lookup->bfd_section = (asection *) NULL;
735 lookup->processed = false;
736 lookup->sectype = normal_section;
737 lookup->addr_tree = (etree_type *) NULL;
738 lang_list_init (&lookup->children);
740 lookup->memspec = (const char *) NULL;
742 lookup->subsection_alignment = -1;
743 lookup->section_alignment = -1;
744 lookup->load_base = (union etree_union *) NULL;
745 lookup->update_dot_tree = NULL;
746 lookup->phdrs = NULL;
748 lang_statement_append (&lang_output_section_statement,
749 (lang_statement_union_type *) lookup,
756 lang_map_flags (flag)
759 if (flag & SEC_ALLOC)
765 if (flag & SEC_READONLY)
778 lang_memory_region_type *m;
780 minfo (_("\nMemory Configuration\n\n"));
781 fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
782 _("Name"), _("Origin"), _("Length"), _("Attributes"));
784 for (m = lang_memory_region_list;
785 m != (lang_memory_region_type *) NULL;
791 fprintf (config.map_file, "%-16s ", m->name);
793 sprintf_vma (buf, m->origin);
794 minfo ("0x%s ", buf);
802 minfo ("0x%V", m->length);
803 if (m->flags || m->not_flags)
811 lang_map_flags (m->flags);
817 lang_map_flags (m->not_flags);
824 fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
829 /* Initialize an output section. */
833 lang_output_section_statement_type *s;
835 section_userdata_type *new;
837 if (s->bfd_section != NULL)
840 if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
841 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME);
843 new = ((section_userdata_type *)
844 stat_alloc (sizeof (section_userdata_type)));
846 s->bfd_section = bfd_get_section_by_name (output_bfd, s->name);
847 if (s->bfd_section == (asection *) NULL)
848 s->bfd_section = bfd_make_section (output_bfd, s->name);
849 if (s->bfd_section == (asection *) NULL)
851 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
852 output_bfd->xvec->name, s->name);
854 s->bfd_section->output_section = s->bfd_section;
856 /* We initialize an output sections output offset to minus its own
857 vma to allow us to output a section through itself. */
858 s->bfd_section->output_offset = 0;
859 get_userdata (s->bfd_section) = (PTR) new;
861 /* If there is a base address, make sure that any sections it might
862 mention are initialized. */
863 if (s->addr_tree != NULL)
864 exp_init_os (s->addr_tree);
867 /* Make sure that all output sections mentioned in an expression are
874 switch (exp->type.node_class)
877 exp_init_os (exp->assign.src);
881 exp_init_os (exp->binary.lhs);
882 exp_init_os (exp->binary.rhs);
886 exp_init_os (exp->trinary.cond);
887 exp_init_os (exp->trinary.lhs);
888 exp_init_os (exp->trinary.rhs);
892 exp_init_os (exp->unary.child);
896 switch (exp->type.node_code)
902 lang_output_section_statement_type *os;
904 os = lang_output_section_find (exp->name.name);
905 if (os != NULL && os->bfd_section == NULL)
916 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
917 once into the output. This routine checks each section, and
918 arrange to discard it if a section of the same name has already
919 been linked. If the section has COMDAT information, then it uses
920 that to decide whether the section should be included. This code
921 assumes that all relevant sections have the SEC_LINK_ONCE flag set;
922 that is, it does not depend solely upon the section name.
923 section_already_linked is called via bfd_map_over_sections. */
925 /* This is the shape of the elements inside the already_linked hash
926 table. It maps a name onto a list of already_linked elements with
927 the same name. It's possible to get more than one element in a
928 list if the COMDAT sections have different names. */
930 struct already_linked_hash_entry
932 struct bfd_hash_entry root;
933 struct already_linked *entry;
936 struct already_linked
938 struct already_linked *next;
942 /* The hash table. */
944 static struct bfd_hash_table already_linked_table;
947 section_already_linked (abfd, sec, data)
952 lang_input_statement_type *entry = (lang_input_statement_type *) data;
955 struct already_linked *l;
956 struct already_linked_hash_entry *already_linked_list;
958 /* If we are only reading symbols from this object, then we want to
959 discard all sections. */
960 if (entry->just_syms_flag)
962 bfd_link_just_syms (sec, &link_info);
966 flags = bfd_get_section_flags (abfd, sec);
968 if ((flags & SEC_LINK_ONCE) == 0)
971 /* FIXME: When doing a relocatable link, we may have trouble
972 copying relocations in other sections that refer to local symbols
973 in the section being discarded. Those relocations will have to
974 be converted somehow; as of this writing I'm not sure that any of
975 the backends handle that correctly.
977 It is tempting to instead not discard link once sections when
978 doing a relocatable link (technically, they should be discarded
979 whenever we are building constructors). However, that fails,
980 because the linker winds up combining all the link once sections
981 into a single large link once section, which defeats the purpose
982 of having link once sections in the first place.
984 Also, not merging link once sections in a relocatable link
985 causes trouble for MIPS ELF, which relies in link once semantics
986 to handle the .reginfo section correctly. */
988 name = bfd_get_section_name (abfd, sec);
990 already_linked_list =
991 ((struct already_linked_hash_entry *)
992 bfd_hash_lookup (&already_linked_table, name, true, false));
994 for (l = already_linked_list->entry; l != NULL; l = l->next)
996 if (sec->comdat == NULL
997 || l->sec->comdat == NULL
998 || strcmp (sec->comdat->name, l->sec->comdat->name) == 0)
1000 /* The section has already been linked. See if we should
1002 switch (flags & SEC_LINK_DUPLICATES)
1007 case SEC_LINK_DUPLICATES_DISCARD:
1010 case SEC_LINK_DUPLICATES_ONE_ONLY:
1011 if (sec->comdat == NULL)
1012 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
1015 einfo (_("%P: %B: warning: ignoring duplicate `%s' section symbol `%s'\n"),
1016 abfd, name, sec->comdat->name);
1019 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
1020 /* FIXME: We should really dig out the contents of both
1021 sections and memcmp them. The COFF/PE spec says that
1022 the Microsoft linker does not implement this
1023 correctly, so I'm not going to bother doing it
1026 case SEC_LINK_DUPLICATES_SAME_SIZE:
1027 if (bfd_section_size (abfd, sec)
1028 != bfd_section_size (l->sec->owner, l->sec))
1029 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
1034 /* Set the output_section field so that lang_add_section
1035 does not create a lang_input_section structure for this
1037 sec->output_section = bfd_abs_section_ptr;
1043 /* This is the first section with this name. Record it. Allocate
1044 the memory from the same obstack as the hash table is kept in. */
1046 l = ((struct already_linked *)
1047 bfd_hash_allocate (&already_linked_table, sizeof *l));
1050 l->next = already_linked_list->entry;
1051 already_linked_list->entry = l;
1054 /* Support routines for the hash table used by section_already_linked,
1055 initialize the table, fill in an entry and remove the table. */
1057 static struct bfd_hash_entry *
1058 already_linked_newfunc (entry, table, string)
1059 struct bfd_hash_entry *entry ATTRIBUTE_UNUSED;
1060 struct bfd_hash_table *table;
1061 const char *string ATTRIBUTE_UNUSED;
1063 struct already_linked_hash_entry *ret =
1064 bfd_hash_allocate (table, sizeof (struct already_linked_hash_entry));
1068 return (struct bfd_hash_entry *) ret;
1072 already_linked_table_init ()
1074 if (! bfd_hash_table_init_n (&already_linked_table,
1075 already_linked_newfunc,
1077 einfo (_("%P%F: Failed to create hash table\n"));
1081 already_linked_table_free ()
1083 bfd_hash_table_free (&already_linked_table);
1086 /* The wild routines.
1088 These expand statements like *(.text) and foo.o to a list of
1089 explicit actions, like foo.o(.text), bar.o(.text) and
1090 foo.o(.text, .data). */
1092 /* Return true if the PATTERN argument is a wildcard pattern.
1093 Although backslashes are treated specially if a pattern contains
1094 wildcards, we do not consider the mere presence of a backslash to
1095 be enough to cause the pattern to be treated as a wildcard.
1096 That lets us handle DOS filenames more naturally. */
1100 const char *pattern;
1104 for (s = pattern; *s != '\0'; ++s)
1112 /* Add SECTION to the output section OUTPUT. Do this by creating a
1113 lang_input_section statement which is placed at PTR. FILE is the
1114 input file which holds SECTION. */
1117 lang_add_section (ptr, section, output, file)
1118 lang_statement_list_type *ptr;
1120 lang_output_section_statement_type *output;
1121 lang_input_statement_type *file;
1126 flags = bfd_get_section_flags (section->owner, section);
1130 /* If we are doing a final link, discard sections marked with
1132 if (! link_info.relocateable
1133 && (flags & SEC_EXCLUDE) != 0)
1136 /* Discard input sections which are assigned to a section named
1137 DISCARD_SECTION_NAME. */
1138 if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
1141 /* Discard debugging sections if we are stripping debugging
1143 if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
1144 && (flags & SEC_DEBUGGING) != 0)
1149 if (section->output_section == NULL)
1151 /* This prevents future calls from assigning this section. */
1152 section->output_section = bfd_abs_section_ptr;
1157 if (section->output_section == NULL)
1160 lang_input_section_type *new;
1163 if (output->bfd_section == NULL)
1166 first = ! output->bfd_section->linker_has_input;
1167 output->bfd_section->linker_has_input = 1;
1169 /* Add a section reference to the list. */
1170 new = new_stat (lang_input_section, ptr);
1172 new->section = section;
1174 section->output_section = output->bfd_section;
1176 flags = section->flags;
1178 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1179 to an output section, because we want to be able to include a
1180 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1181 section (I don't know why we want to do this, but we do).
1182 build_link_order in ldwrite.c handles this case by turning
1183 the embedded SEC_NEVER_LOAD section into a fill. */
1185 flags &= ~ SEC_NEVER_LOAD;
1187 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1188 already been processed. One reason to do this is that on pe
1189 format targets, .text$foo sections go into .text and it's odd
1190 to see .text with SEC_LINK_ONCE set. */
1192 if (! link_info.relocateable)
1193 flags &= ~ (SEC_LINK_ONCE | SEC_LINK_DUPLICATES);
1195 /* If this is not the first input section, and the SEC_READONLY
1196 flag is not currently set, then don't set it just because the
1197 input section has it set. */
1199 if (! first && (section->output_section->flags & SEC_READONLY) == 0)
1200 flags &= ~ SEC_READONLY;
1202 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
1204 && ((section->output_section->flags & (SEC_MERGE | SEC_STRINGS))
1205 != (flags & (SEC_MERGE | SEC_STRINGS))
1206 || ((flags & SEC_MERGE)
1207 && section->output_section->entsize != section->entsize)))
1209 section->output_section->flags &= ~ (SEC_MERGE | SEC_STRINGS);
1210 flags &= ~ (SEC_MERGE | SEC_STRINGS);
1213 /* For now make .tbss normal section. */
1214 if (flags & SEC_THREAD_LOCAL)
1217 section->output_section->flags |= flags;
1219 if (flags & SEC_MERGE)
1220 section->output_section->entsize = section->entsize;
1222 /* If SEC_READONLY is not set in the input section, then clear
1223 it from the output section. */
1224 if ((section->flags & SEC_READONLY) == 0)
1225 section->output_section->flags &= ~SEC_READONLY;
1227 switch (output->sectype)
1229 case normal_section:
1234 case overlay_section:
1235 output->bfd_section->flags &= ~SEC_ALLOC;
1237 case noload_section:
1238 output->bfd_section->flags &= ~SEC_LOAD;
1239 output->bfd_section->flags |= SEC_NEVER_LOAD;
1243 /* Copy over SEC_SMALL_DATA. */
1244 if (section->flags & SEC_SMALL_DATA)
1245 section->output_section->flags |= SEC_SMALL_DATA;
1247 if (section->alignment_power > output->bfd_section->alignment_power)
1248 output->bfd_section->alignment_power = section->alignment_power;
1250 /* If supplied an aligment, then force it. */
1251 if (output->section_alignment != -1)
1252 output->bfd_section->alignment_power = output->section_alignment;
1254 if (section->flags & SEC_BLOCK)
1256 section->output_section->flags |= SEC_BLOCK;
1257 /* FIXME: This value should really be obtained from the bfd... */
1258 output->block_value = 128;
1263 /* Handle wildcard sorting. This returns the lang_input_section which
1264 should follow the one we are going to create for SECTION and FILE,
1265 based on the sorting requirements of WILD. It returns NULL if the
1266 new section should just go at the end of the current list. */
1268 static lang_statement_union_type *
1269 wild_sort (wild, sec, file, section)
1270 lang_wild_statement_type *wild;
1271 struct wildcard_list *sec;
1272 lang_input_statement_type *file;
1275 const char *section_name;
1276 lang_statement_union_type *l;
1278 if (!wild->filenames_sorted && (sec == NULL || !sec->spec.sorted))
1281 section_name = bfd_get_section_name (file->the_bfd, section);
1282 for (l = wild->children.head; l != NULL; l = l->header.next)
1284 lang_input_section_type *ls;
1286 if (l->header.type != lang_input_section_enum)
1288 ls = &l->input_section;
1290 /* Sorting by filename takes precedence over sorting by section
1293 if (wild->filenames_sorted)
1295 const char *fn, *ln;
1299 /* The PE support for the .idata section as generated by
1300 dlltool assumes that files will be sorted by the name of
1301 the archive and then the name of the file within the
1304 if (file->the_bfd != NULL
1305 && bfd_my_archive (file->the_bfd) != NULL)
1307 fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
1312 fn = file->filename;
1316 if (ls->ifile->the_bfd != NULL
1317 && bfd_my_archive (ls->ifile->the_bfd) != NULL)
1319 ln = bfd_get_filename (bfd_my_archive (ls->ifile->the_bfd));
1324 ln = ls->ifile->filename;
1328 i = strcmp (fn, ln);
1337 fn = file->filename;
1339 ln = ls->ifile->filename;
1341 i = strcmp (fn, ln);
1349 /* Here either the files are not sorted by name, or we are
1350 looking at the sections for this file. */
1352 if (sec != NULL && sec->spec.sorted)
1354 if (strcmp (section_name,
1355 bfd_get_section_name (ls->ifile->the_bfd,
1365 /* Expand a wild statement for a particular FILE. SECTION may be
1366 NULL, in which case it is a wild card. */
1369 output_section_callback (ptr, sec, section, file, output)
1370 lang_wild_statement_type *ptr;
1371 struct wildcard_list *sec;
1373 lang_input_statement_type *file;
1376 lang_statement_union_type *before;
1378 /* Exclude sections that match UNIQUE_SECTION_LIST. */
1379 if (unique_section_p (bfd_get_section_name (file->the_bfd, section)))
1382 /* If the wild pattern was marked KEEP, the member sections
1383 should be as well. */
1384 if (ptr->keep_sections)
1385 section->flags |= SEC_KEEP;
1387 before = wild_sort (ptr, sec, file, section);
1389 /* Here BEFORE points to the lang_input_section which
1390 should follow the one we are about to add. If BEFORE
1391 is NULL, then the section should just go at the end
1392 of the current list. */
1395 lang_add_section (&ptr->children, section,
1396 (lang_output_section_statement_type *) output,
1400 lang_statement_list_type list;
1401 lang_statement_union_type **pp;
1403 lang_list_init (&list);
1404 lang_add_section (&list, section,
1405 (lang_output_section_statement_type *) output,
1408 /* If we are discarding the section, LIST.HEAD will
1410 if (list.head != NULL)
1412 ASSERT (list.head->header.next == NULL);
1414 for (pp = &ptr->children.head;
1416 pp = &(*pp)->header.next)
1417 ASSERT (*pp != NULL);
1419 list.head->header.next = *pp;
1425 /* This is passed a file name which must have been seen already and
1426 added to the statement tree. We will see if it has been opened
1427 already and had its symbols read. If not then we'll read it. */
1429 static lang_input_statement_type *
1433 lang_input_statement_type *search;
1435 for (search = (lang_input_statement_type *) input_file_chain.head;
1436 search != (lang_input_statement_type *) NULL;
1437 search = (lang_input_statement_type *) search->next_real_file)
1439 if (search->filename == (char *) NULL && name == (char *) NULL)
1441 if (search->filename != (char *) NULL
1442 && name != (char *) NULL
1443 && strcmp (search->filename, name) == 0)
1447 if (search == (lang_input_statement_type *) NULL)
1448 search = new_afile (name, lang_input_file_is_file_enum, default_target,
1451 /* If we have already added this file, or this file is not real
1452 (FIXME: can that ever actually happen?) or the name is NULL
1453 (FIXME: can that ever actually happen?) don't add this file. */
1456 || search->filename == (const char *) NULL)
1459 if (! load_symbols (search, (lang_statement_list_type *) NULL))
1465 /* Get the symbols for an input file. */
1468 load_symbols (entry, place)
1469 lang_input_statement_type *entry;
1470 lang_statement_list_type *place;
1477 ldfile_open_file (entry);
1479 if (! bfd_check_format (entry->the_bfd, bfd_archive)
1480 && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
1483 lang_statement_list_type *hold;
1484 boolean bad_load = true;
1486 err = bfd_get_error ();
1488 /* See if the emulation has some special knowledge. */
1489 if (ldemul_unrecognized_file (entry))
1492 if (err == bfd_error_file_ambiguously_recognized)
1496 einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
1497 einfo (_("%B: matching formats:"), entry->the_bfd);
1498 for (p = matching; *p != NULL; p++)
1502 else if (err != bfd_error_file_not_recognized
1504 einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
1508 bfd_close (entry->the_bfd);
1509 entry->the_bfd = NULL;
1511 /* Try to interpret the file as a linker script. */
1512 ldfile_open_command_file (entry->filename);
1517 ldfile_assumed_script = true;
1518 parser_input = input_script;
1520 ldfile_assumed_script = false;
1527 if (ldemul_recognized_file (entry))
1530 /* We don't call ldlang_add_file for an archive. Instead, the
1531 add_symbols entry point will call ldlang_add_file, via the
1532 add_archive_element callback, for each element of the archive
1534 switch (bfd_get_format (entry->the_bfd))
1540 ldlang_add_file (entry);
1541 if (trace_files || trace_file_tries)
1542 info_msg ("%I\n", entry);
1546 if (entry->whole_archive)
1549 boolean loaded = true;
1553 member = bfd_openr_next_archived_file (entry->the_bfd, member);
1558 if (! bfd_check_format (member, bfd_object))
1560 einfo (_("%F%B: member %B in archive is not an object\n"),
1561 entry->the_bfd, member);
1565 if (! ((*link_info.callbacks->add_archive_element)
1566 (&link_info, member, "--whole-archive")))
1569 if (! bfd_link_add_symbols (member, &link_info))
1571 einfo (_("%F%B: could not read symbols: %E\n"), member);
1576 entry->loaded = loaded;
1582 if (bfd_link_add_symbols (entry->the_bfd, &link_info))
1583 entry->loaded = true;
1585 einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
1587 return entry->loaded;
1590 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
1591 may be NULL, indicating that it is a wildcard. Separate
1592 lang_input_section statements are created for each part of the
1593 expansion; they are added after the wild statement S. OUTPUT is
1594 the output section. */
1597 wild (s, target, output)
1598 lang_wild_statement_type *s;
1599 const char *target ATTRIBUTE_UNUSED;
1600 lang_output_section_statement_type *output;
1602 struct wildcard_list *sec;
1604 walk_wild (s, output_section_callback, (PTR) output);
1606 for (sec = s->section_list; sec != NULL; sec = sec->next)
1608 if (default_common_section != NULL)
1610 if (sec->spec.name != NULL && strcmp (sec->spec.name, "COMMON") == 0)
1612 /* Remember the section that common is going to in case we
1613 later get something which doesn't know where to put it. */
1614 default_common_section = output;
1619 /* Return true iff target is the sought target. */
1622 get_target (target, data)
1623 const bfd_target *target;
1626 const char *sought = (const char *) data;
1628 return strcmp (target->name, sought) == 0;
1631 /* Like strcpy() but convert to lower case as well. */
1640 while ((c = *src++) != 0)
1641 *dest++ = TOLOWER (c);
1646 /* Remove the first occurance of needle (if any) in haystack
1650 strcut (haystack, needle)
1654 haystack = strstr (haystack, needle);
1660 for (src = haystack + strlen (needle); *src;)
1661 *haystack++ = *src++;
1667 /* Compare two target format name strings.
1668 Return a value indicating how "similar" they are. */
1671 name_compare (first, second)
1679 copy1 = xmalloc (strlen (first) + 1);
1680 copy2 = xmalloc (strlen (second) + 1);
1682 /* Convert the names to lower case. */
1683 stricpy (copy1, first);
1684 stricpy (copy2, second);
1686 /* Remove and endian strings from the name. */
1687 strcut (copy1, "big");
1688 strcut (copy1, "little");
1689 strcut (copy2, "big");
1690 strcut (copy2, "little");
1692 /* Return a value based on how many characters match,
1693 starting from the beginning. If both strings are
1694 the same then return 10 * their length. */
1695 for (result = 0; copy1[result] == copy2[result]; result++)
1696 if (copy1[result] == 0)
1708 /* Set by closest_target_match() below. */
1709 static const bfd_target *winner;
1711 /* Scan all the valid bfd targets looking for one that has the endianness
1712 requirement that was specified on the command line, and is the nearest
1713 match to the original output target. */
1716 closest_target_match (target, data)
1717 const bfd_target *target;
1720 const bfd_target *original = (const bfd_target *) data;
1722 if (command_line.endian == ENDIAN_BIG
1723 && target->byteorder != BFD_ENDIAN_BIG)
1726 if (command_line.endian == ENDIAN_LITTLE
1727 && target->byteorder != BFD_ENDIAN_LITTLE)
1730 /* Must be the same flavour. */
1731 if (target->flavour != original->flavour)
1734 /* If we have not found a potential winner yet, then record this one. */
1741 /* Oh dear, we now have two potential candidates for a successful match.
1742 Compare their names and choose the better one. */
1743 if (name_compare (target->name, original->name)
1744 > name_compare (winner->name, original->name))
1747 /* Keep on searching until wqe have checked them all. */
1751 /* Return the BFD target format of the first input file. */
1754 get_first_input_target ()
1756 char *target = NULL;
1758 LANG_FOR_EACH_INPUT_STATEMENT (s)
1760 if (s->header.type == lang_input_statement_enum
1763 ldfile_open_file (s);
1765 if (s->the_bfd != NULL
1766 && bfd_check_format (s->the_bfd, bfd_object))
1768 target = bfd_get_target (s->the_bfd);
1779 /* Open the output file. */
1787 /* Has the user told us which output format to use? */
1788 if (output_target == (char *) NULL)
1790 /* No - has the current target been set to something other than
1792 if (current_target != default_target)
1793 output_target = current_target;
1795 /* No - can we determine the format of the first input file? */
1798 output_target = get_first_input_target ();
1800 /* Failed - use the default output target. */
1801 if (output_target == NULL)
1802 output_target = default_target;
1806 /* Has the user requested a particular endianness on the command
1808 if (command_line.endian != ENDIAN_UNSET)
1810 const bfd_target *target;
1811 enum bfd_endian desired_endian;
1813 /* Get the chosen target. */
1814 target = bfd_search_for_target (get_target, (PTR) output_target);
1816 /* If the target is not supported, we cannot do anything. */
1819 if (command_line.endian == ENDIAN_BIG)
1820 desired_endian = BFD_ENDIAN_BIG;
1822 desired_endian = BFD_ENDIAN_LITTLE;
1824 /* See if the target has the wrong endianness. This should
1825 not happen if the linker script has provided big and
1826 little endian alternatives, but some scrips don't do
1828 if (target->byteorder != desired_endian)
1830 /* If it does, then see if the target provides
1831 an alternative with the correct endianness. */
1832 if (target->alternative_target != NULL
1833 && (target->alternative_target->byteorder == desired_endian))
1834 output_target = target->alternative_target->name;
1837 /* Try to find a target as similar as possible to
1838 the default target, but which has the desired
1839 endian characteristic. */
1840 (void) bfd_search_for_target (closest_target_match,
1843 /* Oh dear - we could not find any targets that
1844 satisfy our requirements. */
1846 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1848 output_target = winner->name;
1854 output = bfd_openw (name, output_target);
1856 if (output == (bfd *) NULL)
1858 if (bfd_get_error () == bfd_error_invalid_target)
1859 einfo (_("%P%F: target %s not found\n"), output_target);
1861 einfo (_("%P%F: cannot open output file %s: %E\n"), name);
1864 delete_output_file_on_failure = true;
1867 output->flags |= D_PAGED;
1870 if (! bfd_set_format (output, bfd_object))
1871 einfo (_("%P%F:%s: can not make object file: %E\n"), name);
1872 if (! bfd_set_arch_mach (output,
1873 ldfile_output_architecture,
1874 ldfile_output_machine))
1875 einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
1877 link_info.hash = bfd_link_hash_table_create (output);
1878 if (link_info.hash == (struct bfd_link_hash_table *) NULL)
1879 einfo (_("%P%F: can not create link hash table: %E\n"));
1881 bfd_set_gp_size (output, g_switch_value);
1886 ldlang_open_output (statement)
1887 lang_statement_union_type *statement;
1889 switch (statement->header.type)
1891 case lang_output_statement_enum:
1892 ASSERT (output_bfd == (bfd *) NULL);
1893 output_bfd = open_output (statement->output_statement.name);
1894 ldemul_set_output_arch ();
1895 if (config.magic_demand_paged && !link_info.relocateable)
1896 output_bfd->flags |= D_PAGED;
1898 output_bfd->flags &= ~D_PAGED;
1899 if (config.text_read_only)
1900 output_bfd->flags |= WP_TEXT;
1902 output_bfd->flags &= ~WP_TEXT;
1903 if (link_info.traditional_format)
1904 output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
1906 output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
1909 case lang_target_statement_enum:
1910 current_target = statement->target_statement.target;
1917 /* Open all the input files. */
1920 open_input_bfds (s, force)
1921 lang_statement_union_type *s;
1924 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
1926 switch (s->header.type)
1928 case lang_constructors_statement_enum:
1929 open_input_bfds (constructor_list.head, force);
1931 case lang_output_section_statement_enum:
1932 open_input_bfds (s->output_section_statement.children.head, force);
1934 case lang_wild_statement_enum:
1935 /* Maybe we should load the file's symbols. */
1936 if (s->wild_statement.filename
1937 && ! wildcardp (s->wild_statement.filename))
1938 (void) lookup_name (s->wild_statement.filename);
1939 open_input_bfds (s->wild_statement.children.head, force);
1941 case lang_group_statement_enum:
1943 struct bfd_link_hash_entry *undefs;
1945 /* We must continually search the entries in the group
1946 until no new symbols are added to the list of undefined
1951 undefs = link_info.hash->undefs_tail;
1952 open_input_bfds (s->group_statement.children.head, true);
1954 while (undefs != link_info.hash->undefs_tail);
1957 case lang_target_statement_enum:
1958 current_target = s->target_statement.target;
1960 case lang_input_statement_enum:
1961 if (s->input_statement.real)
1963 lang_statement_list_type add;
1965 s->input_statement.target = current_target;
1967 /* If we are being called from within a group, and this
1968 is an archive which has already been searched, then
1969 force it to be researched unless the whole archive
1970 has been loaded already. */
1972 && !s->input_statement.whole_archive
1973 && s->input_statement.loaded
1974 && bfd_check_format (s->input_statement.the_bfd,
1976 s->input_statement.loaded = false;
1978 lang_list_init (&add);
1980 if (! load_symbols (&s->input_statement, &add))
1981 config.make_executable = false;
1983 if (add.head != NULL)
1985 *add.tail = s->header.next;
1986 s->header.next = add.head;
1996 /* If there are [COMMONS] statements, put a wild one into the bss
2000 lang_reasonable_defaults ()
2003 lang_output_section_statement_lookup (".text");
2004 lang_output_section_statement_lookup (".data");
2006 default_common_section = lang_output_section_statement_lookup (".bss");
2008 if (placed_commons == false)
2010 lang_wild_statement_type *new =
2011 new_stat (lang_wild_statement,
2012 &default_common_section->children);
2014 new->section_name = "COMMON";
2015 new->filename = (char *) NULL;
2016 lang_list_init (&new->children);
2021 /* Add the supplied name to the symbol table as an undefined reference.
2022 This is a two step process as the symbol table doesn't even exist at
2023 the time the ld command line is processed. First we put the name
2024 on a list, then, once the output file has been opened, transfer the
2025 name to the symbol table. */
2027 typedef struct ldlang_undef_chain_list
2029 struct ldlang_undef_chain_list *next;
2031 } ldlang_undef_chain_list_type;
2033 static ldlang_undef_chain_list_type *ldlang_undef_chain_list_head;
2036 ldlang_add_undef (name)
2037 const char *const name;
2039 ldlang_undef_chain_list_type *new =
2040 ((ldlang_undef_chain_list_type *)
2041 stat_alloc (sizeof (ldlang_undef_chain_list_type)));
2043 new->next = ldlang_undef_chain_list_head;
2044 ldlang_undef_chain_list_head = new;
2046 new->name = xstrdup (name);
2048 if (output_bfd != NULL)
2049 insert_undefined (new->name);
2052 /* Insert NAME as undefined in the symbol table. */
2055 insert_undefined (name)
2058 struct bfd_link_hash_entry *h;
2060 h = bfd_link_hash_lookup (link_info.hash, name, true, false, true);
2061 if (h == (struct bfd_link_hash_entry *) NULL)
2062 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2063 if (h->type == bfd_link_hash_new)
2065 h->type = bfd_link_hash_undefined;
2066 h->u.undef.abfd = NULL;
2067 bfd_link_add_undef (link_info.hash, h);
2071 /* Run through the list of undefineds created above and place them
2072 into the linker hash table as undefined symbols belonging to the
2076 lang_place_undefineds ()
2078 ldlang_undef_chain_list_type *ptr;
2080 for (ptr = ldlang_undef_chain_list_head;
2081 ptr != (ldlang_undef_chain_list_type *) NULL;
2084 insert_undefined (ptr->name);
2088 /* Open input files and attatch to output sections. */
2091 map_input_to_output_sections (s, target, output_section_statement)
2092 lang_statement_union_type *s;
2094 lang_output_section_statement_type *output_section_statement;
2096 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
2098 switch (s->header.type)
2100 case lang_wild_statement_enum:
2101 wild (&s->wild_statement, target, output_section_statement);
2103 case lang_constructors_statement_enum:
2104 map_input_to_output_sections (constructor_list.head,
2106 output_section_statement);
2108 case lang_output_section_statement_enum:
2109 map_input_to_output_sections (s->output_section_statement.children.head,
2111 &s->output_section_statement);
2113 case lang_output_statement_enum:
2115 case lang_target_statement_enum:
2116 target = s->target_statement.target;
2118 case lang_group_statement_enum:
2119 map_input_to_output_sections (s->group_statement.children.head,
2121 output_section_statement);
2123 case lang_fill_statement_enum:
2124 case lang_input_section_enum:
2125 case lang_object_symbols_statement_enum:
2126 case lang_data_statement_enum:
2127 case lang_reloc_statement_enum:
2128 case lang_padding_statement_enum:
2129 case lang_input_statement_enum:
2130 if (output_section_statement != NULL
2131 && output_section_statement->bfd_section == NULL)
2132 init_os (output_section_statement);
2134 case lang_assignment_statement_enum:
2135 if (output_section_statement != NULL
2136 && output_section_statement->bfd_section == NULL)
2137 init_os (output_section_statement);
2139 /* Make sure that any sections mentioned in the assignment
2141 exp_init_os (s->assignment_statement.exp);
2143 case lang_afile_asection_pair_statement_enum:
2146 case lang_address_statement_enum:
2147 /* Mark the specified section with the supplied address. */
2149 lang_output_section_statement_type *os =
2150 lang_output_section_statement_lookup
2151 (s->address_statement.section_name);
2153 if (os->bfd_section == NULL)
2155 os->addr_tree = s->address_statement.address;
2163 print_output_section_statement (output_section_statement)
2164 lang_output_section_statement_type *output_section_statement;
2166 asection *section = output_section_statement->bfd_section;
2169 if (output_section_statement != abs_output_section)
2171 minfo ("\n%s", output_section_statement->name);
2173 if (section != NULL)
2175 print_dot = section->vma;
2177 len = strlen (output_section_statement->name);
2178 if (len >= SECTION_NAME_MAP_LENGTH - 1)
2183 while (len < SECTION_NAME_MAP_LENGTH)
2189 minfo ("0x%V %W", section->vma, section->_raw_size);
2191 if (output_section_statement->load_base != NULL)
2195 addr = exp_get_abs_int (output_section_statement->load_base, 0,
2196 "load base", lang_final_phase_enum);
2197 minfo (_(" load address 0x%V"), addr);
2204 print_statement_list (output_section_statement->children.head,
2205 output_section_statement);
2209 print_assignment (assignment, output_section)
2210 lang_assignment_statement_type *assignment;
2211 lang_output_section_statement_type *output_section;
2214 etree_value_type result;
2216 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2219 result = exp_fold_tree (assignment->exp->assign.src, output_section,
2220 lang_final_phase_enum, print_dot, &print_dot);
2226 value = result.value + result.section->bfd_section->vma;
2227 dst = assignment->exp->assign.dst;
2229 minfo ("0x%V", value);
2230 if (dst[0] == '.' && dst[1] == 0)
2243 exp_print_tree (assignment->exp);
2249 print_input_statement (statm)
2250 lang_input_statement_type *statm;
2252 if (statm->filename != (char *) NULL)
2254 fprintf (config.map_file, "LOAD %s\n", statm->filename);
2258 /* Print all symbols defined in a particular section. This is called
2259 via bfd_link_hash_traverse. */
2262 print_one_symbol (hash_entry, ptr)
2263 struct bfd_link_hash_entry *hash_entry;
2266 asection *sec = (asection *) ptr;
2268 if ((hash_entry->type == bfd_link_hash_defined
2269 || hash_entry->type == bfd_link_hash_defweak)
2270 && sec == hash_entry->u.def.section)
2274 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2277 (hash_entry->u.def.value
2278 + hash_entry->u.def.section->output_offset
2279 + hash_entry->u.def.section->output_section->vma));
2281 minfo (" %T\n", hash_entry->root.string);
2287 /* Print information about an input section to the map file. */
2290 print_input_section (in)
2291 lang_input_section_type *in;
2293 asection *i = in->section;
2294 bfd_size_type size = i->_cooked_size != 0 ? i->_cooked_size : i->_raw_size;
2295 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2296 ldfile_output_machine);
2301 minfo ("%s", i->name);
2303 if (i->output_section != NULL)
2307 len = 1 + strlen (i->name);
2308 if (len >= SECTION_NAME_MAP_LENGTH - 1)
2313 while (len < SECTION_NAME_MAP_LENGTH)
2319 minfo ("0x%V %W %B\n",
2320 i->output_section->vma + i->output_offset, size / opb,
2323 if (i->_cooked_size != 0 && i->_cooked_size != i->_raw_size)
2325 len = SECTION_NAME_MAP_LENGTH + 3;
2337 minfo (_("%W (size before relaxing)\n"), i->_raw_size);
2340 bfd_link_hash_traverse (link_info.hash, print_one_symbol, (PTR) i);
2342 print_dot = i->output_section->vma + i->output_offset + size / opb;
2348 print_fill_statement (fill)
2349 lang_fill_statement_type *fill;
2353 fputs (" FILL mask 0x", config.map_file);
2354 for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--)
2355 fprintf (config.map_file, "%02x", *p);
2356 fputs ("\n", config.map_file);
2360 print_data_statement (data)
2361 lang_data_statement_type *data;
2367 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2368 ldfile_output_machine);
2370 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2373 addr = data->output_vma;
2374 if (data->output_section != NULL)
2375 addr += data->output_section->vma;
2403 minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
2405 if (data->exp->type.node_class != etree_value)
2408 exp_print_tree (data->exp);
2413 print_dot = addr + size / opb;
2417 /* Print an address statement. These are generated by options like
2421 print_address_statement (address)
2422 lang_address_statement_type *address;
2424 minfo (_("Address of section %s set to "), address->section_name);
2425 exp_print_tree (address->address);
2429 /* Print a reloc statement. */
2432 print_reloc_statement (reloc)
2433 lang_reloc_statement_type *reloc;
2438 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2439 ldfile_output_machine);
2441 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2444 addr = reloc->output_vma;
2445 if (reloc->output_section != NULL)
2446 addr += reloc->output_section->vma;
2448 size = bfd_get_reloc_size (reloc->howto);
2450 minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
2452 if (reloc->name != NULL)
2453 minfo ("%s+", reloc->name);
2455 minfo ("%s+", reloc->section->name);
2457 exp_print_tree (reloc->addend_exp);
2461 print_dot = addr + size / opb;
2465 print_padding_statement (s)
2466 lang_padding_statement_type *s;
2470 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2471 ldfile_output_machine);
2475 len = sizeof " *fill*" - 1;
2476 while (len < SECTION_NAME_MAP_LENGTH)
2482 addr = s->output_offset;
2483 if (s->output_section != NULL)
2484 addr += s->output_section->vma;
2485 minfo ("0x%V %W ", addr, s->size);
2487 if (s->fill->size != 0)
2491 for (p = s->fill->data, size = s->fill->size; size != 0; p++, size--)
2492 fprintf (config.map_file, "%02x", *p);
2497 print_dot = addr + s->size / opb;
2501 print_wild_statement (w, os)
2502 lang_wild_statement_type *w;
2503 lang_output_section_statement_type *os;
2505 struct wildcard_list *sec;
2509 if (w->filenames_sorted)
2511 if (w->filename != NULL)
2512 minfo ("%s", w->filename);
2515 if (w->filenames_sorted)
2519 for (sec = w->section_list; sec; sec = sec->next)
2521 if (sec->spec.sorted)
2523 if (sec->spec.exclude_name_list != NULL)
2526 minfo ("EXCLUDE_FILE ( %s", sec->spec.exclude_name_list->name);
2527 for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next)
2528 minfo (", %s", tmp->name);
2531 if (sec->spec.name != NULL)
2532 minfo ("%s", sec->spec.name);
2535 if (sec->spec.sorted)
2542 print_statement_list (w->children.head, os);
2545 /* Print a group statement. */
2549 lang_group_statement_type *s;
2550 lang_output_section_statement_type *os;
2552 fprintf (config.map_file, "START GROUP\n");
2553 print_statement_list (s->children.head, os);
2554 fprintf (config.map_file, "END GROUP\n");
2557 /* Print the list of statements in S.
2558 This can be called for any statement type. */
2561 print_statement_list (s, os)
2562 lang_statement_union_type *s;
2563 lang_output_section_statement_type *os;
2567 print_statement (s, os);
2572 /* Print the first statement in statement list S.
2573 This can be called for any statement type. */
2576 print_statement (s, os)
2577 lang_statement_union_type *s;
2578 lang_output_section_statement_type *os;
2580 switch (s->header.type)
2583 fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
2586 case lang_constructors_statement_enum:
2587 if (constructor_list.head != NULL)
2589 if (constructors_sorted)
2590 minfo (" SORT (CONSTRUCTORS)\n");
2592 minfo (" CONSTRUCTORS\n");
2593 print_statement_list (constructor_list.head, os);
2596 case lang_wild_statement_enum:
2597 print_wild_statement (&s->wild_statement, os);
2599 case lang_address_statement_enum:
2600 print_address_statement (&s->address_statement);
2602 case lang_object_symbols_statement_enum:
2603 minfo (" CREATE_OBJECT_SYMBOLS\n");
2605 case lang_fill_statement_enum:
2606 print_fill_statement (&s->fill_statement);
2608 case lang_data_statement_enum:
2609 print_data_statement (&s->data_statement);
2611 case lang_reloc_statement_enum:
2612 print_reloc_statement (&s->reloc_statement);
2614 case lang_input_section_enum:
2615 print_input_section (&s->input_section);
2617 case lang_padding_statement_enum:
2618 print_padding_statement (&s->padding_statement);
2620 case lang_output_section_statement_enum:
2621 print_output_section_statement (&s->output_section_statement);
2623 case lang_assignment_statement_enum:
2624 print_assignment (&s->assignment_statement, os);
2626 case lang_target_statement_enum:
2627 fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
2629 case lang_output_statement_enum:
2630 minfo ("OUTPUT(%s", s->output_statement.name);
2631 if (output_target != NULL)
2632 minfo (" %s", output_target);
2635 case lang_input_statement_enum:
2636 print_input_statement (&s->input_statement);
2638 case lang_group_statement_enum:
2639 print_group (&s->group_statement, os);
2641 case lang_afile_asection_pair_statement_enum:
2650 print_statement_list (statement_list.head, abs_output_section);
2653 /* Print the first N statements in statement list S to STDERR.
2654 If N == 0, nothing is printed.
2655 If N < 0, the entire list is printed.
2656 Intended to be called from GDB. */
2659 dprint_statement (s, n)
2660 lang_statement_union_type *s;
2663 FILE *map_save = config.map_file;
2665 config.map_file = stderr;
2668 print_statement_list (s, abs_output_section);
2671 while (s && --n >= 0)
2673 print_statement (s, abs_output_section);
2678 config.map_file = map_save;
2682 insert_pad (ptr, fill, alignment_needed, output_section, dot)
2683 lang_statement_union_type **ptr;
2685 unsigned int alignment_needed;
2686 asection *output_section;
2689 static fill_type zero_fill = { 1, { 0 } };
2690 lang_statement_union_type *pad;
2692 pad = ((lang_statement_union_type *)
2693 ((char *) ptr - offsetof (lang_statement_union_type, header.next)));
2694 if (ptr != &statement_list.head
2695 && pad->header.type == lang_padding_statement_enum
2696 && pad->padding_statement.output_section == output_section)
2698 /* Use the existing pad statement. The above test on output
2699 section is probably redundant, but it doesn't hurt to check. */
2703 /* Make a new padding statement, linked into existing chain. */
2704 pad = ((lang_statement_union_type *)
2705 stat_alloc (sizeof (lang_padding_statement_type)));
2706 pad->header.next = *ptr;
2708 pad->header.type = lang_padding_statement_enum;
2709 pad->padding_statement.output_section = output_section;
2710 if (fill == (fill_type *) 0)
2712 pad->padding_statement.fill = fill;
2714 pad->padding_statement.output_offset = dot - output_section->vma;
2715 pad->padding_statement.size = alignment_needed;
2716 output_section->_raw_size += alignment_needed;
2719 /* Work out how much this section will move the dot point. */
2722 size_input_section (this_ptr, output_section_statement, fill, dot)
2723 lang_statement_union_type **this_ptr;
2724 lang_output_section_statement_type *output_section_statement;
2728 lang_input_section_type *is = &((*this_ptr)->input_section);
2729 asection *i = is->section;
2731 if (is->ifile->just_syms_flag == false)
2733 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2734 ldfile_output_machine);
2735 unsigned int alignment_needed;
2738 /* Align this section first to the input sections requirement,
2739 then to the output section's requirement. If this alignment
2740 is greater than any seen before, then record it too. Perform
2741 the alignment by inserting a magic 'padding' statement. */
2743 if (output_section_statement->subsection_alignment != -1)
2744 i->alignment_power = output_section_statement->subsection_alignment;
2746 o = output_section_statement->bfd_section;
2747 if (o->alignment_power < i->alignment_power)
2748 o->alignment_power = i->alignment_power;
2750 alignment_needed = align_power (dot, i->alignment_power) - dot;
2752 if (alignment_needed != 0)
2754 insert_pad (this_ptr, fill, alignment_needed * opb, o, dot);
2755 dot += alignment_needed;
2758 /* Remember where in the output section this input section goes. */
2760 i->output_offset = dot - o->vma;
2762 /* Mark how big the output section must be to contain this now. */
2763 if (i->_cooked_size != 0)
2764 dot += i->_cooked_size / opb;
2766 dot += i->_raw_size / opb;
2767 o->_raw_size = (dot - o->vma) * opb;
2771 i->output_offset = i->vma - output_section_statement->bfd_section->vma;
2777 #define IGNORE_SECTION(bfd, s) \
2778 (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD)) \
2779 != (SEC_ALLOC | SEC_LOAD)) \
2780 || bfd_section_size (bfd, s) == 0)
2782 /* Check to see if any allocated sections overlap with other allocated
2783 sections. This can happen when the linker script specifically specifies
2784 the output section addresses of the two sections. */
2787 lang_check_section_addresses ()
2790 unsigned opb = bfd_octets_per_byte (output_bfd);
2792 /* Scan all sections in the output list. */
2793 for (s = output_bfd->sections; s != NULL; s = s->next)
2797 /* Ignore sections which are not loaded or which have no contents. */
2798 if (IGNORE_SECTION (output_bfd, s))
2801 /* Once we reach section 's' stop our seach. This prevents two
2802 warning messages from being produced, one for 'section A overlaps
2803 section B' and one for 'section B overlaps section A'. */
2804 for (os = output_bfd->sections; os != s; os = os->next)
2811 /* Only consider loadable sections with real contents. */
2812 if (IGNORE_SECTION (output_bfd, os))
2815 /* We must check the sections' LMA addresses not their
2816 VMA addresses because overlay sections can have
2817 overlapping VMAs but they must have distinct LMAs. */
2818 s_start = bfd_section_lma (output_bfd, s);
2819 os_start = bfd_section_lma (output_bfd, os);
2820 s_end = s_start + bfd_section_size (output_bfd, s) / opb - 1;
2821 os_end = os_start + bfd_section_size (output_bfd, os) / opb - 1;
2823 /* Look for an overlap. */
2824 if ((s_end < os_start) || (s_start > os_end))
2828 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2829 s->name, s_start, s_end, os->name, os_start, os_end);
2831 /* Once we have found one overlap for this section,
2832 stop looking for others. */
2838 /* Make sure the new address is within the region. We explicitly permit the
2839 current address to be at the exact end of the region when the address is
2840 non-zero, in case the region is at the end of addressable memory and the
2841 calculation wraps around. */
2844 os_region_check (os, region, tree, base)
2845 lang_output_section_statement_type *os;
2846 struct memory_region_struct *region;
2850 if ((region->current < region->origin
2851 || (region->current - region->origin > region->length))
2852 && ((region->current != region->origin + region->length)
2855 if (tree != (etree_type *) NULL)
2857 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2859 os->bfd_section->owner,
2860 os->bfd_section->name,
2865 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2867 os->bfd_section->owner,
2868 os->bfd_section->name);
2870 /* Reset the region pointer. */
2871 region->current = region->origin;
2875 /* Set the sizes for all the output sections. */
2878 lang_size_sections_1 (s, output_section_statement, prev, fill, dot, relax)
2879 lang_statement_union_type *s;
2880 lang_output_section_statement_type *output_section_statement;
2881 lang_statement_union_type **prev;
2886 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2887 ldfile_output_machine);
2889 /* Size up the sections from their constituent parts. */
2890 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
2892 switch (s->header.type)
2894 case lang_output_section_statement_enum:
2897 lang_output_section_statement_type *os;
2899 os = &s->output_section_statement;
2900 if (os->bfd_section == NULL)
2901 /* This section was never actually created. */
2904 /* If this is a COFF shared library section, use the size and
2905 address from the input section. FIXME: This is COFF
2906 specific; it would be cleaner if there were some other way
2907 to do this, but nothing simple comes to mind. */
2908 if ((os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
2912 if (os->children.head == NULL
2913 || os->children.head->header.next != NULL
2914 || os->children.head->header.type != lang_input_section_enum)
2915 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2918 input = os->children.head->input_section.section;
2919 bfd_set_section_vma (os->bfd_section->owner,
2921 bfd_section_vma (input->owner, input));
2922 os->bfd_section->_raw_size = input->_raw_size;
2926 if (bfd_is_abs_section (os->bfd_section))
2928 /* No matter what happens, an abs section starts at zero. */
2929 ASSERT (os->bfd_section->vma == 0);
2933 if (os->addr_tree == (etree_type *) NULL)
2935 /* No address specified for this section, get one
2936 from the region specification. */
2937 if (os->region == (lang_memory_region_type *) NULL
2938 || (((bfd_get_section_flags (output_bfd, os->bfd_section)
2939 & (SEC_ALLOC | SEC_LOAD)) != 0)
2940 && os->region->name[0] == '*'
2941 && strcmp (os->region->name, "*default*") == 0))
2943 os->region = lang_memory_default (os->bfd_section);
2946 /* If a loadable section is using the default memory
2947 region, and some non default memory regions were
2948 defined, issue a warning. */
2949 if ((bfd_get_section_flags (output_bfd, os->bfd_section)
2950 & (SEC_ALLOC | SEC_LOAD)) != 0
2951 && (bfd_get_section_flags (output_bfd, os->bfd_section)
2952 & SEC_NEVER_LOAD) == 0
2953 && ! link_info.relocateable
2954 && strcmp (os->region->name, "*default*") == 0
2955 && lang_memory_region_list != NULL
2956 && (strcmp (lang_memory_region_list->name,
2958 || lang_memory_region_list->next != NULL))
2959 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2960 bfd_get_section_name (output_bfd,
2963 dot = os->region->current;
2965 if (os->section_alignment == -1)
2970 dot = align_power (dot,
2971 os->bfd_section->alignment_power);
2973 if (dot != olddot && config.warn_section_align)
2974 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2975 os->name, (unsigned int) (dot - olddot));
2982 r = exp_fold_tree (os->addr_tree,
2984 lang_allocating_phase_enum,
2986 if (r.valid_p == false)
2988 einfo (_("%F%S: non constant address expression for section %s\n"),
2991 dot = r.value + r.section->bfd_section->vma;
2994 /* The section starts here.
2995 First, align to what the section needs. */
2997 if (os->section_alignment != -1)
2998 dot = align_power (dot, os->section_alignment);
3000 bfd_set_section_vma (0, os->bfd_section, dot);
3002 os->bfd_section->output_offset = 0;
3005 lang_size_sections_1 (os->children.head, os, &os->children.head,
3006 os->fill, dot, relax);
3008 /* Put the section within the requested block size, or
3009 align at the block boundary. */
3010 after = ALIGN_N (os->bfd_section->vma
3011 + os->bfd_section->_raw_size / opb,
3012 /* The coercion here is important, see ld.h. */
3013 (bfd_vma) os->block_value);
3015 if (bfd_is_abs_section (os->bfd_section))
3016 ASSERT (after == os->bfd_section->vma);
3017 else if ((os->bfd_section->flags & SEC_HAS_CONTENTS) == 0
3018 && (os->bfd_section->flags & SEC_THREAD_LOCAL))
3019 os->bfd_section->_raw_size = 0;
3021 os->bfd_section->_raw_size =
3022 (after - os->bfd_section->vma) * opb;
3024 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
3025 os->processed = true;
3027 if (os->update_dot_tree != 0)
3028 exp_fold_tree (os->update_dot_tree, abs_output_section,
3029 lang_allocating_phase_enum, dot, &dot);
3031 /* Update dot in the region ?
3032 We only do this if the section is going to be allocated,
3033 since unallocated sections do not contribute to the region's
3034 overall size in memory.
3036 If the SEC_NEVER_LOAD bit is not set, it will affect the
3037 addresses of sections after it. We have to update
3039 if (os->region != (lang_memory_region_type *) NULL
3040 && ((bfd_get_section_flags (output_bfd, os->bfd_section)
3041 & SEC_NEVER_LOAD) == 0
3042 || (bfd_get_section_flags (output_bfd, os->bfd_section)
3043 & (SEC_ALLOC | SEC_LOAD))))
3045 os->region->current = dot;
3047 /* Make sure the new address is within the region. */
3048 os_region_check (os, os->region, os->addr_tree,
3049 os->bfd_section->vma);
3051 /* If there's no load address specified, use the run
3052 region as the load region. */
3053 if (os->lma_region == NULL && os->load_base == NULL)
3054 os->lma_region = os->region;
3056 if (os->lma_region != NULL)
3058 if (os->load_base != NULL)
3060 einfo (_("%X%P: use an absolute load address or a load memory region, not both\n"));
3064 /* Don't allocate twice. */
3065 if (os->lma_region != os->region)
3067 /* Set load_base, which will be handled later. */
3069 exp_intop (os->lma_region->current);
3070 os->lma_region->current +=
3071 os->bfd_section->_raw_size / opb;
3072 os_region_check (os, os->lma_region, NULL,
3073 os->bfd_section->lma);
3081 case lang_constructors_statement_enum:
3082 dot = lang_size_sections_1 (constructor_list.head,
3083 output_section_statement,
3084 &s->wild_statement.children.head,
3088 case lang_data_statement_enum:
3090 unsigned int size = 0;
3092 s->data_statement.output_vma =
3093 dot - output_section_statement->bfd_section->vma;
3094 s->data_statement.output_section =
3095 output_section_statement->bfd_section;
3097 switch (s->data_statement.type)
3118 output_section_statement->bfd_section->_raw_size += size;
3119 /* The output section gets contents, and then we inspect for
3120 any flags set in the input script which override any ALLOC. */
3121 output_section_statement->bfd_section->flags |= SEC_HAS_CONTENTS;
3122 if (!(output_section_statement->flags & SEC_NEVER_LOAD))
3124 output_section_statement->bfd_section->flags |=
3125 SEC_ALLOC | SEC_LOAD;
3130 case lang_reloc_statement_enum:
3134 s->reloc_statement.output_vma =
3135 dot - output_section_statement->bfd_section->vma;
3136 s->reloc_statement.output_section =
3137 output_section_statement->bfd_section;
3138 size = bfd_get_reloc_size (s->reloc_statement.howto);
3140 output_section_statement->bfd_section->_raw_size += size;
3144 case lang_wild_statement_enum:
3146 dot = lang_size_sections_1 (s->wild_statement.children.head,
3147 output_section_statement,
3148 &s->wild_statement.children.head,
3153 case lang_object_symbols_statement_enum:
3154 link_info.create_object_symbols_section =
3155 output_section_statement->bfd_section;
3157 case lang_output_statement_enum:
3158 case lang_target_statement_enum:
3160 case lang_input_section_enum:
3164 i = (*prev)->input_section.section;
3167 if (i->_cooked_size == 0)
3168 i->_cooked_size = i->_raw_size;
3174 if (! bfd_relax_section (i->owner, i, &link_info, &again))
3175 einfo (_("%P%F: can't relax section: %E\n"));
3179 dot = size_input_section (prev, output_section_statement,
3180 output_section_statement->fill, dot);
3183 case lang_input_statement_enum:
3185 case lang_fill_statement_enum:
3186 s->fill_statement.output_section =
3187 output_section_statement->bfd_section;
3189 fill = s->fill_statement.fill;
3191 case lang_assignment_statement_enum:
3193 bfd_vma newdot = dot;
3195 exp_fold_tree (s->assignment_statement.exp,
3196 output_section_statement,
3197 lang_allocating_phase_enum,
3203 if (output_section_statement == abs_output_section)
3205 /* If we don't have an output section, then just adjust
3206 the default memory address. */
3207 lang_memory_region_lookup ("*default*")->current = newdot;
3211 /* Insert a pad after this statement. We can't
3212 put the pad before when relaxing, in case the
3213 assignment references dot. */
3214 insert_pad (&s->header.next, fill, (newdot - dot) * opb,
3215 output_section_statement->bfd_section, dot);
3217 /* Don't neuter the pad below when relaxing. */
3226 case lang_padding_statement_enum:
3227 /* If this is the first time lang_size_sections is called,
3228 we won't have any padding statements. If this is the
3229 second or later passes when relaxing, we should allow
3230 padding to shrink. If padding is needed on this pass, it
3231 will be added back in. */
3232 s->padding_statement.size = 0;
3234 /* Make sure output_offset is valid. If relaxation shrinks
3235 the section and this pad isn't needed, it's possible to
3236 have output_offset larger than the final size of the
3237 section. bfd_set_section_contents will complain even for
3238 a pad size of zero. */
3239 s->padding_statement.output_offset
3240 = dot - output_section_statement->bfd_section->vma;
3243 case lang_group_statement_enum:
3244 dot = lang_size_sections_1 (s->group_statement.children.head,
3245 output_section_statement,
3246 &s->group_statement.children.head,
3254 /* We can only get here when relaxing is turned on. */
3255 case lang_address_statement_enum:
3258 prev = &s->header.next;
3264 lang_size_sections (s, output_section_statement, prev, fill, dot, relax)
3265 lang_statement_union_type *s;
3266 lang_output_section_statement_type *output_section_statement;
3267 lang_statement_union_type **prev;
3274 exp_data_seg.phase = exp_dataseg_none;
3275 result = lang_size_sections_1 (s, output_section_statement, prev, fill,
3277 if (exp_data_seg.phase == exp_dataseg_end_seen)
3279 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
3280 a page could be saved in the data segment. */
3281 bfd_vma first, last;
3283 first = -exp_data_seg.base & (exp_data_seg.pagesize - 1);
3284 last = exp_data_seg.end & (exp_data_seg.pagesize - 1);
3286 && ((exp_data_seg.base & ~(exp_data_seg.pagesize - 1))
3287 != (exp_data_seg.end & ~(exp_data_seg.pagesize - 1)))
3288 && first + last <= exp_data_seg.pagesize)
3290 exp_data_seg.phase = exp_dataseg_adjust;
3291 result = lang_size_sections_1 (s, output_section_statement, prev,
3300 lang_do_assignments (s, output_section_statement, fill, dot)
3301 lang_statement_union_type *s;
3302 lang_output_section_statement_type *output_section_statement;
3306 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3307 ldfile_output_machine);
3309 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
3311 switch (s->header.type)
3313 case lang_constructors_statement_enum:
3314 dot = lang_do_assignments (constructor_list.head,
3315 output_section_statement,
3320 case lang_output_section_statement_enum:
3322 lang_output_section_statement_type *os;
3324 os = &(s->output_section_statement);
3325 if (os->bfd_section != NULL)
3327 dot = os->bfd_section->vma;
3328 (void) lang_do_assignments (os->children.head, os,
3330 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
3335 /* If nothing has been placed into the output section then
3336 it won't have a bfd_section. */
3337 if (os->bfd_section)
3339 os->bfd_section->lma
3340 = exp_get_abs_int (os->load_base, 0, "load base",
3341 lang_final_phase_enum);
3346 case lang_wild_statement_enum:
3348 dot = lang_do_assignments (s->wild_statement.children.head,
3349 output_section_statement,
3354 case lang_object_symbols_statement_enum:
3355 case lang_output_statement_enum:
3356 case lang_target_statement_enum:
3358 case lang_common_statement_enum:
3361 case lang_data_statement_enum:
3363 etree_value_type value;
3365 value = exp_fold_tree (s->data_statement.exp,
3367 lang_final_phase_enum, dot, &dot);
3368 s->data_statement.value = value.value;
3369 if (value.valid_p == false)
3370 einfo (_("%F%P: invalid data statement\n"));
3374 switch (s->data_statement.type)
3398 case lang_reloc_statement_enum:
3400 etree_value_type value;
3402 value = exp_fold_tree (s->reloc_statement.addend_exp,
3404 lang_final_phase_enum, dot, &dot);
3405 s->reloc_statement.addend_value = value.value;
3406 if (value.valid_p == false)
3407 einfo (_("%F%P: invalid reloc statement\n"));
3409 dot += bfd_get_reloc_size (s->reloc_statement.howto) / opb;
3412 case lang_input_section_enum:
3414 asection *in = s->input_section.section;
3416 if (in->_cooked_size != 0)
3417 dot += in->_cooked_size / opb;
3419 dot += in->_raw_size / opb;
3423 case lang_input_statement_enum:
3425 case lang_fill_statement_enum:
3426 fill = s->fill_statement.fill;
3428 case lang_assignment_statement_enum:
3430 exp_fold_tree (s->assignment_statement.exp,
3431 output_section_statement,
3432 lang_final_phase_enum,
3438 case lang_padding_statement_enum:
3439 dot += s->padding_statement.size / opb;
3442 case lang_group_statement_enum:
3443 dot = lang_do_assignments (s->group_statement.children.head,
3444 output_section_statement,
3452 case lang_address_statement_enum:
3460 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3461 operator .startof. (section_name), it produces an undefined symbol
3462 .startof.section_name. Similarly, when it sees
3463 .sizeof. (section_name), it produces an undefined symbol
3464 .sizeof.section_name. For all the output sections, we look for
3465 such symbols, and set them to the correct value. */
3472 if (link_info.relocateable)
3475 for (s = output_bfd->sections; s != NULL; s = s->next)
3477 const char *secname;
3479 struct bfd_link_hash_entry *h;
3481 secname = bfd_get_section_name (output_bfd, s);
3482 buf = xmalloc (10 + strlen (secname));
3484 sprintf (buf, ".startof.%s", secname);
3485 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3486 if (h != NULL && h->type == bfd_link_hash_undefined)
3488 h->type = bfd_link_hash_defined;
3489 h->u.def.value = bfd_get_section_vma (output_bfd, s);
3490 h->u.def.section = bfd_abs_section_ptr;
3493 sprintf (buf, ".sizeof.%s", secname);
3494 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3495 if (h != NULL && h->type == bfd_link_hash_undefined)
3499 opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3500 ldfile_output_machine);
3501 h->type = bfd_link_hash_defined;
3502 if (s->_cooked_size != 0)
3503 h->u.def.value = s->_cooked_size / opb;
3505 h->u.def.value = s->_raw_size / opb;
3506 h->u.def.section = bfd_abs_section_ptr;
3516 struct bfd_link_hash_entry *h;
3519 if (link_info.relocateable || link_info.shared)
3524 if (entry_symbol == (char *) NULL)
3526 /* No entry has been specified. Look for start, but don't warn
3527 if we don't find it. */
3528 entry_symbol = "start";
3532 h = bfd_link_hash_lookup (link_info.hash, entry_symbol, false, false, true);
3533 if (h != (struct bfd_link_hash_entry *) NULL
3534 && (h->type == bfd_link_hash_defined
3535 || h->type == bfd_link_hash_defweak)
3536 && h->u.def.section->output_section != NULL)
3540 val = (h->u.def.value
3541 + bfd_get_section_vma (output_bfd,
3542 h->u.def.section->output_section)
3543 + h->u.def.section->output_offset);
3544 if (! bfd_set_start_address (output_bfd, val))
3545 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol);
3552 /* We couldn't find the entry symbol. Try parsing it as a
3554 val = bfd_scan_vma (entry_symbol, &send, 0);
3557 if (! bfd_set_start_address (output_bfd, val))
3558 einfo (_("%P%F: can't set start address\n"));
3564 /* Can't find the entry symbol, and it's not a number. Use
3565 the first address in the text section. */
3566 ts = bfd_get_section_by_name (output_bfd, entry_section);
3567 if (ts != (asection *) NULL)
3570 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3571 entry_symbol, bfd_get_section_vma (output_bfd, ts));
3572 if (! bfd_set_start_address (output_bfd,
3573 bfd_get_section_vma (output_bfd,
3575 einfo (_("%P%F: can't set start address\n"));
3580 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3587 /* This is a small function used when we want to ignore errors from
3591 #ifdef ANSI_PROTOTYPES
3592 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
3594 ignore_bfd_errors (s)
3595 const char *s ATTRIBUTE_UNUSED;
3598 /* Don't do anything. */
3601 /* Check that the architecture of all the input files is compatible
3602 with the output file. Also call the backend to let it do any
3603 other checking that is needed. */
3608 lang_statement_union_type *file;
3610 const bfd_arch_info_type *compatible;
3612 for (file = file_chain.head;
3613 file != (lang_statement_union_type *) NULL;
3614 file = file->input_statement.next)
3616 input_bfd = file->input_statement.the_bfd;
3617 compatible = bfd_arch_get_compatible (input_bfd, output_bfd);
3619 /* In general it is not possible to perform a relocatable
3620 link between differing object formats when the input
3621 file has relocations, because the relocations in the
3622 input format may not have equivalent representations in
3623 the output format (and besides BFD does not translate
3624 relocs for other link purposes than a final link). */
3625 if ((link_info.relocateable || link_info.emitrelocations)
3626 && (compatible == NULL
3627 || bfd_get_flavour (input_bfd) != bfd_get_flavour (output_bfd))
3628 && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
3630 einfo (_("%P%F: Relocatable linking with relocations from format %s (%B) to format %s (%B) is not supported\n"),
3631 bfd_get_target (input_bfd), input_bfd,
3632 bfd_get_target (output_bfd), output_bfd);
3633 /* einfo with %F exits. */
3636 if (compatible == NULL)
3638 if (command_line.warn_mismatch)
3639 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3640 bfd_printable_name (input_bfd), input_bfd,
3641 bfd_printable_name (output_bfd));
3643 else if (bfd_count_sections (input_bfd))
3645 /* If the input bfd has no contents, it shouldn't set the
3646 private data of the output bfd. */
3648 bfd_error_handler_type pfn = NULL;
3650 /* If we aren't supposed to warn about mismatched input
3651 files, temporarily set the BFD error handler to a
3652 function which will do nothing. We still want to call
3653 bfd_merge_private_bfd_data, since it may set up
3654 information which is needed in the output file. */
3655 if (! command_line.warn_mismatch)
3656 pfn = bfd_set_error_handler (ignore_bfd_errors);
3657 if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
3659 if (command_line.warn_mismatch)
3660 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3663 if (! command_line.warn_mismatch)
3664 bfd_set_error_handler (pfn);
3669 /* Look through all the global common symbols and attach them to the
3670 correct section. The -sort-common command line switch may be used
3671 to roughly sort the entries by size. */
3676 if (command_line.inhibit_common_definition)
3678 if (link_info.relocateable
3679 && ! command_line.force_common_definition)
3682 if (! config.sort_common)
3683 bfd_link_hash_traverse (link_info.hash, lang_one_common, (PTR) NULL);
3688 for (power = 4; power >= 0; power--)
3689 bfd_link_hash_traverse (link_info.hash, lang_one_common,
3694 /* Place one common symbol in the correct section. */
3697 lang_one_common (h, info)
3698 struct bfd_link_hash_entry *h;
3701 unsigned int power_of_two;
3704 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3705 ldfile_output_machine);
3707 if (h->type != bfd_link_hash_common)
3711 power_of_two = h->u.c.p->alignment_power;
3713 if (config.sort_common
3714 && power_of_two < (unsigned int) *(int *) info)
3717 section = h->u.c.p->section;
3719 /* Increase the size of the section. */
3720 section->_cooked_size = ALIGN_N ((section->_cooked_size + opb - 1) / opb,
3721 (bfd_size_type) (1 << power_of_two)) * opb;
3723 /* Adjust the alignment if necessary. */
3724 if (power_of_two > section->alignment_power)
3725 section->alignment_power = power_of_two;
3727 /* Change the symbol from common to defined. */
3728 h->type = bfd_link_hash_defined;
3729 h->u.def.section = section;
3730 h->u.def.value = section->_cooked_size;
3732 /* Increase the size of the section. */
3733 section->_cooked_size += size;
3735 /* Make sure the section is allocated in memory, and make sure that
3736 it is no longer a common section. */
3737 section->flags |= SEC_ALLOC;
3738 section->flags &= ~SEC_IS_COMMON;
3740 if (config.map_file != NULL)
3742 static boolean header_printed;
3747 if (! header_printed)
3749 minfo (_("\nAllocating common symbols\n"));
3750 minfo (_("Common symbol size file\n\n"));
3751 header_printed = true;
3754 name = demangle (h->root.string);
3756 len = strlen (name);
3771 if (size <= 0xffffffff)
3772 sprintf (buf, "%lx", (unsigned long) size);
3774 sprintf_vma (buf, size);
3784 minfo ("%B\n", section->owner);
3790 /* Run through the input files and ensure that every input section has
3791 somewhere to go. If one is found without a destination then create
3792 an input request and place it into the statement tree. */
3795 lang_place_orphans ()
3797 LANG_FOR_EACH_INPUT_STATEMENT (file)
3801 for (s = file->the_bfd->sections;
3802 s != (asection *) NULL;
3805 if (s->output_section == (asection *) NULL)
3807 /* This section of the file is not attatched, root
3808 around for a sensible place for it to go. */
3810 if (file->just_syms_flag)
3814 else if (strcmp (s->name, "COMMON") == 0)
3816 /* This is a lonely common section which must have
3817 come from an archive. We attach to the section
3818 with the wildcard. */
3819 if (! link_info.relocateable
3820 || command_line.force_common_definition)
3822 if (default_common_section == NULL)
3825 /* This message happens when using the
3826 svr3.ifile linker script, so I have
3828 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3830 default_common_section =
3831 lang_output_section_statement_lookup (".bss");
3834 lang_add_section (&default_common_section->children, s,
3835 default_common_section, file);
3838 else if (ldemul_place_orphan (file, s))
3842 lang_output_section_statement_type *os;
3844 os = lang_output_section_statement_lookup (s->name);
3845 lang_add_section (&os->children, s, os, file);
3853 lang_set_flags (ptr, flags, invert)
3854 lang_memory_region_type *ptr;
3858 flagword *ptr_flags;
3860 ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
3866 *ptr_flags |= SEC_ALLOC;
3870 *ptr_flags |= SEC_READONLY;
3874 *ptr_flags |= SEC_DATA;
3878 *ptr_flags |= SEC_CODE;
3883 *ptr_flags |= SEC_LOAD;
3887 einfo (_("%P%F: invalid syntax in flags\n"));
3894 /* Call a function on each input file. This function will be called
3895 on an archive, but not on the elements. */
3898 lang_for_each_input_file (func)
3899 void (*func) PARAMS ((lang_input_statement_type *));
3901 lang_input_statement_type *f;
3903 for (f = (lang_input_statement_type *) input_file_chain.head;
3905 f = (lang_input_statement_type *) f->next_real_file)
3909 /* Call a function on each file. The function will be called on all
3910 the elements of an archive which are included in the link, but will
3911 not be called on the archive file itself. */
3914 lang_for_each_file (func)
3915 void (*func) PARAMS ((lang_input_statement_type *));
3917 LANG_FOR_EACH_INPUT_STATEMENT (f)
3928 lang_for_each_input_section (func)
3929 void (*func) PARAMS ((bfd *ab, asection *as));
3931 LANG_FOR_EACH_INPUT_STATEMENT (f)
3935 for (s = f->the_bfd->sections;
3936 s != (asection *) NULL;
3939 func (f->the_bfd, s);
3947 ldlang_add_file (entry)
3948 lang_input_statement_type *entry;
3952 lang_statement_append (&file_chain,
3953 (lang_statement_union_type *) entry,
3956 /* The BFD linker needs to have a list of all input BFDs involved in
3958 ASSERT (entry->the_bfd->link_next == (bfd *) NULL);
3959 ASSERT (entry->the_bfd != output_bfd);
3960 for (pp = &link_info.input_bfds;
3961 *pp != (bfd *) NULL;
3962 pp = &(*pp)->link_next)
3964 *pp = entry->the_bfd;
3965 entry->the_bfd->usrdata = (PTR) entry;
3966 bfd_set_gp_size (entry->the_bfd, g_switch_value);
3968 /* Look through the sections and check for any which should not be
3969 included in the link. We need to do this now, so that we can
3970 notice when the backend linker tries to report multiple
3971 definition errors for symbols which are in sections we aren't
3972 going to link. FIXME: It might be better to entirely ignore
3973 symbols which are defined in sections which are going to be
3974 discarded. This would require modifying the backend linker for
3975 each backend which might set the SEC_LINK_ONCE flag. If we do
3976 this, we should probably handle SEC_EXCLUDE in the same way. */
3978 bfd_map_over_sections (entry->the_bfd, section_already_linked, (PTR) entry);
3982 lang_add_output (name, from_script)
3986 /* Make -o on command line override OUTPUT in script. */
3987 if (had_output_filename == false || !from_script)
3989 output_filename = name;
3990 had_output_filename = true;
3994 static lang_output_section_statement_type *current_section;
4006 for (l = 0; l < 32; l++)
4008 if (i >= (unsigned int) x)
4016 lang_output_section_statement_type *
4017 lang_enter_output_section_statement (output_section_statement_name,
4018 address_exp, sectype, block_value,
4019 align, subalign, ebase)
4020 const char *output_section_statement_name;
4021 etree_type *address_exp;
4022 enum section_type sectype;
4023 bfd_vma block_value;
4025 etree_type *subalign;
4028 lang_output_section_statement_type *os;
4032 lang_output_section_statement_lookup (output_section_statement_name);
4034 /* Add this statement to tree. */
4036 add_statement (lang_output_section_statement_enum,
4037 output_section_statement);
4039 /* Make next things chain into subchain of this. */
4041 if (os->addr_tree == (etree_type *) NULL)
4043 os->addr_tree = address_exp;
4045 os->sectype = sectype;
4046 if (sectype != noload_section)
4047 os->flags = SEC_NO_FLAGS;
4049 os->flags = SEC_NEVER_LOAD;
4050 os->block_value = block_value ? block_value : 1;
4051 stat_ptr = &os->children;
4053 os->subsection_alignment =
4054 topower (exp_get_value_int (subalign, -1, "subsection alignment", 0));
4055 os->section_alignment =
4056 topower (exp_get_value_int (align, -1, "section alignment", 0));
4058 os->load_base = ebase;
4065 lang_output_statement_type *new =
4066 new_stat (lang_output_statement, stat_ptr);
4068 new->name = output_filename;
4071 /* Reset the current counters in the regions. */
4074 lang_reset_memory_regions ()
4076 lang_memory_region_type *p = lang_memory_region_list;
4079 for (p = lang_memory_region_list;
4080 p != (lang_memory_region_type *) NULL;
4083 p->old_length = (bfd_size_type) (p->current - p->origin);
4084 p->current = p->origin;
4087 for (o = output_bfd->sections; o != NULL; o = o->next)
4091 /* If the wild pattern was marked KEEP, the member sections
4092 should be as well. */
4095 gc_section_callback (ptr, sec, section, file, data)
4096 lang_wild_statement_type *ptr;
4097 struct wildcard_list *sec ATTRIBUTE_UNUSED;
4099 lang_input_statement_type *file ATTRIBUTE_UNUSED;
4100 PTR data ATTRIBUTE_UNUSED;
4102 if (ptr->keep_sections)
4103 section->flags |= SEC_KEEP;
4106 /* Handle a wild statement, marking it against GC. */
4110 lang_wild_statement_type *s;
4112 walk_wild (s, gc_section_callback, NULL);
4115 /* Iterate over sections marking them against GC. */
4118 lang_gc_sections_1 (s)
4119 lang_statement_union_type *s;
4121 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
4123 switch (s->header.type)
4125 case lang_wild_statement_enum:
4126 lang_gc_wild (&s->wild_statement);
4128 case lang_constructors_statement_enum:
4129 lang_gc_sections_1 (constructor_list.head);
4131 case lang_output_section_statement_enum:
4132 lang_gc_sections_1 (s->output_section_statement.children.head);
4134 case lang_group_statement_enum:
4135 lang_gc_sections_1 (s->group_statement.children.head);
4146 struct bfd_link_hash_entry *h;
4147 ldlang_undef_chain_list_type *ulist, fake_list_start;
4149 /* Keep all sections so marked in the link script. */
4151 lang_gc_sections_1 (statement_list.head);
4153 /* Keep all sections containing symbols undefined on the command-line.
4154 Handle the entry symbol at the same time. */
4156 if (entry_symbol != NULL)
4158 fake_list_start.next = ldlang_undef_chain_list_head;
4159 fake_list_start.name = (char *) entry_symbol;
4160 ulist = &fake_list_start;
4163 ulist = ldlang_undef_chain_list_head;
4165 for (; ulist; ulist = ulist->next)
4167 h = bfd_link_hash_lookup (link_info.hash, ulist->name,
4168 false, false, false);
4170 if (h != (struct bfd_link_hash_entry *) NULL
4171 && (h->type == bfd_link_hash_defined
4172 || h->type == bfd_link_hash_defweak)
4173 && ! bfd_is_abs_section (h->u.def.section))
4175 h->u.def.section->flags |= SEC_KEEP;
4179 bfd_gc_sections (output_bfd, &link_info);
4185 lang_reasonable_defaults ();
4186 current_target = default_target;
4188 /* Open the output file. */
4189 lang_for_each_statement (ldlang_open_output);
4191 ldemul_create_output_section_statements ();
4193 /* Add to the hash table all undefineds on the command line. */
4194 lang_place_undefineds ();
4196 already_linked_table_init ();
4198 /* Create a bfd for each input file. */
4199 current_target = default_target;
4200 open_input_bfds (statement_list.head, false);
4202 ldemul_after_open ();
4204 already_linked_table_free ();
4206 /* Make sure that we're not mixing architectures. We call this
4207 after all the input files have been opened, but before we do any
4208 other processing, so that any operations merge_private_bfd_data
4209 does on the output file will be known during the rest of the
4213 /* Handle .exports instead of a version script if we're told to do so. */
4214 if (command_line.version_exports_section)
4215 lang_do_version_exports_section ();
4217 /* Build all sets based on the information gathered from the input
4219 ldctor_build_sets ();
4221 /* Remove unreferenced sections if asked to. */
4222 if (command_line.gc_sections)
4223 lang_gc_sections ();
4225 /* If there were any SEC_MERGE sections, finish their merging, so that
4226 section sizes can be computed. This has to be done after GC of sections,
4227 so that GCed sections are not merged, but before assigning output
4228 sections, since removing whole input sections is hard then. */
4229 bfd_merge_sections (output_bfd, &link_info);
4231 /* Size up the common data. */
4234 /* Run through the contours of the script and attach input sections
4235 to the correct output sections. */
4236 map_input_to_output_sections (statement_list.head, (char *) NULL,
4237 (lang_output_section_statement_type *) NULL);
4239 /* Find any sections not attached explicitly and handle them. */
4240 lang_place_orphans ();
4242 if (! link_info.relocateable)
4244 /* Look for a text section and set the readonly attribute in it. */
4245 asection *found = bfd_get_section_by_name (output_bfd, ".text");
4247 if (found != (asection *) NULL)
4249 if (config.text_read_only)
4250 found->flags |= SEC_READONLY;
4252 found->flags &= ~SEC_READONLY;
4256 /* Do anything special before sizing sections. This is where ELF
4257 and other back-ends size dynamic sections. */
4258 ldemul_before_allocation ();
4260 /* We must record the program headers before we try to fix the
4261 section positions, since they will affect SIZEOF_HEADERS. */
4262 lang_record_phdrs ();
4264 /* Size up the sections. */
4265 lang_size_sections (statement_list.head,
4267 &statement_list.head, 0, (bfd_vma) 0, NULL);
4269 /* Now run around and relax if we can. */
4270 if (command_line.relax)
4272 /* Keep relaxing until bfd_relax_section gives up. */
4273 boolean relax_again;
4277 lang_reset_memory_regions ();
4279 relax_again = false;
4281 /* Note: pe-dll.c does something like this also. If you find
4282 you need to change this code, you probably need to change
4283 pe-dll.c also. DJ */
4285 /* Do all the assignments with our current guesses as to
4287 lang_do_assignments (statement_list.head,
4289 (fill_type *) 0, (bfd_vma) 0);
4291 /* Perform another relax pass - this time we know where the
4292 globals are, so can make a better guess. */
4293 lang_size_sections (statement_list.head,
4295 &statement_list.head, 0, (bfd_vma) 0,
4298 while (relax_again);
4301 /* See if anything special should be done now we know how big
4303 ldemul_after_allocation ();
4305 /* Fix any .startof. or .sizeof. symbols. */
4306 lang_set_startof ();
4308 /* Do all the assignments, now that we know the final resting places
4309 of all the symbols. */
4311 lang_do_assignments (statement_list.head,
4313 (fill_type *) 0, (bfd_vma) 0);
4315 /* Make sure that the section addresses make sense. */
4316 if (! link_info.relocateable
4317 && command_line.check_section_addresses)
4318 lang_check_section_addresses ();
4326 /* EXPORTED TO YACC */
4329 lang_add_wild (filespec, section_list, keep_sections)
4330 struct wildcard_spec *filespec;
4331 struct wildcard_list *section_list;
4332 boolean keep_sections;
4334 struct wildcard_list *curr, *next;
4335 lang_wild_statement_type *new;
4337 /* Reverse the list as the parser puts it back to front. */
4338 for (curr = section_list, section_list = NULL;
4340 section_list = curr, curr = next)
4342 if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
4343 placed_commons = true;
4346 curr->next = section_list;
4349 if (filespec != NULL && filespec->name != NULL)
4351 if (strcmp (filespec->name, "*") == 0)
4352 filespec->name = NULL;
4353 else if (! wildcardp (filespec->name))
4354 lang_has_input_file = true;
4357 new = new_stat (lang_wild_statement, stat_ptr);
4358 new->filename = NULL;
4359 new->filenames_sorted = false;
4360 if (filespec != NULL)
4362 new->filename = filespec->name;
4363 new->filenames_sorted = filespec->sorted;
4365 new->section_list = section_list;
4366 new->keep_sections = keep_sections;
4367 lang_list_init (&new->children);
4371 lang_section_start (name, address)
4373 etree_type *address;
4375 lang_address_statement_type *ad;
4377 ad = new_stat (lang_address_statement, stat_ptr);
4378 ad->section_name = name;
4379 ad->address = address;
4382 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4383 because of a -e argument on the command line, or zero if this is
4384 called by ENTRY in a linker script. Command line arguments take
4388 lang_add_entry (name, cmdline)
4392 if (entry_symbol == NULL
4394 || ! entry_from_cmdline)
4396 entry_symbol = name;
4397 entry_from_cmdline = cmdline;
4402 lang_add_target (name)
4405 lang_target_statement_type *new = new_stat (lang_target_statement,
4421 map_option_f = true;
4429 lang_add_fill (fill)
4432 lang_fill_statement_type *new = new_stat (lang_fill_statement,
4439 lang_add_data (type, exp)
4441 union etree_union *exp;
4444 lang_data_statement_type *new = new_stat (lang_data_statement,
4452 /* Create a new reloc statement. RELOC is the BFD relocation type to
4453 generate. HOWTO is the corresponding howto structure (we could
4454 look this up, but the caller has already done so). SECTION is the
4455 section to generate a reloc against, or NAME is the name of the
4456 symbol to generate a reloc against. Exactly one of SECTION and
4457 NAME must be NULL. ADDEND is an expression for the addend. */
4460 lang_add_reloc (reloc, howto, section, name, addend)
4461 bfd_reloc_code_real_type reloc;
4462 reloc_howto_type *howto;
4465 union etree_union *addend;
4467 lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
4471 p->section = section;
4473 p->addend_exp = addend;
4475 p->addend_value = 0;
4476 p->output_section = NULL;
4480 lang_assignment_statement_type *
4481 lang_add_assignment (exp)
4484 lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
4492 lang_add_attribute (attribute)
4493 enum statement_enum attribute;
4495 new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
4502 if (startup_file != (char *) NULL)
4504 einfo (_("%P%Fmultiple STARTUP files\n"));
4506 first_file->filename = name;
4507 first_file->local_sym_name = name;
4508 first_file->real = true;
4510 startup_file = name;
4517 lang_float_flag = maybe;
4521 lang_leave_output_section_statement (fill, memspec, phdrs, lma_memspec)
4523 const char *memspec;
4524 struct lang_output_section_phdr_list *phdrs;
4525 const char *lma_memspec;
4527 current_section->fill = fill;
4528 current_section->region = lang_memory_region_lookup (memspec);
4529 current_section->lma_region = lang_memory_region_lookup (lma_memspec);
4531 /* If no runtime region has been given, but the load region has
4532 been, use the load region. */
4533 if (current_section->lma_region != 0 && strcmp (memspec, "*default*") == 0)
4534 current_section->region = current_section->lma_region;
4536 current_section->phdrs = phdrs;
4537 stat_ptr = &statement_list;
4540 /* Create an absolute symbol with the given name with the value of the
4541 address of first byte of the section named.
4543 If the symbol already exists, then do nothing. */
4546 lang_abs_symbol_at_beginning_of (secname, name)
4547 const char *secname;
4550 struct bfd_link_hash_entry *h;
4552 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4553 if (h == (struct bfd_link_hash_entry *) NULL)
4554 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4556 if (h->type == bfd_link_hash_new
4557 || h->type == bfd_link_hash_undefined)
4561 h->type = bfd_link_hash_defined;
4563 sec = bfd_get_section_by_name (output_bfd, secname);
4564 if (sec == (asection *) NULL)
4567 h->u.def.value = bfd_get_section_vma (output_bfd, sec);
4569 h->u.def.section = bfd_abs_section_ptr;
4573 /* Create an absolute symbol with the given name with the value of the
4574 address of the first byte after the end of the section named.
4576 If the symbol already exists, then do nothing. */
4579 lang_abs_symbol_at_end_of (secname, name)
4580 const char *secname;
4583 struct bfd_link_hash_entry *h;
4585 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4586 if (h == (struct bfd_link_hash_entry *) NULL)
4587 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4589 if (h->type == bfd_link_hash_new
4590 || h->type == bfd_link_hash_undefined)
4594 h->type = bfd_link_hash_defined;
4596 sec = bfd_get_section_by_name (output_bfd, secname);
4597 if (sec == (asection *) NULL)
4600 h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
4601 + bfd_section_size (output_bfd, sec) /
4602 bfd_octets_per_byte (output_bfd));
4604 h->u.def.section = bfd_abs_section_ptr;
4609 lang_statement_append (list, element, field)
4610 lang_statement_list_type *list;
4611 lang_statement_union_type *element;
4612 lang_statement_union_type **field;
4614 *(list->tail) = element;
4618 /* Set the output format type. -oformat overrides scripts. */
4621 lang_add_output_format (format, big, little, from_script)
4627 if (output_target == NULL || !from_script)
4629 if (command_line.endian == ENDIAN_BIG
4632 else if (command_line.endian == ENDIAN_LITTLE
4636 output_target = format;
4640 /* Enter a group. This creates a new lang_group_statement, and sets
4641 stat_ptr to build new statements within the group. */
4646 lang_group_statement_type *g;
4648 g = new_stat (lang_group_statement, stat_ptr);
4649 lang_list_init (&g->children);
4650 stat_ptr = &g->children;
4653 /* Leave a group. This just resets stat_ptr to start writing to the
4654 regular list of statements again. Note that this will not work if
4655 groups can occur inside anything else which can adjust stat_ptr,
4656 but currently they can't. */
4661 stat_ptr = &statement_list;
4664 /* Add a new program header. This is called for each entry in a PHDRS
4665 command in a linker script. */
4668 lang_new_phdr (name, type, filehdr, phdrs, at, flags)
4676 struct lang_phdr *n, **pp;
4678 n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));
4681 n->type = exp_get_value_int (type, 0, "program header type",
4682 lang_final_phase_enum);
4683 n->filehdr = filehdr;
4688 for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
4693 /* Record the program header information in the output BFD. FIXME: We
4694 should not be calling an ELF specific function here. */
4697 lang_record_phdrs ()
4701 struct lang_output_section_phdr_list *last;
4702 struct lang_phdr *l;
4703 lang_statement_union_type *u;
4706 secs = (asection **) xmalloc (alc * sizeof (asection *));
4708 for (l = lang_phdr_list; l != NULL; l = l->next)
4715 for (u = lang_output_section_statement.head;
4717 u = u->output_section_statement.next)
4719 lang_output_section_statement_type *os;
4720 struct lang_output_section_phdr_list *pl;
4722 os = &u->output_section_statement;
4729 if (os->sectype == noload_section
4730 || os->bfd_section == NULL
4731 || (os->bfd_section->flags & SEC_ALLOC) == 0)
4736 if (os->bfd_section == NULL)
4739 for (; pl != NULL; pl = pl->next)
4741 if (strcmp (pl->name, l->name) == 0)
4746 secs = ((asection **)
4747 xrealloc (secs, alc * sizeof (asection *)));
4749 secs[c] = os->bfd_section;
4756 if (l->flags == NULL)
4759 flags = exp_get_vma (l->flags, 0, "phdr flags",
4760 lang_final_phase_enum);
4765 at = exp_get_vma (l->at, 0, "phdr load address",
4766 lang_final_phase_enum);
4768 if (! bfd_record_phdr (output_bfd, l->type,
4769 l->flags != NULL, flags, l->at != NULL,
4770 at, l->filehdr, l->phdrs, c, secs))
4771 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4776 /* Make sure all the phdr assignments succeeded. */
4777 for (u = lang_output_section_statement.head;
4779 u = u->output_section_statement.next)
4781 struct lang_output_section_phdr_list *pl;
4783 if (u->output_section_statement.bfd_section == NULL)
4786 for (pl = u->output_section_statement.phdrs;
4789 if (! pl->used && strcmp (pl->name, "NONE") != 0)
4790 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4791 u->output_section_statement.name, pl->name);
4795 /* Record a list of sections which may not be cross referenced. */
4798 lang_add_nocrossref (l)
4799 struct lang_nocrossref *l;
4801 struct lang_nocrossrefs *n;
4803 n = (struct lang_nocrossrefs *) xmalloc (sizeof *n);
4804 n->next = nocrossref_list;
4806 nocrossref_list = n;
4808 /* Set notice_all so that we get informed about all symbols. */
4809 link_info.notice_all = true;
4812 /* Overlay handling. We handle overlays with some static variables. */
4814 /* The overlay virtual address. */
4815 static etree_type *overlay_vma;
4817 /* An expression for the maximum section size seen so far. */
4818 static etree_type *overlay_max;
4820 /* A list of all the sections in this overlay. */
4822 struct overlay_list {
4823 struct overlay_list *next;
4824 lang_output_section_statement_type *os;
4827 static struct overlay_list *overlay_list;
4829 /* Start handling an overlay. */
4832 lang_enter_overlay (vma_expr)
4833 etree_type *vma_expr;
4835 /* The grammar should prevent nested overlays from occurring. */
4836 ASSERT (overlay_vma == NULL && overlay_max == NULL);
4838 overlay_vma = vma_expr;
4841 /* Start a section in an overlay. We handle this by calling
4842 lang_enter_output_section_statement with the correct VMA.
4843 lang_leave_overlay sets up the LMA and memory regions. */
4846 lang_enter_overlay_section (name)
4849 struct overlay_list *n;
4852 lang_enter_output_section_statement (name, overlay_vma, normal_section,
4855 /* If this is the first section, then base the VMA of future
4856 sections on this one. This will work correctly even if `.' is
4857 used in the addresses. */
4858 if (overlay_list == NULL)
4859 overlay_vma = exp_nameop (ADDR, name);
4861 /* Remember the section. */
4862 n = (struct overlay_list *) xmalloc (sizeof *n);
4863 n->os = current_section;
4864 n->next = overlay_list;
4867 size = exp_nameop (SIZEOF, name);
4869 /* Arrange to work out the maximum section end address. */
4870 if (overlay_max == NULL)
4873 overlay_max = exp_binop (MAX_K, overlay_max, size);
4876 /* Finish a section in an overlay. There isn't any special to do
4880 lang_leave_overlay_section (fill, phdrs)
4882 struct lang_output_section_phdr_list *phdrs;
4889 name = current_section->name;
4891 /* For now, assume that "*default*" is the run-time memory region and
4892 that no load-time region has been specified. It doesn't really
4893 matter what we say here, since lang_leave_overlay will override it. */
4894 lang_leave_output_section_statement (fill, "*default*", phdrs, 0);
4896 /* Define the magic symbols. */
4898 clean = xmalloc (strlen (name) + 1);
4900 for (s1 = name; *s1 != '\0'; s1++)
4901 if (ISALNUM (*s1) || *s1 == '_')
4905 buf = xmalloc (strlen (clean) + sizeof "__load_start_");
4906 sprintf (buf, "__load_start_%s", clean);
4907 lang_add_assignment (exp_assop ('=', buf,
4908 exp_nameop (LOADADDR, name)));
4910 buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
4911 sprintf (buf, "__load_stop_%s", clean);
4912 lang_add_assignment (exp_assop ('=', buf,
4914 exp_nameop (LOADADDR, name),
4915 exp_nameop (SIZEOF, name))));
4920 /* Finish an overlay. If there are any overlay wide settings, this
4921 looks through all the sections in the overlay and sets them. */
4924 lang_leave_overlay (lma_expr, nocrossrefs, fill, memspec, phdrs, lma_memspec)
4925 etree_type *lma_expr;
4928 const char *memspec;
4929 struct lang_output_section_phdr_list *phdrs;
4930 const char *lma_memspec;
4932 lang_memory_region_type *region;
4933 lang_memory_region_type *lma_region;
4934 struct overlay_list *l;
4935 struct lang_nocrossref *nocrossref;
4937 region = lang_memory_region_lookup (memspec);
4938 lma_region = lang_memory_region_lookup (lma_memspec);
4942 /* After setting the size of the last section, set '.' to end of the
4944 if (overlay_list != NULL)
4945 overlay_list->os->update_dot_tree
4946 = exp_assop ('=', ".", exp_binop ('+', overlay_vma, overlay_max));
4951 struct overlay_list *next;
4953 if (fill != (fill_type *) 0 && l->os->fill == (fill_type *) 0)
4956 l->os->region = region;
4957 l->os->lma_region = lma_region;
4959 /* The first section has the load address specified in the
4960 OVERLAY statement. The rest are worked out from that.
4961 The base address is not needed (and should be null) if
4962 an LMA region was specified. */
4964 l->os->load_base = lma_expr;
4965 else if (lma_region == 0)
4966 l->os->load_base = exp_binop ('+',
4967 exp_nameop (LOADADDR, l->next->os->name),
4968 exp_nameop (SIZEOF, l->next->os->name));
4970 if (phdrs != NULL && l->os->phdrs == NULL)
4971 l->os->phdrs = phdrs;
4975 struct lang_nocrossref *nc;
4977 nc = (struct lang_nocrossref *) xmalloc (sizeof *nc);
4978 nc->name = l->os->name;
4979 nc->next = nocrossref;
4988 if (nocrossref != NULL)
4989 lang_add_nocrossref (nocrossref);
4992 overlay_list = NULL;
4996 /* Version handling. This is only useful for ELF. */
4998 /* This global variable holds the version tree that we build. */
5000 struct bfd_elf_version_tree *lang_elf_version_info;
5003 lang_vers_match_lang_c (expr, sym)
5004 struct bfd_elf_version_expr *expr;
5007 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5009 return fnmatch (expr->pattern, sym, 0) == 0;
5013 lang_vers_match_lang_cplusplus (expr, sym)
5014 struct bfd_elf_version_expr *expr;
5020 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5023 alt_sym = cplus_demangle (sym, /* DMGL_NO_TPARAMS */ 0);
5026 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
5027 Should we early out false in this case? */
5028 result = fnmatch (expr->pattern, sym, 0) == 0;
5032 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
5040 lang_vers_match_lang_java (expr, sym)
5041 struct bfd_elf_version_expr *expr;
5047 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5050 alt_sym = cplus_demangle (sym, DMGL_JAVA);
5053 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
5054 Should we early out false in this case? */
5055 result = fnmatch (expr->pattern, sym, 0) == 0;
5059 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
5066 /* This is called for each variable name or match expression. */
5068 struct bfd_elf_version_expr *
5069 lang_new_vers_pattern (orig, new, lang)
5070 struct bfd_elf_version_expr *orig;
5074 struct bfd_elf_version_expr *ret;
5076 ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret);
5080 if (lang == NULL || strcasecmp (lang, "C") == 0)
5081 ret->match = lang_vers_match_lang_c;
5082 else if (strcasecmp (lang, "C++") == 0)
5083 ret->match = lang_vers_match_lang_cplusplus;
5084 else if (strcasecmp (lang, "Java") == 0)
5085 ret->match = lang_vers_match_lang_java;
5088 einfo (_("%X%P: unknown language `%s' in version information\n"),
5090 ret->match = lang_vers_match_lang_c;
5093 return ldemul_new_vers_pattern (ret);
5096 /* This is called for each set of variable names and match
5099 struct bfd_elf_version_tree *
5100 lang_new_vers_node (globals, locals)
5101 struct bfd_elf_version_expr *globals;
5102 struct bfd_elf_version_expr *locals;
5104 struct bfd_elf_version_tree *ret;
5106 ret = (struct bfd_elf_version_tree *) xmalloc (sizeof *ret);
5110 ret->globals = globals;
5111 ret->locals = locals;
5113 ret->name_indx = (unsigned int) -1;
5118 /* This static variable keeps track of version indices. */
5120 static int version_index;
5122 /* This is called when we know the name and dependencies of the
5126 lang_register_vers_node (name, version, deps)
5128 struct bfd_elf_version_tree *version;
5129 struct bfd_elf_version_deps *deps;
5131 struct bfd_elf_version_tree *t, **pp;
5132 struct bfd_elf_version_expr *e1;
5137 if ((name[0] == '\0' && lang_elf_version_info != NULL)
5138 || (lang_elf_version_info && lang_elf_version_info->name[0] == '\0'))
5140 einfo (_("%X%P: anonymous version tag cannot be combined with other version tags\n"));
5144 /* Make sure this node has a unique name. */
5145 for (t = lang_elf_version_info; t != NULL; t = t->next)
5146 if (strcmp (t->name, name) == 0)
5147 einfo (_("%X%P: duplicate version tag `%s'\n"), name);
5149 /* Check the global and local match names, and make sure there
5150 aren't any duplicates. */
5152 for (e1 = version->globals; e1 != NULL; e1 = e1->next)
5154 for (t = lang_elf_version_info; t != NULL; t = t->next)
5156 struct bfd_elf_version_expr *e2;
5158 for (e2 = t->locals; e2 != NULL; e2 = e2->next)
5159 if (strcmp (e1->pattern, e2->pattern) == 0)
5160 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5165 for (e1 = version->locals; e1 != NULL; e1 = e1->next)
5167 for (t = lang_elf_version_info; t != NULL; t = t->next)
5169 struct bfd_elf_version_expr *e2;
5171 for (e2 = t->globals; e2 != NULL; e2 = e2->next)
5172 if (strcmp (e1->pattern, e2->pattern) == 0)
5173 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5178 version->deps = deps;
5179 version->name = name;
5180 if (name[0] != '\0')
5183 version->vernum = version_index;
5186 version->vernum = 0;
5188 for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
5193 /* This is called when we see a version dependency. */
5195 struct bfd_elf_version_deps *
5196 lang_add_vers_depend (list, name)
5197 struct bfd_elf_version_deps *list;
5200 struct bfd_elf_version_deps *ret;
5201 struct bfd_elf_version_tree *t;
5203 ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret);
5206 for (t = lang_elf_version_info; t != NULL; t = t->next)
5208 if (strcmp (t->name, name) == 0)
5210 ret->version_needed = t;
5215 einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
5221 lang_do_version_exports_section ()
5223 struct bfd_elf_version_expr *greg = NULL, *lreg;
5225 LANG_FOR_EACH_INPUT_STATEMENT (is)
5227 asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
5234 len = bfd_section_size (is->the_bfd, sec);
5235 contents = xmalloc (len);
5236 if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
5237 einfo (_("%X%P: unable to read .exports section contents\n"), sec);
5240 while (p < contents + len)
5242 greg = lang_new_vers_pattern (greg, p, NULL);
5243 p = strchr (p, '\0') + 1;
5246 /* Do not free the contents, as we used them creating the regex. */
5248 /* Do not include this section in the link. */
5249 bfd_set_section_flags (is->the_bfd, sec,
5250 bfd_get_section_flags (is->the_bfd, sec) | SEC_EXCLUDE);
5253 lreg = lang_new_vers_pattern (NULL, "*", NULL);
5254 lang_register_vers_node (command_line.version_exports_section,
5255 lang_new_vers_node (greg, lreg), NULL);
5259 lang_add_unique (name)
5262 struct unique_sections *ent;
5264 for (ent = unique_section_list; ent; ent = ent->next)
5265 if (strcmp (ent->name, name) == 0)
5268 ent = (struct unique_sections *) xmalloc (sizeof *ent);
5269 ent->name = xstrdup (name);
5270 ent->next = unique_section_list;
5271 unique_section_list = ent;