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"
45 static lang_statement_union_type *new_statement PARAMS ((enum statement_enum,
47 lang_statement_list_type *));
50 static struct obstack stat_obstack;
52 #define obstack_chunk_alloc xmalloc
53 #define obstack_chunk_free free
54 static const char *startup_file;
55 static lang_statement_list_type input_file_chain;
56 static boolean placed_commons = false;
57 static lang_output_section_statement_type *default_common_section;
58 static boolean map_option_f;
59 static bfd_vma print_dot;
60 static lang_input_statement_type *first_file;
61 static const char *current_target;
62 static const char *output_target;
63 static lang_statement_list_type statement_list;
64 static struct lang_phdr *lang_phdr_list;
66 static void lang_for_each_statement_worker
67 PARAMS ((void (*) (lang_statement_union_type *),
68 lang_statement_union_type *));
69 static lang_input_statement_type *new_afile
70 PARAMS ((const char *, lang_input_file_enum_type, const char *, boolean));
71 static lang_memory_region_type *lang_memory_default PARAMS ((asection *));
72 static void lang_map_flags PARAMS ((flagword));
73 static void init_os PARAMS ((lang_output_section_statement_type *));
74 static void exp_init_os PARAMS ((etree_type *));
75 static void section_already_linked PARAMS ((bfd *, asection *, PTR));
76 static struct bfd_hash_entry *already_linked_newfunc
77 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
78 static void already_linked_table_init PARAMS ((void));
79 static void already_linked_table_free PARAMS ((void));
80 static boolean wildcardp PARAMS ((const char *));
81 static lang_statement_union_type *wild_sort
82 PARAMS ((lang_wild_statement_type *, lang_input_statement_type *,
84 static void output_section_callback
85 PARAMS ((lang_wild_statement_type *, asection *,
86 lang_input_statement_type *, PTR));
87 static lang_input_statement_type *lookup_name PARAMS ((const char *));
88 static void load_symbols
89 PARAMS ((lang_input_statement_type *, lang_statement_list_type *));
91 PARAMS ((lang_wild_statement_type *, const char *, const char *,
92 const char *, lang_output_section_statement_type *));
93 static bfd *open_output PARAMS ((const char *));
94 static void ldlang_open_output PARAMS ((lang_statement_union_type *));
95 static void open_input_bfds PARAMS ((lang_statement_union_type *, boolean));
96 static void lang_reasonable_defaults PARAMS ((void));
97 static void lang_place_undefineds PARAMS ((void));
98 static void map_input_to_output_sections
99 PARAMS ((lang_statement_union_type *, const char *,
100 lang_output_section_statement_type *));
101 static void print_output_section_statement
102 PARAMS ((lang_output_section_statement_type *));
103 static void print_assignment
104 PARAMS ((lang_assignment_statement_type *,
105 lang_output_section_statement_type *));
106 static void print_input_statement PARAMS ((lang_input_statement_type *));
107 static boolean print_one_symbol PARAMS ((struct bfd_link_hash_entry *, PTR));
108 static void print_input_section PARAMS ((lang_input_section_type *));
109 static void print_fill_statement PARAMS ((lang_fill_statement_type *));
110 static void print_data_statement PARAMS ((lang_data_statement_type *));
111 static void print_address_statement PARAMS ((lang_address_statement_type *));
112 static void print_reloc_statement PARAMS ((lang_reloc_statement_type *));
113 static void print_padding_statement PARAMS ((lang_padding_statement_type *));
114 static void print_wild_statement
115 PARAMS ((lang_wild_statement_type *, lang_output_section_statement_type *));
116 static void print_group
117 PARAMS ((lang_group_statement_type *, lang_output_section_statement_type *));
118 static void print_statement
119 PARAMS ((lang_statement_union_type *, lang_output_section_statement_type *));
120 static void print_statement_list
121 PARAMS ((lang_statement_union_type *, lang_output_section_statement_type *));
122 static void print_statements PARAMS ((void));
123 static bfd_vma insert_pad
124 PARAMS ((lang_statement_union_type **, fill_type,
125 unsigned int, asection *, bfd_vma));
126 static bfd_vma size_input_section
127 PARAMS ((lang_statement_union_type **, lang_output_section_statement_type *,
128 fill_type, bfd_vma, boolean));
129 static void lang_finish PARAMS ((void));
130 static void ignore_bfd_errors PARAMS ((const char *, ...));
131 static void record_bfd_errors PARAMS ((const char *, ...));
132 static void lang_check PARAMS ((void));
133 static void lang_common PARAMS ((void));
134 static boolean lang_one_common PARAMS ((struct bfd_link_hash_entry *, PTR));
135 static void lang_place_orphans PARAMS ((void));
136 static int topower PARAMS ((int));
137 static void lang_set_startof PARAMS ((void));
138 static void reset_memory_regions PARAMS ((void));
139 static void gc_section_callback
140 PARAMS ((lang_wild_statement_type *, asection *,
141 lang_input_statement_type *, PTR));
142 static void lang_record_phdrs PARAMS ((void));
143 static void lang_gc_wild
144 PARAMS ((lang_wild_statement_type *, const char *, const char *));
145 static void lang_gc_sections_1 PARAMS ((lang_statement_union_type *));
146 static void lang_gc_sections PARAMS ((void));
147 static int lang_vers_match_lang_c
148 PARAMS ((struct bfd_elf_version_expr *, const char *));
149 static int lang_vers_match_lang_cplusplus
150 PARAMS ((struct bfd_elf_version_expr *, const char *));
151 static int lang_vers_match_lang_java
152 PARAMS ((struct bfd_elf_version_expr *, const char *));
153 static void lang_do_version_exports_section PARAMS ((void));
154 static void lang_check_section_addresses PARAMS ((void));
155 static void os_region_check
156 PARAMS ((lang_output_section_statement_type *,
157 struct memory_region_struct *, etree_type *, bfd_vma));
159 typedef void (*callback_t) PARAMS ((lang_wild_statement_type *,
160 asection *, lang_input_statement_type *,
162 static void walk_wild
163 PARAMS ((lang_wild_statement_type *, const char *, const char *,
165 static void walk_wild_section
166 PARAMS ((lang_wild_statement_type *, const char *,
167 lang_input_statement_type *, callback_t, PTR));
168 static void walk_wild_file
169 PARAMS ((lang_wild_statement_type *, const char *,
170 lang_input_statement_type *, callback_t, PTR));
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 boolean entry_from_cmdline;
186 boolean lang_has_input_file = false;
187 boolean had_output_filename = false;
188 boolean lang_float_flag = false;
189 boolean delete_output_file_on_failure = false;
190 struct lang_nocrossrefs *nocrossref_list;
191 struct unique_sections *unique_section_list;
193 etree_type *base; /* Relocation base - or null */
195 #if defined(__STDC__) || defined(ALMOST_STDC)
196 #define cat(a,b) a##b
198 #define cat(a,b) a/**/b
201 /* Don't beautify the line below with "innocent" whitespace, it breaks the K&R C preprocessor! */
202 #define new_stat(x, y) (cat (x,_type)*) new_statement (cat (x,_enum), sizeof (cat (x,_type)), y)
204 #define outside_section_address(q) ((q)->output_offset + (q)->output_section->vma)
206 #define outside_symbol_address(q) ((q)->value + outside_section_address (q->section))
208 #define SECTION_NAME_MAP_LENGTH (16)
214 return obstack_alloc (&stat_obstack, size);
218 unique_section_p (secnam)
221 struct unique_sections *unam;
223 for (unam = unique_section_list; unam; unam = unam->next)
224 if (wildcardp (unam->name)
225 ? fnmatch (unam->name, secnam, 0) == 0
226 : strcmp (unam->name, secnam) == 0)
234 /* Generic traversal routines for finding matching sections. */
237 walk_wild_section (ptr, section, file, callback, data)
238 lang_wild_statement_type *ptr;
240 lang_input_statement_type *file;
244 /* Don't process sections from files which were excluded. */
245 if (ptr->exclude_filename_list != NULL)
247 struct name_list *list_tmp;
248 for (list_tmp = ptr->exclude_filename_list; list_tmp; list_tmp = list_tmp->next)
252 if (wildcardp (list_tmp->name))
253 match = fnmatch (list_tmp->name, file->filename, 0) == 0 ? true : false;
255 match = strcmp (list_tmp->name, file->filename) == 0 ? true : false;
262 if (file->just_syms_flag == false)
264 register asection *s;
265 boolean wildcard = false;
268 wildcard = wildcardp (section);
270 for (s = file->the_bfd->sections; s != NULL; s = s->next)
273 const char *sname = bfd_get_section_name (file->the_bfd, s);
278 match = fnmatch (section, sname, 0) == 0 ? true : false;
280 match = strcmp (section, sname) == 0 ? true : false;
282 /* If this is a wild-card output section statement, exclude
283 sections that match UNIQUE_SECTION_LIST. */
284 if (match && (data == NULL || !unique_section_p (sname)))
285 (*callback) (ptr, s, file, data);
290 /* Handle a wild statement for a single file F. */
293 walk_wild_file (s, section, f, callback, data)
294 lang_wild_statement_type *s;
296 lang_input_statement_type *f;
300 if (f->the_bfd == NULL
301 || ! bfd_check_format (f->the_bfd, bfd_archive))
302 walk_wild_section (s, section, f, callback, data);
307 /* This is an archive file. We must map each member of the
308 archive separately. */
309 member = bfd_openr_next_archived_file (f->the_bfd, (bfd *) NULL);
310 while (member != NULL)
312 /* When lookup_name is called, it will call the add_symbols
313 entry point for the archive. For each element of the
314 archive which is included, BFD will call ldlang_add_file,
315 which will set the usrdata field of the member to the
316 lang_input_statement. */
317 if (member->usrdata != NULL)
319 walk_wild_section (s, section,
320 (lang_input_statement_type *) member->usrdata,
324 member = bfd_openr_next_archived_file (f->the_bfd, member);
330 walk_wild (s, section, file, callback, data)
331 lang_wild_statement_type *s;
337 if (file == (char *) NULL)
339 /* Perform the iteration over all files in the list. */
340 LANG_FOR_EACH_INPUT_STATEMENT (f)
342 walk_wild_file (s, section, f, callback, data);
345 else if (wildcardp (file))
347 LANG_FOR_EACH_INPUT_STATEMENT (f)
349 if (fnmatch (file, f->filename, FNM_FILE_NAME) == 0)
350 walk_wild_file (s, section, f, callback, data);
355 lang_input_statement_type *f;
357 /* Perform the iteration over a single file. */
358 f = lookup_name (file);
359 walk_wild_file (s, section, f, callback, data);
363 /* lang_for_each_statement walks the parse tree and calls the provided
364 function for each node. */
367 lang_for_each_statement_worker (func, s)
368 void (*func) PARAMS ((lang_statement_union_type *));
369 lang_statement_union_type *s;
371 for (; s != (lang_statement_union_type *) NULL; s = s->next)
375 switch (s->header.type)
377 case lang_constructors_statement_enum:
378 lang_for_each_statement_worker (func, constructor_list.head);
380 case lang_output_section_statement_enum:
381 lang_for_each_statement_worker
383 s->output_section_statement.children.head);
385 case lang_wild_statement_enum:
386 lang_for_each_statement_worker
388 s->wild_statement.children.head);
390 case lang_group_statement_enum:
391 lang_for_each_statement_worker (func,
392 s->group_statement.children.head);
394 case lang_data_statement_enum:
395 case lang_reloc_statement_enum:
396 case lang_object_symbols_statement_enum:
397 case lang_output_statement_enum:
398 case lang_target_statement_enum:
399 case lang_input_section_enum:
400 case lang_input_statement_enum:
401 case lang_assignment_statement_enum:
402 case lang_padding_statement_enum:
403 case lang_address_statement_enum:
404 case lang_fill_statement_enum:
414 lang_for_each_statement (func)
415 void (*func) PARAMS ((lang_statement_union_type *));
417 lang_for_each_statement_worker (func, statement_list.head);
420 /*----------------------------------------------------------------------*/
423 lang_list_init (list)
424 lang_statement_list_type *list;
426 list->head = (lang_statement_union_type *) NULL;
427 list->tail = &list->head;
430 /* Build a new statement node for the parse tree. */
432 static lang_statement_union_type *
433 new_statement (type, size, list)
434 enum statement_enum type;
436 lang_statement_list_type *list;
438 lang_statement_union_type *new = (lang_statement_union_type *)
441 new->header.type = type;
442 new->header.next = (lang_statement_union_type *) NULL;
443 lang_statement_append (list, new, &new->header.next);
447 /* Build a new input file node for the language. There are several
448 ways in which we treat an input file, eg, we only look at symbols,
449 or prefix it with a -l etc.
451 We can be supplied with requests for input files more than once;
452 they may, for example be split over serveral lines like foo.o(.text)
453 foo.o(.data) etc, so when asked for a file we check that we havn't
454 got it already so we don't duplicate the bfd. */
456 static lang_input_statement_type *
457 new_afile (name, file_type, target, add_to_list)
459 lang_input_file_enum_type file_type;
463 lang_input_statement_type *p;
466 p = new_stat (lang_input_statement, stat_ptr);
469 p = ((lang_input_statement_type *)
470 stat_alloc (sizeof (lang_input_statement_type)));
471 p->header.next = NULL;
474 lang_has_input_file = true;
478 case lang_input_file_is_symbols_only_enum:
480 p->is_archive = false;
482 p->local_sym_name = name;
483 p->just_syms_flag = true;
484 p->search_dirs_flag = false;
486 case lang_input_file_is_fake_enum:
488 p->is_archive = false;
490 p->local_sym_name = name;
491 p->just_syms_flag = false;
492 p->search_dirs_flag = false;
494 case lang_input_file_is_l_enum:
495 p->is_archive = true;
498 p->local_sym_name = concat ("-l", name, (const char *) NULL);
499 p->just_syms_flag = false;
500 p->search_dirs_flag = true;
502 case lang_input_file_is_marker_enum:
504 p->is_archive = false;
506 p->local_sym_name = name;
507 p->just_syms_flag = false;
508 p->search_dirs_flag = true;
510 case lang_input_file_is_search_file_enum:
512 p->is_archive = false;
514 p->local_sym_name = name;
515 p->just_syms_flag = false;
516 p->search_dirs_flag = true;
518 case lang_input_file_is_file_enum:
520 p->is_archive = false;
522 p->local_sym_name = name;
523 p->just_syms_flag = false;
524 p->search_dirs_flag = false;
529 p->the_bfd = (bfd *) NULL;
530 p->asymbols = (asymbol **) NULL;
531 p->next_real_file = (lang_statement_union_type *) NULL;
532 p->next = (lang_statement_union_type *) NULL;
534 p->dynamic = config.dynamic_link;
535 p->whole_archive = whole_archive;
537 lang_statement_append (&input_file_chain,
538 (lang_statement_union_type *) p,
543 lang_input_statement_type *
544 lang_add_input_file (name, file_type, target)
546 lang_input_file_enum_type file_type;
549 lang_has_input_file = true;
550 return new_afile (name, file_type, target, true);
553 /* Build enough state so that the parser can build its tree. */
558 obstack_begin (&stat_obstack, 1000);
560 stat_ptr = &statement_list;
562 lang_list_init (stat_ptr);
564 lang_list_init (&input_file_chain);
565 lang_list_init (&lang_output_section_statement);
566 lang_list_init (&file_chain);
567 first_file = lang_add_input_file ((char *) NULL,
568 lang_input_file_is_marker_enum,
571 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME);
573 abs_output_section->bfd_section = bfd_abs_section_ptr;
577 /*----------------------------------------------------------------------
578 A region is an area of memory declared with the
579 MEMORY { name:org=exp, len=exp ... }
582 We maintain a list of all the regions here.
584 If no regions are specified in the script, then the default is used
585 which is created when looked up to be the entire data space. */
587 static lang_memory_region_type *lang_memory_region_list;
588 static lang_memory_region_type **lang_memory_region_list_tail = &lang_memory_region_list;
590 lang_memory_region_type *
591 lang_memory_region_lookup (name)
592 const char *const name;
594 lang_memory_region_type *p;
596 for (p = lang_memory_region_list;
597 p != (lang_memory_region_type *) NULL;
600 if (strcmp (p->name, name) == 0)
607 /* This code used to always use the first region in the list as the
608 default region. I changed it to instead use a region
609 encompassing all of memory as the default region. This permits
610 NOLOAD sections to work reasonably without requiring a region.
611 People should specify what region they mean, if they really want
613 if (strcmp (name, "*default*") == 0)
615 if (lang_memory_region_list != (lang_memory_region_type *) NULL)
617 return lang_memory_region_list;
623 lang_memory_region_type *new =
624 (lang_memory_region_type *) stat_alloc (sizeof (lang_memory_region_type));
626 new->name = buystring (name);
627 new->next = (lang_memory_region_type *) NULL;
629 *lang_memory_region_list_tail = new;
630 lang_memory_region_list_tail = &new->next;
634 new->length = ~(bfd_size_type) 0;
636 new->had_full_message = false;
642 static lang_memory_region_type *
643 lang_memory_default (section)
646 lang_memory_region_type *p;
648 flagword sec_flags = section->flags;
650 /* Override SEC_DATA to mean a writable section. */
651 if ((sec_flags & (SEC_ALLOC | SEC_READONLY | SEC_CODE)) == SEC_ALLOC)
652 sec_flags |= SEC_DATA;
654 for (p = lang_memory_region_list;
655 p != (lang_memory_region_type *) NULL;
658 if ((p->flags & sec_flags) != 0
659 && (p->not_flags & sec_flags) == 0)
664 return lang_memory_region_lookup ("*default*");
667 lang_output_section_statement_type *
668 lang_output_section_find (name)
669 const char *const name;
671 lang_statement_union_type *u;
672 lang_output_section_statement_type *lookup;
674 for (u = lang_output_section_statement.head;
675 u != (lang_statement_union_type *) NULL;
678 lookup = &u->output_section_statement;
679 if (strcmp (name, lookup->name) == 0)
684 return (lang_output_section_statement_type *) NULL;
687 lang_output_section_statement_type *
688 lang_output_section_statement_lookup (name)
689 const char *const name;
691 lang_output_section_statement_type *lookup;
693 lookup = lang_output_section_find (name);
694 if (lookup == (lang_output_section_statement_type *) NULL)
697 lookup = (lang_output_section_statement_type *)
698 new_stat (lang_output_section_statement, stat_ptr);
699 lookup->region = (lang_memory_region_type *) NULL;
700 lookup->lma_region = (lang_memory_region_type *) NULL;
702 lookup->block_value = 1;
705 lookup->next = (lang_statement_union_type *) NULL;
706 lookup->bfd_section = (asection *) NULL;
707 lookup->processed = false;
708 lookup->sectype = normal_section;
709 lookup->addr_tree = (etree_type *) NULL;
710 lang_list_init (&lookup->children);
712 lookup->memspec = (const char *) NULL;
714 lookup->subsection_alignment = -1;
715 lookup->section_alignment = -1;
716 lookup->load_base = (union etree_union *) NULL;
717 lookup->phdrs = NULL;
719 lang_statement_append (&lang_output_section_statement,
720 (lang_statement_union_type *) lookup,
727 lang_map_flags (flag)
730 if (flag & SEC_ALLOC)
736 if (flag & SEC_READONLY)
749 lang_memory_region_type *m;
751 minfo (_("\nMemory Configuration\n\n"));
752 fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
753 _("Name"), _("Origin"), _("Length"), _("Attributes"));
755 for (m = lang_memory_region_list;
756 m != (lang_memory_region_type *) NULL;
762 fprintf (config.map_file, "%-16s ", m->name);
764 sprintf_vma (buf, m->origin);
765 minfo ("0x%s ", buf);
773 minfo ("0x%V", m->length);
774 if (m->flags || m->not_flags)
782 lang_map_flags (m->flags);
788 lang_map_flags (m->not_flags);
795 fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
800 /* Initialize an output section. */
804 lang_output_section_statement_type *s;
806 section_userdata_type *new;
808 if (s->bfd_section != NULL)
811 if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
812 einfo (_("%P%F: Illegal use of `%s' section"), DISCARD_SECTION_NAME);
814 new = ((section_userdata_type *)
815 stat_alloc (sizeof (section_userdata_type)));
817 s->bfd_section = bfd_get_section_by_name (output_bfd, s->name);
818 if (s->bfd_section == (asection *) NULL)
819 s->bfd_section = bfd_make_section (output_bfd, s->name);
820 if (s->bfd_section == (asection *) NULL)
822 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
823 output_bfd->xvec->name, s->name);
825 s->bfd_section->output_section = s->bfd_section;
827 /* We initialize an output sections output offset to minus its own
828 vma to allow us to output a section through itself. */
829 s->bfd_section->output_offset = 0;
830 get_userdata (s->bfd_section) = (PTR) new;
832 /* If there is a base address, make sure that any sections it might
833 mention are initialized. */
834 if (s->addr_tree != NULL)
835 exp_init_os (s->addr_tree);
838 /* Make sure that all output sections mentioned in an expression are
845 switch (exp->type.node_class)
848 exp_init_os (exp->assign.src);
852 exp_init_os (exp->binary.lhs);
853 exp_init_os (exp->binary.rhs);
857 exp_init_os (exp->trinary.cond);
858 exp_init_os (exp->trinary.lhs);
859 exp_init_os (exp->trinary.rhs);
863 exp_init_os (exp->unary.child);
867 switch (exp->type.node_code)
873 lang_output_section_statement_type *os;
875 os = lang_output_section_find (exp->name.name);
876 if (os != NULL && os->bfd_section == NULL)
887 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
888 once into the output. This routine checks each section, and
889 arrange to discard it if a section of the same name has already
890 been linked. If the section has COMDAT information, then it uses
891 that to decide whether the section should be included. This code
892 assumes that all relevant sections have the SEC_LINK_ONCE flag set;
893 that is, it does not depend solely upon the section name.
894 section_already_linked is called via bfd_map_over_sections. */
896 /* This is the shape of the elements inside the already_linked hash
897 table. It maps a name onto a list of already_linked elements with
898 the same name. It's possible to get more than one element in a
899 list if the COMDAT sections have different names. */
901 struct already_linked_hash_entry
903 struct bfd_hash_entry root;
904 struct already_linked *entry;
907 struct already_linked
909 struct already_linked *next;
913 /* The hash table. */
915 static struct bfd_hash_table already_linked_table;
918 section_already_linked (abfd, sec, data)
923 lang_input_statement_type *entry = (lang_input_statement_type *) data;
926 struct already_linked *l;
927 struct already_linked_hash_entry *already_linked_list;
929 /* If we are only reading symbols from this object, then we want to
930 discard all sections. */
931 if (entry->just_syms_flag)
933 sec->output_section = bfd_abs_section_ptr;
934 sec->output_offset = sec->vma;
938 flags = bfd_get_section_flags (abfd, sec);
940 if ((flags & SEC_LINK_ONCE) == 0)
943 /* FIXME: When doing a relocatable link, we may have trouble
944 copying relocations in other sections that refer to local symbols
945 in the section being discarded. Those relocations will have to
946 be converted somehow; as of this writing I'm not sure that any of
947 the backends handle that correctly.
949 It is tempting to instead not discard link once sections when
950 doing a relocatable link (technically, they should be discarded
951 whenever we are building constructors). However, that fails,
952 because the linker winds up combining all the link once sections
953 into a single large link once section, which defeats the purpose
954 of having link once sections in the first place.
956 Also, not merging link once sections in a relocatable link
957 causes trouble for MIPS ELF, which relies in link once semantics
958 to handle the .reginfo section correctly. */
960 name = bfd_get_section_name (abfd, sec);
962 already_linked_list =
963 ((struct already_linked_hash_entry *)
964 bfd_hash_lookup (&already_linked_table, name, true, false));
966 for (l = already_linked_list->entry; l != NULL; l = l->next)
968 if (sec->comdat == NULL
969 || l->sec->comdat == NULL
970 || strcmp (sec->comdat->name, l->sec->comdat->name) == 0)
972 /* The section has already been linked. See if we should
974 switch (flags & SEC_LINK_DUPLICATES)
979 case SEC_LINK_DUPLICATES_DISCARD:
982 case SEC_LINK_DUPLICATES_ONE_ONLY:
983 if (sec->comdat == NULL)
984 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
987 einfo (_("%P: %B: warning: ignoring duplicate `%s' section symbol `%s'\n"),
988 abfd, name, sec->comdat->name);
991 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
992 /* FIXME: We should really dig out the contents of both
993 sections and memcmp them. The COFF/PE spec says that
994 the Microsoft linker does not implement this
995 correctly, so I'm not going to bother doing it
998 case SEC_LINK_DUPLICATES_SAME_SIZE:
999 if (bfd_section_size (abfd, sec)
1000 != bfd_section_size (l->sec->owner, l->sec))
1001 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
1006 /* Set the output_section field so that wild_doit does not
1007 create a lang_input_section structure for this section.
1008 Since there might be a symbol in the section being
1009 discarded, we must retain a pointer to the section which
1010 we are really going to use. */
1011 sec->output_section = bfd_abs_section_ptr;
1012 sec->kept_section = l->sec;
1018 /* This is the first section with this name. Record it. Allocate
1019 the memory from the same obstack as the hash table is kept in. */
1021 l = ((struct already_linked *)
1022 bfd_hash_allocate (&already_linked_table, sizeof *l));
1025 l->next = already_linked_list->entry;
1026 already_linked_list->entry = l;
1029 /* Support routines for the hash table used by section_already_linked,
1030 initialize the table, fill in an entry and remove the table. */
1032 static struct bfd_hash_entry *
1033 already_linked_newfunc (entry, table, string)
1034 struct bfd_hash_entry *entry ATTRIBUTE_UNUSED;
1035 struct bfd_hash_table *table;
1036 const char *string ATTRIBUTE_UNUSED;
1038 struct already_linked_hash_entry *ret =
1039 bfd_hash_allocate (table, sizeof (struct already_linked_hash_entry));
1043 return (struct bfd_hash_entry *) ret;
1047 already_linked_table_init ()
1049 if (! bfd_hash_table_init_n (&already_linked_table,
1050 already_linked_newfunc,
1052 einfo (_("%P%F: Failed to create hash table\n"));
1056 already_linked_table_free ()
1058 bfd_hash_table_free (&already_linked_table);
1061 /* The wild routines.
1063 These expand statements like *(.text) and foo.o to a list of
1064 explicit actions, like foo.o(.text), bar.o(.text) and
1065 foo.o(.text, .data). */
1067 /* Return true if the PATTERN argument is a wildcard pattern.
1068 Although backslashes are treated specially if a pattern contains
1069 wildcards, we do not consider the mere presence of a backslash to
1070 be enough to cause the the pattern to be treated as a wildcard.
1071 That lets us handle DOS filenames more naturally. */
1075 const char *pattern;
1079 for (s = pattern; *s != '\0'; ++s)
1087 /* Add SECTION to the output section OUTPUT. Do this by creating a
1088 lang_input_section statement which is placed at PTR. FILE is the
1089 input file which holds SECTION. */
1092 wild_doit (ptr, section, output, file)
1093 lang_statement_list_type *ptr;
1095 lang_output_section_statement_type *output;
1096 lang_input_statement_type *file;
1101 flags = bfd_get_section_flags (section->owner, section);
1105 /* If we are doing a final link, discard sections marked with
1107 if (! link_info.relocateable
1108 && (flags & SEC_EXCLUDE) != 0)
1111 /* Discard input sections which are assigned to a section named
1112 DISCARD_SECTION_NAME. */
1113 if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
1116 /* Discard debugging sections if we are stripping debugging
1118 if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
1119 && (flags & SEC_DEBUGGING) != 0)
1124 if (section->output_section == NULL)
1126 /* This prevents future calls from assigning this section. */
1127 section->output_section = bfd_abs_section_ptr;
1132 if (section->output_section == NULL)
1135 lang_input_section_type *new;
1138 if (output->bfd_section == NULL)
1146 /* Add a section reference to the list. */
1147 new = new_stat (lang_input_section, ptr);
1149 new->section = section;
1151 section->output_section = output->bfd_section;
1153 flags = section->flags;
1155 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1156 to an output section, because we want to be able to include a
1157 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1158 section (I don't know why we want to do this, but we do).
1159 build_link_order in ldwrite.c handles this case by turning
1160 the embedded SEC_NEVER_LOAD section into a fill. */
1162 flags &= ~ SEC_NEVER_LOAD;
1164 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1165 already been processed. One reason to do this is that on pe
1166 format targets, .text$foo sections go into .text and it's odd
1167 to see .text with SEC_LINK_ONCE set. */
1169 if (! link_info.relocateable)
1170 flags &= ~ (SEC_LINK_ONCE | SEC_LINK_DUPLICATES);
1172 /* If this is not the first input section, and the SEC_READONLY
1173 flag is not currently set, then don't set it just because the
1174 input section has it set. */
1176 if (! first && (section->output_section->flags & SEC_READONLY) == 0)
1177 flags &= ~ SEC_READONLY;
1179 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
1181 && ((section->output_section->flags & (SEC_MERGE | SEC_STRINGS))
1182 != (flags & (SEC_MERGE | SEC_STRINGS))
1183 || ((flags & SEC_MERGE)
1184 && section->output_section->entsize != section->entsize)))
1186 section->output_section->flags &= ~ (SEC_MERGE | SEC_STRINGS);
1187 flags &= ~ (SEC_MERGE | SEC_STRINGS);
1190 section->output_section->flags |= flags;
1192 if (flags & SEC_MERGE)
1193 section->output_section->entsize = section->entsize;
1195 /* If SEC_READONLY is not set in the input section, then clear
1196 it from the output section. */
1197 if ((section->flags & SEC_READONLY) == 0)
1198 section->output_section->flags &= ~SEC_READONLY;
1200 switch (output->sectype)
1202 case normal_section:
1207 case overlay_section:
1208 output->bfd_section->flags &= ~SEC_ALLOC;
1210 case noload_section:
1211 output->bfd_section->flags &= ~SEC_LOAD;
1212 output->bfd_section->flags |= SEC_NEVER_LOAD;
1216 /* Copy over SEC_SMALL_DATA. */
1217 if (section->flags & SEC_SMALL_DATA)
1218 section->output_section->flags |= SEC_SMALL_DATA;
1220 if (section->alignment_power > output->bfd_section->alignment_power)
1221 output->bfd_section->alignment_power = section->alignment_power;
1223 /* If supplied an aligment, then force it. */
1224 if (output->section_alignment != -1)
1225 output->bfd_section->alignment_power = output->section_alignment;
1227 if (section->flags & SEC_BLOCK)
1229 section->output_section->flags |= SEC_BLOCK;
1230 /* FIXME: This value should really be obtained from the bfd... */
1231 output->block_value = 128;
1236 /* Handle wildcard sorting. This returns the lang_input_section which
1237 should follow the one we are going to create for SECTION and FILE,
1238 based on the sorting requirements of WILD. It returns NULL if the
1239 new section should just go at the end of the current list. */
1241 static lang_statement_union_type *
1242 wild_sort (wild, file, section)
1243 lang_wild_statement_type *wild;
1244 lang_input_statement_type *file;
1247 const char *section_name;
1248 lang_statement_union_type *l;
1250 if (! wild->filenames_sorted && ! wild->sections_sorted)
1253 section_name = bfd_get_section_name (file->the_bfd, section);
1254 for (l = wild->children.head; l != NULL; l = l->next)
1256 lang_input_section_type *ls;
1258 if (l->header.type != lang_input_section_enum)
1260 ls = &l->input_section;
1262 /* Sorting by filename takes precedence over sorting by section
1265 if (wild->filenames_sorted)
1267 const char *fn, *ln;
1271 /* The PE support for the .idata section as generated by
1272 dlltool assumes that files will be sorted by the name of
1273 the archive and then the name of the file within the
1276 if (file->the_bfd != NULL
1277 && bfd_my_archive (file->the_bfd) != NULL)
1279 fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
1284 fn = file->filename;
1288 if (ls->ifile->the_bfd != NULL
1289 && bfd_my_archive (ls->ifile->the_bfd) != NULL)
1291 ln = bfd_get_filename (bfd_my_archive (ls->ifile->the_bfd));
1296 ln = ls->ifile->filename;
1300 i = strcmp (fn, ln);
1309 fn = file->filename;
1311 ln = ls->ifile->filename;
1313 i = strcmp (fn, ln);
1321 /* Here either the files are not sorted by name, or we are
1322 looking at the sections for this file. */
1324 if (wild->sections_sorted)
1326 if (strcmp (section_name,
1327 bfd_get_section_name (ls->ifile->the_bfd,
1337 /* Expand a wild statement for a particular FILE. SECTION may be
1338 NULL, in which case it is a wild card. */
1341 output_section_callback (ptr, section, file, output)
1342 lang_wild_statement_type *ptr;
1344 lang_input_statement_type *file;
1347 lang_statement_union_type *before;
1349 /* If the wild pattern was marked KEEP, the member sections
1350 should be as well. */
1351 if (ptr->keep_sections)
1352 section->flags |= SEC_KEEP;
1354 before = wild_sort (ptr, file, section);
1356 /* Here BEFORE points to the lang_input_section which
1357 should follow the one we are about to add. If BEFORE
1358 is NULL, then the section should just go at the end
1359 of the current list. */
1362 wild_doit (&ptr->children, section,
1363 (lang_output_section_statement_type *) output,
1367 lang_statement_list_type list;
1368 lang_statement_union_type **pp;
1370 lang_list_init (&list);
1371 wild_doit (&list, section,
1372 (lang_output_section_statement_type *) output,
1375 /* If we are discarding the section, LIST.HEAD will
1377 if (list.head != NULL)
1379 ASSERT (list.head->next == NULL);
1381 for (pp = &ptr->children.head;
1384 ASSERT (*pp != NULL);
1386 list.head->next = *pp;
1392 /* This is passed a file name which must have been seen already and
1393 added to the statement tree. We will see if it has been opened
1394 already and had its symbols read. If not then we'll read it. */
1396 static lang_input_statement_type *
1400 lang_input_statement_type *search;
1402 for (search = (lang_input_statement_type *) input_file_chain.head;
1403 search != (lang_input_statement_type *) NULL;
1404 search = (lang_input_statement_type *) search->next_real_file)
1406 if (search->filename == (char *) NULL && name == (char *) NULL)
1408 if (search->filename != (char *) NULL
1409 && name != (char *) NULL
1410 && strcmp (search->filename, name) == 0)
1414 if (search == (lang_input_statement_type *) NULL)
1415 search = new_afile (name, lang_input_file_is_file_enum, default_target,
1418 /* If we have already added this file, or this file is not real
1419 (FIXME: can that ever actually happen?) or the name is NULL
1420 (FIXME: can that ever actually happen?) don't add this file. */
1423 || search->filename == (const char *) NULL)
1426 load_symbols (search, (lang_statement_list_type *) NULL);
1431 /* Get the symbols for an input file. */
1434 load_symbols (entry, place)
1435 lang_input_statement_type *entry;
1436 lang_statement_list_type *place;
1443 ldfile_open_file (entry);
1445 if (! bfd_check_format (entry->the_bfd, bfd_archive)
1446 && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
1449 lang_statement_list_type *hold;
1451 err = bfd_get_error ();
1453 /* See if the emulation has some special knowledge. */
1454 if (ldemul_unrecognized_file (entry))
1457 if (err == bfd_error_file_ambiguously_recognized)
1461 einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
1462 einfo (_("%B: matching formats:"), entry->the_bfd);
1463 for (p = matching; *p != NULL; p++)
1467 else if (err != bfd_error_file_not_recognized
1469 einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
1471 bfd_close (entry->the_bfd);
1472 entry->the_bfd = NULL;
1474 /* Try to interpret the file as a linker script. */
1475 ldfile_open_command_file (entry->filename);
1480 ldfile_assumed_script = true;
1481 parser_input = input_script;
1483 ldfile_assumed_script = false;
1490 if (ldemul_recognized_file (entry))
1493 /* We don't call ldlang_add_file for an archive. Instead, the
1494 add_symbols entry point will call ldlang_add_file, via the
1495 add_archive_element callback, for each element of the archive
1497 switch (bfd_get_format (entry->the_bfd))
1503 ldlang_add_file (entry);
1504 if (trace_files || trace_file_tries)
1505 info_msg ("%I\n", entry);
1509 if (entry->whole_archive)
1511 bfd *member = bfd_openr_next_archived_file (entry->the_bfd,
1513 while (member != NULL)
1515 if (! bfd_check_format (member, bfd_object))
1516 einfo (_("%F%B: object %B in archive is not object\n"),
1517 entry->the_bfd, member);
1518 if (! ((*link_info.callbacks->add_archive_element)
1519 (&link_info, member, "--whole-archive")))
1521 if (! bfd_link_add_symbols (member, &link_info))
1522 einfo (_("%F%B: could not read symbols: %E\n"), member);
1523 member = bfd_openr_next_archived_file (entry->the_bfd,
1527 entry->loaded = true;
1533 if (! bfd_link_add_symbols (entry->the_bfd, &link_info))
1534 einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
1536 entry->loaded = true;
1539 /* Handle a wild statement. SECTION or FILE or both may be NULL,
1540 indicating that it is a wildcard. Separate lang_input_section
1541 statements are created for each part of the expansion; they are
1542 added after the wild statement S. OUTPUT is the output section. */
1545 wild (s, section, file, target, output)
1546 lang_wild_statement_type *s;
1547 const char *section;
1549 const char *target ATTRIBUTE_UNUSED;
1550 lang_output_section_statement_type *output;
1552 walk_wild (s, section, file, output_section_callback, (PTR) output);
1554 if (section != (char *) NULL
1555 && strcmp (section, "COMMON") == 0
1556 && default_common_section == NULL)
1558 /* Remember the section that common is going to in case we later
1559 get something which doesn't know where to put it. */
1560 default_common_section = output;
1564 /* Return true iff target is the sought target. */
1567 get_target (target, data)
1568 const bfd_target *target;
1571 const char *sought = (const char *) data;
1573 return strcmp (target->name, sought) == 0;
1576 /* Like strcpy() but convert to lower case as well. */
1585 while ((c = *src++) != 0)
1587 if (isupper ((unsigned char) c))
1596 /* Remove the first occurance of needle (if any) in haystack
1600 strcut (haystack, needle)
1604 haystack = strstr (haystack, needle);
1610 for (src = haystack + strlen (needle); *src;)
1611 *haystack++ = *src++;
1617 /* Compare two target format name strings.
1618 Return a value indicating how "similar" they are. */
1621 name_compare (first, second)
1629 copy1 = xmalloc (strlen (first) + 1);
1630 copy2 = xmalloc (strlen (second) + 1);
1632 /* Convert the names to lower case. */
1633 stricpy (copy1, first);
1634 stricpy (copy2, second);
1636 /* Remove and endian strings from the name. */
1637 strcut (copy1, "big");
1638 strcut (copy1, "little");
1639 strcut (copy2, "big");
1640 strcut (copy2, "little");
1642 /* Return a value based on how many characters match,
1643 starting from the beginning. If both strings are
1644 the same then return 10 * their length. */
1645 for (result = 0; copy1[result] == copy2[result]; result++)
1646 if (copy1[result] == 0)
1658 /* Set by closest_target_match() below. */
1659 static const bfd_target *winner;
1661 /* Scan all the valid bfd targets looking for one that has the endianness
1662 requirement that was specified on the command line, and is the nearest
1663 match to the original output target. */
1666 closest_target_match (target, data)
1667 const bfd_target *target;
1670 const bfd_target *original = (const bfd_target *) data;
1672 if (command_line.endian == ENDIAN_BIG
1673 && target->byteorder != BFD_ENDIAN_BIG)
1676 if (command_line.endian == ENDIAN_LITTLE
1677 && target->byteorder != BFD_ENDIAN_LITTLE)
1680 /* Must be the same flavour. */
1681 if (target->flavour != original->flavour)
1684 /* If we have not found a potential winner yet, then record this one. */
1691 /* Oh dear, we now have two potential candidates for a successful match.
1692 Compare their names and choose the better one. */
1693 if (name_compare (target->name, original->name) > name_compare (winner->name, original->name))
1696 /* Keep on searching until wqe have checked them all. */
1700 /* Return the BFD target format of the first input file. */
1703 get_first_input_target ()
1705 char *target = NULL;
1707 LANG_FOR_EACH_INPUT_STATEMENT (s)
1709 if (s->header.type == lang_input_statement_enum
1712 ldfile_open_file (s);
1714 if (s->the_bfd != NULL
1715 && bfd_check_format (s->the_bfd, bfd_object))
1717 target = bfd_get_target (s->the_bfd);
1728 /* Open the output file. */
1736 /* Has the user told us which output format to use? */
1737 if (output_target == (char *) NULL)
1739 /* No - has the current target been set to something other than
1741 if (current_target != default_target)
1742 output_target = current_target;
1744 /* No - can we determine the format of the first input file? */
1747 output_target = get_first_input_target ();
1749 /* Failed - use the default output target. */
1750 if (output_target == NULL)
1751 output_target = default_target;
1755 /* Has the user requested a particular endianness on the command
1757 if (command_line.endian != ENDIAN_UNSET)
1759 const bfd_target *target;
1760 enum bfd_endian desired_endian;
1762 /* Get the chosen target. */
1763 target = bfd_search_for_target (get_target, (PTR) output_target);
1765 /* If the target is not supported, we cannot do anything. */
1768 if (command_line.endian == ENDIAN_BIG)
1769 desired_endian = BFD_ENDIAN_BIG;
1771 desired_endian = BFD_ENDIAN_LITTLE;
1773 /* See if the target has the wrong endianness. This should
1774 not happen if the linker script has provided big and
1775 little endian alternatives, but some scrips don't do
1777 if (target->byteorder != desired_endian)
1779 /* If it does, then see if the target provides
1780 an alternative with the correct endianness. */
1781 if (target->alternative_target != NULL
1782 && (target->alternative_target->byteorder == desired_endian))
1783 output_target = target->alternative_target->name;
1786 /* Try to find a target as similar as possible to
1787 the default target, but which has the desired
1788 endian characteristic. */
1789 (void) bfd_search_for_target (closest_target_match, (PTR) target);
1791 /* Oh dear - we could not find any targets that
1792 satisfy our requirements. */
1794 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1796 output_target = winner->name;
1802 output = bfd_openw (name, output_target);
1804 if (output == (bfd *) NULL)
1806 if (bfd_get_error () == bfd_error_invalid_target)
1807 einfo (_("%P%F: target %s not found\n"), output_target);
1809 einfo (_("%P%F: cannot open output file %s: %E\n"), name);
1812 delete_output_file_on_failure = true;
1815 output->flags |= D_PAGED;
1818 if (! bfd_set_format (output, bfd_object))
1819 einfo (_("%P%F:%s: can not make object file: %E\n"), name);
1820 if (! bfd_set_arch_mach (output,
1821 ldfile_output_architecture,
1822 ldfile_output_machine))
1823 einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
1825 link_info.hash = bfd_link_hash_table_create (output);
1826 if (link_info.hash == (struct bfd_link_hash_table *) NULL)
1827 einfo (_("%P%F: can not create link hash table: %E\n"));
1829 bfd_set_gp_size (output, g_switch_value);
1834 ldlang_open_output (statement)
1835 lang_statement_union_type *statement;
1837 switch (statement->header.type)
1839 case lang_output_statement_enum:
1840 ASSERT (output_bfd == (bfd *) NULL);
1841 output_bfd = open_output (statement->output_statement.name);
1842 ldemul_set_output_arch ();
1843 if (config.magic_demand_paged && !link_info.relocateable)
1844 output_bfd->flags |= D_PAGED;
1846 output_bfd->flags &= ~D_PAGED;
1847 if (config.text_read_only)
1848 output_bfd->flags |= WP_TEXT;
1850 output_bfd->flags &= ~WP_TEXT;
1851 if (link_info.traditional_format)
1852 output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
1854 output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
1857 case lang_target_statement_enum:
1858 current_target = statement->target_statement.target;
1865 /* Open all the input files. */
1868 open_input_bfds (s, force)
1869 lang_statement_union_type *s;
1872 for (; s != (lang_statement_union_type *) NULL; s = s->next)
1874 switch (s->header.type)
1876 case lang_constructors_statement_enum:
1877 open_input_bfds (constructor_list.head, force);
1879 case lang_output_section_statement_enum:
1880 open_input_bfds (s->output_section_statement.children.head, force);
1882 case lang_wild_statement_enum:
1883 /* Maybe we should load the file's symbols. */
1884 if (s->wild_statement.filename
1885 && ! wildcardp (s->wild_statement.filename))
1886 (void) lookup_name (s->wild_statement.filename);
1887 open_input_bfds (s->wild_statement.children.head, force);
1889 case lang_group_statement_enum:
1891 struct bfd_link_hash_entry *undefs;
1893 /* We must continually search the entries in the group
1894 until no new symbols are added to the list of undefined
1899 undefs = link_info.hash->undefs_tail;
1900 open_input_bfds (s->group_statement.children.head, true);
1902 while (undefs != link_info.hash->undefs_tail);
1905 case lang_target_statement_enum:
1906 current_target = s->target_statement.target;
1908 case lang_input_statement_enum:
1909 if (s->input_statement.real)
1911 lang_statement_list_type add;
1912 bfd_error_handler_type pfn;
1914 s->input_statement.target = current_target;
1916 /* If we are being called from within a group, and this
1917 is an archive which has already been searched, then
1918 force it to be researched unless the whole archive
1919 has been loaded already. */
1921 && !s->input_statement.whole_archive
1922 && s->input_statement.loaded
1923 && bfd_check_format (s->input_statement.the_bfd,
1925 s->input_statement.loaded = false;
1927 lang_list_init (& add);
1929 /* We need to know if an error occurs whilst loading the
1930 symbols, since this means that a valid executable can
1932 pfn = bfd_set_error_handler (record_bfd_errors);
1934 load_symbols (&s->input_statement, &add);
1936 bfd_set_error_handler (pfn);
1938 if (add.head != NULL)
1940 *add.tail = s->next;
1951 /* If there are [COMMONS] statements, put a wild one into the bss
1955 lang_reasonable_defaults ()
1958 lang_output_section_statement_lookup (".text");
1959 lang_output_section_statement_lookup (".data");
1961 default_common_section = lang_output_section_statement_lookup (".bss");
1963 if (placed_commons == false)
1965 lang_wild_statement_type *new =
1966 new_stat (lang_wild_statement,
1967 &default_common_section->children);
1969 new->section_name = "COMMON";
1970 new->filename = (char *) NULL;
1971 lang_list_init (&new->children);
1976 /* Add the supplied name to the symbol table as an undefined reference.
1977 Remove items from the chain as we open input bfds. */
1978 typedef struct ldlang_undef_chain_list
1980 struct ldlang_undef_chain_list *next;
1982 } ldlang_undef_chain_list_type;
1984 static ldlang_undef_chain_list_type *ldlang_undef_chain_list_head;
1987 ldlang_add_undef (name)
1988 const char *const name;
1990 ldlang_undef_chain_list_type *new =
1991 ((ldlang_undef_chain_list_type *)
1992 stat_alloc (sizeof (ldlang_undef_chain_list_type)));
1994 new->next = ldlang_undef_chain_list_head;
1995 ldlang_undef_chain_list_head = new;
1997 new->name = buystring (name);
2000 /* Run through the list of undefineds created above and place them
2001 into the linker hash table as undefined symbols belonging to the
2005 lang_place_undefineds ()
2007 ldlang_undef_chain_list_type *ptr;
2009 for (ptr = ldlang_undef_chain_list_head;
2010 ptr != (ldlang_undef_chain_list_type *) NULL;
2013 struct bfd_link_hash_entry *h;
2015 h = bfd_link_hash_lookup (link_info.hash, ptr->name, true, false, true);
2016 if (h == (struct bfd_link_hash_entry *) NULL)
2017 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2018 if (h->type == bfd_link_hash_new)
2020 h->type = bfd_link_hash_undefined;
2021 h->u.undef.abfd = NULL;
2022 bfd_link_add_undef (link_info.hash, h);
2027 /* Open input files and attatch to output sections. */
2030 map_input_to_output_sections (s, target, output_section_statement)
2031 lang_statement_union_type *s;
2033 lang_output_section_statement_type *output_section_statement;
2035 for (; s != (lang_statement_union_type *) NULL; s = s->next)
2037 switch (s->header.type)
2040 case lang_wild_statement_enum:
2041 wild (&s->wild_statement, s->wild_statement.section_name,
2042 s->wild_statement.filename, target,
2043 output_section_statement);
2046 case lang_constructors_statement_enum:
2047 map_input_to_output_sections (constructor_list.head,
2049 output_section_statement);
2051 case lang_output_section_statement_enum:
2052 map_input_to_output_sections (s->output_section_statement.children.head,
2054 &s->output_section_statement);
2056 case lang_output_statement_enum:
2058 case lang_target_statement_enum:
2059 target = s->target_statement.target;
2061 case lang_group_statement_enum:
2062 map_input_to_output_sections (s->group_statement.children.head,
2064 output_section_statement);
2066 case lang_fill_statement_enum:
2067 case lang_input_section_enum:
2068 case lang_object_symbols_statement_enum:
2069 case lang_data_statement_enum:
2070 case lang_reloc_statement_enum:
2071 case lang_padding_statement_enum:
2072 case lang_input_statement_enum:
2073 if (output_section_statement != NULL
2074 && output_section_statement->bfd_section == NULL)
2075 init_os (output_section_statement);
2077 case lang_assignment_statement_enum:
2078 if (output_section_statement != NULL
2079 && output_section_statement->bfd_section == NULL)
2080 init_os (output_section_statement);
2082 /* Make sure that any sections mentioned in the assignment
2084 exp_init_os (s->assignment_statement.exp);
2086 case lang_afile_asection_pair_statement_enum:
2089 case lang_address_statement_enum:
2090 /* Mark the specified section with the supplied address. */
2092 lang_output_section_statement_type *os =
2093 lang_output_section_statement_lookup
2094 (s->address_statement.section_name);
2096 if (os->bfd_section == NULL)
2098 os->addr_tree = s->address_statement.address;
2106 print_output_section_statement (output_section_statement)
2107 lang_output_section_statement_type *output_section_statement;
2109 asection *section = output_section_statement->bfd_section;
2112 if (output_section_statement != abs_output_section)
2114 minfo ("\n%s", output_section_statement->name);
2116 if (section != NULL)
2118 print_dot = section->vma;
2120 len = strlen (output_section_statement->name);
2121 if (len >= SECTION_NAME_MAP_LENGTH - 1)
2126 while (len < SECTION_NAME_MAP_LENGTH)
2132 minfo ("0x%V %W", section->vma, section->_raw_size);
2134 if (output_section_statement->load_base != NULL)
2138 addr = exp_get_abs_int (output_section_statement->load_base, 0,
2139 "load base", lang_final_phase_enum);
2140 minfo (_(" load address 0x%V"), addr);
2147 print_statement_list (output_section_statement->children.head,
2148 output_section_statement);
2152 print_assignment (assignment, output_section)
2153 lang_assignment_statement_type *assignment;
2154 lang_output_section_statement_type *output_section;
2157 etree_value_type result;
2159 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2162 result = exp_fold_tree (assignment->exp->assign.src, output_section,
2163 lang_final_phase_enum, print_dot, &print_dot);
2165 minfo ("0x%V", result.value + result.section->bfd_section->vma);
2176 exp_print_tree (assignment->exp);
2182 print_input_statement (statm)
2183 lang_input_statement_type *statm;
2185 if (statm->filename != (char *) NULL)
2187 fprintf (config.map_file, "LOAD %s\n", statm->filename);
2191 /* Print all symbols defined in a particular section. This is called
2192 via bfd_link_hash_traverse. */
2195 print_one_symbol (hash_entry, ptr)
2196 struct bfd_link_hash_entry *hash_entry;
2199 asection *sec = (asection *) ptr;
2201 if ((hash_entry->type == bfd_link_hash_defined
2202 || hash_entry->type == bfd_link_hash_defweak)
2203 && sec == hash_entry->u.def.section)
2207 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2210 (hash_entry->u.def.value
2211 + hash_entry->u.def.section->output_offset
2212 + hash_entry->u.def.section->output_section->vma));
2214 minfo (" %T\n", hash_entry->root.string);
2220 /* Print information about an input section to the map file. */
2223 print_input_section (in)
2224 lang_input_section_type *in;
2226 asection *i = in->section;
2227 bfd_size_type size = i->_cooked_size != 0 ? i->_cooked_size : i->_raw_size;
2228 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2229 ldfile_output_machine);
2234 minfo ("%s", i->name);
2236 if (i->output_section != NULL)
2240 len = 1 + strlen (i->name);
2241 if (len >= SECTION_NAME_MAP_LENGTH - 1)
2246 while (len < SECTION_NAME_MAP_LENGTH)
2252 minfo ("0x%V %W %B\n",
2253 i->output_section->vma + i->output_offset, size / opb,
2256 if (i->_cooked_size != 0 && i->_cooked_size != i->_raw_size)
2258 len = SECTION_NAME_MAP_LENGTH + 3;
2270 minfo (_("%W (size before relaxing)\n"), i->_raw_size);
2273 bfd_link_hash_traverse (link_info.hash, print_one_symbol, (PTR) i);
2275 print_dot = i->output_section->vma + i->output_offset + size / opb;
2281 print_fill_statement (fill)
2282 lang_fill_statement_type *fill;
2284 fprintf (config.map_file, " FILL mask 0x%x\n", fill->fill);
2288 print_data_statement (data)
2289 lang_data_statement_type *data;
2295 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2296 ldfile_output_machine);
2298 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2301 addr = data->output_vma;
2302 if (data->output_section != NULL)
2303 addr += data->output_section->vma;
2331 minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
2333 if (data->exp->type.node_class != etree_value)
2336 exp_print_tree (data->exp);
2341 print_dot = addr + size / opb;
2345 /* Print an address statement. These are generated by options like
2349 print_address_statement (address)
2350 lang_address_statement_type *address;
2352 minfo (_("Address of section %s set to "), address->section_name);
2353 exp_print_tree (address->address);
2357 /* Print a reloc statement. */
2360 print_reloc_statement (reloc)
2361 lang_reloc_statement_type *reloc;
2366 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2367 ldfile_output_machine);
2369 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2372 addr = reloc->output_vma;
2373 if (reloc->output_section != NULL)
2374 addr += reloc->output_section->vma;
2376 size = bfd_get_reloc_size (reloc->howto);
2378 minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
2380 if (reloc->name != NULL)
2381 minfo ("%s+", reloc->name);
2383 minfo ("%s+", reloc->section->name);
2385 exp_print_tree (reloc->addend_exp);
2389 print_dot = addr + size / opb;
2393 print_padding_statement (s)
2394 lang_padding_statement_type *s;
2398 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2399 ldfile_output_machine);
2403 len = sizeof " *fill*" - 1;
2404 while (len < SECTION_NAME_MAP_LENGTH)
2410 addr = s->output_offset;
2411 if (s->output_section != NULL)
2412 addr += s->output_section->vma;
2413 minfo ("0x%V %W", addr, s->size);
2416 minfo (" %u", s->fill);
2420 print_dot = addr + s->size / opb;
2424 print_wild_statement (w, os)
2425 lang_wild_statement_type *w;
2426 lang_output_section_statement_type *os;
2430 if (w->filenames_sorted)
2432 if (w->exclude_filename_list != NULL)
2435 minfo ("EXCLUDE_FILE ( %s", w->exclude_filename_list->name);
2436 for (tmp = w->exclude_filename_list->next; tmp; tmp = tmp->next)
2437 minfo (", %s", tmp->name);
2440 if (w->filename != NULL)
2441 minfo ("%s", w->filename);
2444 if (w->filenames_sorted)
2448 if (w->sections_sorted)
2450 if (w->section_name != NULL)
2451 minfo ("%s", w->section_name);
2454 if (w->sections_sorted)
2460 print_statement_list (w->children.head, os);
2463 /* Print a group statement. */
2467 lang_group_statement_type *s;
2468 lang_output_section_statement_type *os;
2470 fprintf (config.map_file, "START GROUP\n");
2471 print_statement_list (s->children.head, os);
2472 fprintf (config.map_file, "END GROUP\n");
2475 /* Print the list of statements in S.
2476 This can be called for any statement type. */
2479 print_statement_list (s, os)
2480 lang_statement_union_type *s;
2481 lang_output_section_statement_type *os;
2485 print_statement (s, os);
2490 /* Print the first statement in statement list S.
2491 This can be called for any statement type. */
2494 print_statement (s, os)
2495 lang_statement_union_type *s;
2496 lang_output_section_statement_type *os;
2498 switch (s->header.type)
2501 fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
2504 case lang_constructors_statement_enum:
2505 if (constructor_list.head != NULL)
2507 if (constructors_sorted)
2508 minfo (" SORT (CONSTRUCTORS)\n");
2510 minfo (" CONSTRUCTORS\n");
2511 print_statement_list (constructor_list.head, os);
2514 case lang_wild_statement_enum:
2515 print_wild_statement (&s->wild_statement, os);
2517 case lang_address_statement_enum:
2518 print_address_statement (&s->address_statement);
2520 case lang_object_symbols_statement_enum:
2521 minfo (" CREATE_OBJECT_SYMBOLS\n");
2523 case lang_fill_statement_enum:
2524 print_fill_statement (&s->fill_statement);
2526 case lang_data_statement_enum:
2527 print_data_statement (&s->data_statement);
2529 case lang_reloc_statement_enum:
2530 print_reloc_statement (&s->reloc_statement);
2532 case lang_input_section_enum:
2533 print_input_section (&s->input_section);
2535 case lang_padding_statement_enum:
2536 print_padding_statement (&s->padding_statement);
2538 case lang_output_section_statement_enum:
2539 print_output_section_statement (&s->output_section_statement);
2541 case lang_assignment_statement_enum:
2542 print_assignment (&s->assignment_statement, os);
2544 case lang_target_statement_enum:
2545 fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
2547 case lang_output_statement_enum:
2548 minfo ("OUTPUT(%s", s->output_statement.name);
2549 if (output_target != NULL)
2550 minfo (" %s", output_target);
2553 case lang_input_statement_enum:
2554 print_input_statement (&s->input_statement);
2556 case lang_group_statement_enum:
2557 print_group (&s->group_statement, os);
2559 case lang_afile_asection_pair_statement_enum:
2568 print_statement_list (statement_list.head, abs_output_section);
2571 /* Print the first N statements in statement list S to STDERR.
2572 If N == 0, nothing is printed.
2573 If N < 0, the entire list is printed.
2574 Intended to be called from GDB. */
2577 dprint_statement (s, n)
2578 lang_statement_union_type *s;
2581 FILE *map_save = config.map_file;
2583 config.map_file = stderr;
2586 print_statement_list (s, abs_output_section);
2589 while (s && --n >= 0)
2591 print_statement (s, abs_output_section);
2596 config.map_file = map_save;
2600 insert_pad (this_ptr, fill, power, output_section_statement, dot)
2601 lang_statement_union_type **this_ptr;
2604 asection *output_section_statement;
2607 /* Align this section first to the
2608 input sections requirement, then
2609 to the output section's requirement.
2610 If this alignment is > than any seen before,
2611 then record it too. Perform the alignment by
2612 inserting a magic 'padding' statement. */
2614 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2615 ldfile_output_machine);
2616 unsigned int alignment_needed = align_power (dot, power) - dot;
2618 if (alignment_needed != 0)
2620 lang_statement_union_type *new =
2621 ((lang_statement_union_type *)
2622 stat_alloc (sizeof (lang_padding_statement_type)));
2624 /* Link into existing chain. */
2625 new->header.next = *this_ptr;
2627 new->header.type = lang_padding_statement_enum;
2628 new->padding_statement.output_section = output_section_statement;
2629 new->padding_statement.output_offset =
2630 dot - output_section_statement->vma;
2631 new->padding_statement.fill = fill;
2632 new->padding_statement.size = alignment_needed * opb;
2635 /* Remember the most restrictive alignment. */
2636 if (power > output_section_statement->alignment_power)
2638 output_section_statement->alignment_power = power;
2640 output_section_statement->_raw_size += alignment_needed * opb;
2642 return dot + alignment_needed;
2645 /* Work out how much this section will move the dot point. */
2648 size_input_section (this_ptr, output_section_statement, fill, dot, relax)
2649 lang_statement_union_type **this_ptr;
2650 lang_output_section_statement_type *output_section_statement;
2653 boolean relax ATTRIBUTE_UNUSED;
2655 lang_input_section_type *is = &((*this_ptr)->input_section);
2656 asection *i = is->section;
2657 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2658 ldfile_output_machine);
2660 if (is->ifile->just_syms_flag == false)
2662 if (output_section_statement->subsection_alignment != -1)
2663 i->alignment_power =
2664 output_section_statement->subsection_alignment;
2666 dot = insert_pad (this_ptr, fill, i->alignment_power,
2667 output_section_statement->bfd_section, dot);
2669 /* Remember where in the output section this input section goes. */
2671 i->output_offset = dot - output_section_statement->bfd_section->vma;
2673 /* Mark how big the output section must be to contain this now. */
2674 if (i->_cooked_size != 0)
2675 dot += i->_cooked_size / opb;
2677 dot += i->_raw_size / opb;
2678 output_section_statement->bfd_section->_raw_size =
2679 (dot - output_section_statement->bfd_section->vma) * opb;
2683 i->output_offset = i->vma - output_section_statement->bfd_section->vma;
2689 #define IGNORE_SECTION(bfd, s) \
2690 (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD)) != (SEC_ALLOC | SEC_LOAD)) \
2691 || bfd_section_size (bfd, s) == 0)
2692 /* Check to see if any allocated sections overlap with other allocated
2693 sections. This can happen when the linker script specifically specifies
2694 the output section addresses of the two sections. */
2697 lang_check_section_addresses ()
2700 unsigned opb = bfd_octets_per_byte (output_bfd);
2703 /* Scan all sections in the output list. */
2704 for (s = output_bfd->sections; s != NULL; s = s->next)
2708 /* Ignore sections which are not loaded or which have no contents. */
2709 if (IGNORE_SECTION (output_bfd, s))
2712 /* Once we reach section 's' stop our seach. This prevents two
2713 warning messages from being produced, one for 'section A overlaps
2714 section B' and one for 'section B overlaps section A'. */
2715 for (os = output_bfd->sections; os != s; os = os->next)
2722 /* Only consider loadable sections with real contents. */
2723 if (IGNORE_SECTION (output_bfd, os))
2726 /* We must check the sections' LMA addresses not their
2727 VMA addresses because overlay sections can have
2728 overlapping VMAs but they must have distinct LMAs. */
2729 s_start = bfd_section_lma (output_bfd, s);
2730 os_start = bfd_section_lma (output_bfd, os);
2731 s_end = s_start + bfd_section_size (output_bfd, s) / opb - 1;
2732 os_end = os_start + bfd_section_size (output_bfd, os) / opb - 1;
2734 /* Look for an overlap. */
2735 if ((s_end < os_start) || (s_start > os_end))
2739 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2740 s->name, s_start, s_end, os->name, os_start, os_end);
2742 /* Once we have found one overlap for this section,
2743 stop looking for others. */
2749 /* This variable indicates whether bfd_relax_section should be called
2752 static boolean relax_again;
2754 /* Make sure the new address is within the region. We explicitly permit the
2755 current address to be at the exact end of the region when the address is
2756 non-zero, in case the region is at the end of addressable memory and the
2757 calculation wraps around. */
2760 os_region_check (os, region, tree, base)
2761 lang_output_section_statement_type *os;
2762 struct memory_region_struct *region;
2766 if ((region->current < region->origin
2767 || (region->current - region->origin > region->length))
2768 && ((region->current != region->origin + region->length)
2771 if (tree != (etree_type *) NULL)
2773 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2775 os->bfd_section->owner,
2776 os->bfd_section->name,
2781 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2783 os->bfd_section->owner,
2784 os->bfd_section->name);
2786 /* Reset the region pointer. */
2787 region->current = region->origin;
2791 /* Set the sizes for all the output sections. */
2794 lang_size_sections (s, output_section_statement, prev, fill, dot, relax)
2795 lang_statement_union_type *s;
2796 lang_output_section_statement_type *output_section_statement;
2797 lang_statement_union_type **prev;
2802 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2803 ldfile_output_machine);
2805 /* Size up the sections from their constituent parts. */
2806 for (; s != (lang_statement_union_type *) NULL; s = s->next)
2808 switch (s->header.type)
2810 case lang_output_section_statement_enum:
2813 lang_output_section_statement_type *os = &s->output_section_statement;
2815 if (os->bfd_section == NULL)
2816 /* This section was never actually created. */
2819 /* If this is a COFF shared library section, use the size and
2820 address from the input section. FIXME: This is COFF
2821 specific; it would be cleaner if there were some other way
2822 to do this, but nothing simple comes to mind. */
2823 if ((os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
2827 if (os->children.head == NULL
2828 || os->children.head->next != NULL
2829 || os->children.head->header.type != lang_input_section_enum)
2830 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2833 input = os->children.head->input_section.section;
2834 bfd_set_section_vma (os->bfd_section->owner,
2836 bfd_section_vma (input->owner, input));
2837 os->bfd_section->_raw_size = input->_raw_size;
2841 if (bfd_is_abs_section (os->bfd_section))
2843 /* No matter what happens, an abs section starts at zero. */
2844 ASSERT (os->bfd_section->vma == 0);
2848 if (os->addr_tree == (etree_type *) NULL)
2850 /* No address specified for this section, get one
2851 from the region specification. */
2852 if (os->region == (lang_memory_region_type *) NULL
2853 || (((bfd_get_section_flags (output_bfd, os->bfd_section)
2854 & (SEC_ALLOC | SEC_LOAD)) != 0)
2855 && os->region->name[0] == '*'
2856 && strcmp (os->region->name, "*default*") == 0))
2858 os->region = lang_memory_default (os->bfd_section);
2861 /* If a loadable section is using the default memory
2862 region, and some non default memory regions were
2863 defined, issue a warning. */
2864 if ((bfd_get_section_flags (output_bfd, os->bfd_section)
2865 & (SEC_ALLOC | SEC_LOAD)) != 0
2866 && ! link_info.relocateable
2867 && strcmp (os->region->name, "*default*") == 0
2868 && lang_memory_region_list != NULL
2869 && (strcmp (lang_memory_region_list->name, "*default*") != 0
2870 || lang_memory_region_list->next != NULL))
2871 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2872 bfd_get_section_name (output_bfd, os->bfd_section));
2874 dot = os->region->current;
2876 if (os->section_alignment == -1)
2881 dot = align_power (dot, os->bfd_section->alignment_power);
2883 if (dot != olddot && config.warn_section_align)
2884 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2885 os->name, (unsigned int) (dot - olddot));
2892 r = exp_fold_tree (os->addr_tree,
2894 lang_allocating_phase_enum,
2896 if (r.valid_p == false)
2898 einfo (_("%F%S: non constant address expression for section %s\n"),
2901 dot = r.value + r.section->bfd_section->vma;
2904 /* The section starts here.
2905 First, align to what the section needs. */
2907 if (os->section_alignment != -1)
2908 dot = align_power (dot, os->section_alignment);
2910 bfd_set_section_vma (0, os->bfd_section, dot);
2912 os->bfd_section->output_offset = 0;
2915 (void) lang_size_sections (os->children.head, os,
2917 os->fill, dot, relax);
2919 /* Put the section within the requested block size, or
2920 align at the block boundary. */
2921 after = ALIGN_N (os->bfd_section->vma
2922 + os->bfd_section->_raw_size / opb,
2923 /* The coercion here is important, see ld.h. */
2924 (bfd_vma) os->block_value);
2926 if (bfd_is_abs_section (os->bfd_section))
2927 ASSERT (after == os->bfd_section->vma);
2929 os->bfd_section->_raw_size =
2930 (after - os->bfd_section->vma) * opb;
2931 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
2932 os->processed = true;
2934 /* Update dot in the region ?
2935 We only do this if the section is going to be allocated,
2936 since unallocated sections do not contribute to the region's
2937 overall size in memory.
2939 If the SEC_NEVER_LOAD bit is not set, it will affect the
2940 addresses of sections after it. We have to update
2942 if (os->region != (lang_memory_region_type *) NULL
2943 && ((bfd_get_section_flags (output_bfd, os->bfd_section)
2944 & SEC_NEVER_LOAD) == 0
2945 || (bfd_get_section_flags (output_bfd, os->bfd_section)
2946 & (SEC_ALLOC | SEC_LOAD))))
2948 os->region->current = dot;
2950 /* Make sure the new address is within the region. */
2951 os_region_check (os, os->region, os->addr_tree,
2952 os->bfd_section->vma);
2954 /* If there's no load address specified, use the run
2955 region as the load region. */
2956 if (os->lma_region == NULL && os->load_base == NULL)
2957 os->lma_region = os->region;
2959 if (os->lma_region != NULL)
2961 if (os->load_base != NULL)
2963 einfo (_("%X%P: use an absolute load address or a load memory region, not both\n"));
2967 /* Don't allocate twice. */
2968 if (os->lma_region != os->region)
2970 /* Set load_base, which will be handled later. */
2972 exp_intop (os->lma_region->current);
2973 os->lma_region->current +=
2974 os->bfd_section->_raw_size / opb;
2975 os_region_check (os, os->lma_region, NULL,
2976 os->bfd_section->lma);
2984 case lang_constructors_statement_enum:
2985 dot = lang_size_sections (constructor_list.head,
2986 output_section_statement,
2987 &s->wild_statement.children.head,
2992 case lang_data_statement_enum:
2994 unsigned int size = 0;
2996 s->data_statement.output_vma =
2997 dot - output_section_statement->bfd_section->vma;
2998 s->data_statement.output_section =
2999 output_section_statement->bfd_section;
3001 switch (s->data_statement.type)
3022 output_section_statement->bfd_section->_raw_size += size;
3023 /* The output section gets contents, and then we inspect for
3024 any flags set in the input script which override any ALLOC. */
3025 output_section_statement->bfd_section->flags |= SEC_HAS_CONTENTS;
3026 if (!(output_section_statement->flags & SEC_NEVER_LOAD))
3028 output_section_statement->bfd_section->flags |=
3029 SEC_ALLOC | SEC_LOAD;
3034 case lang_reloc_statement_enum:
3038 s->reloc_statement.output_vma =
3039 dot - output_section_statement->bfd_section->vma;
3040 s->reloc_statement.output_section =
3041 output_section_statement->bfd_section;
3042 size = bfd_get_reloc_size (s->reloc_statement.howto);
3044 output_section_statement->bfd_section->_raw_size += size;
3048 case lang_wild_statement_enum:
3050 dot = lang_size_sections (s->wild_statement.children.head,
3051 output_section_statement,
3052 &s->wild_statement.children.head,
3057 case lang_object_symbols_statement_enum:
3058 link_info.create_object_symbols_section =
3059 output_section_statement->bfd_section;
3061 case lang_output_statement_enum:
3062 case lang_target_statement_enum:
3064 case lang_input_section_enum:
3068 i = (*prev)->input_section.section;
3071 if (i->_cooked_size == 0)
3072 i->_cooked_size = i->_raw_size;
3078 if (! bfd_relax_section (i->owner, i, &link_info, &again))
3079 einfo (_("%P%F: can't relax section: %E\n"));
3083 dot = size_input_section (prev,
3084 output_section_statement,
3085 output_section_statement->fill,
3089 case lang_input_statement_enum:
3091 case lang_fill_statement_enum:
3092 s->fill_statement.output_section =
3093 output_section_statement->bfd_section;
3095 fill = s->fill_statement.fill;
3097 case lang_assignment_statement_enum:
3099 bfd_vma newdot = dot;
3101 exp_fold_tree (s->assignment_statement.exp,
3102 output_section_statement,
3103 lang_allocating_phase_enum,
3109 /* The assignment changed dot. Insert a pad. */
3110 if (output_section_statement == abs_output_section)
3112 /* If we don't have an output section, then just adjust
3113 the default memory address. */
3114 lang_memory_region_lookup ("*default*")->current = newdot;
3118 lang_statement_union_type *new =
3119 ((lang_statement_union_type *)
3120 stat_alloc (sizeof (lang_padding_statement_type)));
3122 /* Link into existing chain. */
3123 new->header.next = *prev;
3125 new->header.type = lang_padding_statement_enum;
3126 new->padding_statement.output_section =
3127 output_section_statement->bfd_section;
3128 new->padding_statement.output_offset =
3129 dot - output_section_statement->bfd_section->vma;
3130 new->padding_statement.fill = fill;
3131 new->padding_statement.size = (newdot - dot) * opb;
3132 output_section_statement->bfd_section->_raw_size +=
3133 new->padding_statement.size;
3141 case lang_padding_statement_enum:
3142 /* If we are relaxing, and this is not the first pass, some
3143 padding statements may have been inserted during previous
3144 passes. We may have to move the padding statement to a new
3145 location if dot has a different value at this point in this
3146 pass than it did at this point in the previous pass. */
3147 s->padding_statement.output_offset =
3148 dot - output_section_statement->bfd_section->vma;
3149 dot += s->padding_statement.size / opb;
3150 output_section_statement->bfd_section->_raw_size +=
3151 s->padding_statement.size;
3154 case lang_group_statement_enum:
3155 dot = lang_size_sections (s->group_statement.children.head,
3156 output_section_statement,
3157 &s->group_statement.children.head,
3165 /* This can only get here when relaxing is turned on. */
3167 case lang_address_statement_enum:
3170 prev = &s->header.next;
3176 lang_do_assignments (s, output_section_statement, fill, dot)
3177 lang_statement_union_type *s;
3178 lang_output_section_statement_type *output_section_statement;
3182 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3183 ldfile_output_machine);
3185 for (; s != (lang_statement_union_type *) NULL; s = s->next)
3187 switch (s->header.type)
3189 case lang_constructors_statement_enum:
3190 dot = lang_do_assignments (constructor_list.head,
3191 output_section_statement,
3196 case lang_output_section_statement_enum:
3198 lang_output_section_statement_type *os =
3199 &(s->output_section_statement);
3201 if (os->bfd_section != NULL)
3203 dot = os->bfd_section->vma;
3204 (void) lang_do_assignments (os->children.head, os,
3206 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
3211 /* If nothing has been placed into the output section then
3212 it won't have a bfd_section. */
3213 if (os->bfd_section)
3215 os->bfd_section->lma
3216 = exp_get_abs_int (os->load_base, 0, "load base",
3217 lang_final_phase_enum);
3222 case lang_wild_statement_enum:
3224 dot = lang_do_assignments (s->wild_statement.children.head,
3225 output_section_statement,
3230 case lang_object_symbols_statement_enum:
3231 case lang_output_statement_enum:
3232 case lang_target_statement_enum:
3234 case lang_common_statement_enum:
3237 case lang_data_statement_enum:
3239 etree_value_type value;
3241 value = exp_fold_tree (s->data_statement.exp,
3243 lang_final_phase_enum, dot, &dot);
3244 s->data_statement.value = value.value;
3245 if (value.valid_p == false)
3246 einfo (_("%F%P: invalid data statement\n"));
3250 switch (s->data_statement.type)
3274 case lang_reloc_statement_enum:
3276 etree_value_type value;
3278 value = exp_fold_tree (s->reloc_statement.addend_exp,
3280 lang_final_phase_enum, dot, &dot);
3281 s->reloc_statement.addend_value = value.value;
3282 if (value.valid_p == false)
3283 einfo (_("%F%P: invalid reloc statement\n"));
3285 dot += bfd_get_reloc_size (s->reloc_statement.howto) / opb;
3288 case lang_input_section_enum:
3290 asection *in = s->input_section.section;
3292 if (in->_cooked_size != 0)
3293 dot += in->_cooked_size / opb;
3295 dot += in->_raw_size / opb;
3299 case lang_input_statement_enum:
3301 case lang_fill_statement_enum:
3302 fill = s->fill_statement.fill;
3304 case lang_assignment_statement_enum:
3306 exp_fold_tree (s->assignment_statement.exp,
3307 output_section_statement,
3308 lang_final_phase_enum,
3314 case lang_padding_statement_enum:
3315 dot += s->padding_statement.size / opb;
3318 case lang_group_statement_enum:
3319 dot = lang_do_assignments (s->group_statement.children.head,
3320 output_section_statement,
3328 case lang_address_statement_enum:
3336 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3337 operator .startof. (section_name), it produces an undefined symbol
3338 .startof.section_name. Similarly, when it sees
3339 .sizeof. (section_name), it produces an undefined symbol
3340 .sizeof.section_name. For all the output sections, we look for
3341 such symbols, and set them to the correct value. */
3348 if (link_info.relocateable)
3351 for (s = output_bfd->sections; s != NULL; s = s->next)
3353 const char *secname;
3355 struct bfd_link_hash_entry *h;
3357 secname = bfd_get_section_name (output_bfd, s);
3358 buf = xmalloc (10 + strlen (secname));
3360 sprintf (buf, ".startof.%s", secname);
3361 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3362 if (h != NULL && h->type == bfd_link_hash_undefined)
3364 h->type = bfd_link_hash_defined;
3365 h->u.def.value = bfd_get_section_vma (output_bfd, s);
3366 h->u.def.section = bfd_abs_section_ptr;
3369 sprintf (buf, ".sizeof.%s", secname);
3370 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3371 if (h != NULL && h->type == bfd_link_hash_undefined)
3373 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3374 ldfile_output_machine);
3375 h->type = bfd_link_hash_defined;
3376 if (s->_cooked_size != 0)
3377 h->u.def.value = s->_cooked_size / opb;
3379 h->u.def.value = s->_raw_size / opb;
3380 h->u.def.section = bfd_abs_section_ptr;
3390 struct bfd_link_hash_entry *h;
3393 if (link_info.relocateable || link_info.shared)
3398 if (entry_symbol == (char *) NULL)
3400 /* No entry has been specified. Look for start, but don't warn
3401 if we don't find it. */
3402 entry_symbol = "start";
3406 h = bfd_link_hash_lookup (link_info.hash, entry_symbol, false, false, true);
3407 if (h != (struct bfd_link_hash_entry *) NULL
3408 && (h->type == bfd_link_hash_defined
3409 || h->type == bfd_link_hash_defweak)
3410 && h->u.def.section->output_section != NULL)
3414 val = (h->u.def.value
3415 + bfd_get_section_vma (output_bfd,
3416 h->u.def.section->output_section)
3417 + h->u.def.section->output_offset);
3418 if (! bfd_set_start_address (output_bfd, val))
3419 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol);
3426 /* We couldn't find the entry symbol. Try parsing it as a
3428 val = bfd_scan_vma (entry_symbol, &send, 0);
3431 if (! bfd_set_start_address (output_bfd, val))
3432 einfo (_("%P%F: can't set start address\n"));
3438 /* Can't find the entry symbol, and it's not a number. Use
3439 the first address in the text section. */
3440 ts = bfd_get_section_by_name (output_bfd, ".text");
3441 if (ts != (asection *) NULL)
3444 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3445 entry_symbol, bfd_get_section_vma (output_bfd, ts));
3446 if (! bfd_set_start_address (output_bfd,
3447 bfd_get_section_vma (output_bfd,
3449 einfo (_("%P%F: can't set start address\n"));
3454 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3462 /* This is the routine to handle BFD error messages. */
3464 #ifdef ANSI_PROTOTYPES
3467 record_bfd_errors (const char *s, ...)
3475 vfprintf (stderr, s, p);
3479 fprintf (stderr, "\n");
3484 #else /* ! defined (ANSI_PROTOTYPES) */
3487 record_bfd_errors (va_alist)
3497 s = va_arg (p, const char *);
3498 vfprintf (stderr, s, p);
3502 fprintf (stderr, "\n");
3507 #endif /* ! defined (ANSI_PROTOTYPES) */
3508 /* This is a small function used when we want to ignore errors from
3512 #ifdef ANSI_PROTOTYPES
3513 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
3515 ignore_bfd_errors (s)
3516 const char *s ATTRIBUTE_UNUSED;
3519 /* Don't do anything. */
3522 /* Check that the architecture of all the input files is compatible
3523 with the output file. Also call the backend to let it do any
3524 other checking that is needed. */
3529 lang_statement_union_type *file;
3531 const bfd_arch_info_type *compatible;
3533 for (file = file_chain.head;
3534 file != (lang_statement_union_type *) NULL;
3535 file = file->input_statement.next)
3537 input_bfd = file->input_statement.the_bfd;
3538 compatible = bfd_arch_get_compatible (input_bfd,
3540 if (compatible == NULL)
3542 if (command_line.warn_mismatch)
3543 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3544 bfd_printable_name (input_bfd), input_bfd,
3545 bfd_printable_name (output_bfd));
3547 else if (bfd_count_sections (input_bfd))
3549 /* If the input bfd has no contents, it shouldn't set the
3550 private data of the output bfd. */
3552 bfd_error_handler_type pfn = NULL;
3554 /* If we aren't supposed to warn about mismatched input
3555 files, temporarily set the BFD error handler to a
3556 function which will do nothing. We still want to call
3557 bfd_merge_private_bfd_data, since it may set up
3558 information which is needed in the output file. */
3559 if (! command_line.warn_mismatch)
3560 pfn = bfd_set_error_handler (ignore_bfd_errors);
3561 if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
3563 if (command_line.warn_mismatch)
3564 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3567 if (! command_line.warn_mismatch)
3568 bfd_set_error_handler (pfn);
3573 /* Look through all the global common symbols and attach them to the
3574 correct section. The -sort-common command line switch may be used
3575 to roughly sort the entries by size. */
3580 if (link_info.relocateable
3581 && ! command_line.force_common_definition)
3584 if (! config.sort_common)
3585 bfd_link_hash_traverse (link_info.hash, lang_one_common, (PTR) NULL);
3590 for (power = 4; power >= 0; power--)
3591 bfd_link_hash_traverse (link_info.hash, lang_one_common,
3596 /* Place one common symbol in the correct section. */
3599 lang_one_common (h, info)
3600 struct bfd_link_hash_entry *h;
3603 unsigned int power_of_two;
3606 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3607 ldfile_output_machine);
3609 if (h->type != bfd_link_hash_common)
3613 power_of_two = h->u.c.p->alignment_power;
3615 if (config.sort_common
3616 && power_of_two < (unsigned int) *(int *) info)
3619 section = h->u.c.p->section;
3621 /* Increase the size of the section. */
3622 section->_cooked_size = ALIGN_N ((section->_cooked_size + opb - 1) / opb,
3623 (bfd_size_type) (1 << power_of_two)) * opb;
3625 /* Adjust the alignment if necessary. */
3626 if (power_of_two > section->alignment_power)
3627 section->alignment_power = power_of_two;
3629 /* Change the symbol from common to defined. */
3630 h->type = bfd_link_hash_defined;
3631 h->u.def.section = section;
3632 h->u.def.value = section->_cooked_size;
3634 /* Increase the size of the section. */
3635 section->_cooked_size += size;
3637 /* Make sure the section is allocated in memory, and make sure that
3638 it is no longer a common section. */
3639 section->flags |= SEC_ALLOC;
3640 section->flags &= ~SEC_IS_COMMON;
3642 if (config.map_file != NULL)
3644 static boolean header_printed;
3649 if (! header_printed)
3651 minfo (_("\nAllocating common symbols\n"));
3652 minfo (_("Common symbol size file\n\n"));
3653 header_printed = true;
3656 name = demangle (h->root.string);
3658 len = strlen (name);
3673 if (size <= 0xffffffff)
3674 sprintf (buf, "%lx", (unsigned long) size);
3676 sprintf_vma (buf, size);
3686 minfo ("%B\n", section->owner);
3692 /* Run through the input files and ensure that every input section has
3693 somewhere to go. If one is found without a destination then create
3694 an input request and place it into the statement tree. */
3697 lang_place_orphans ()
3699 LANG_FOR_EACH_INPUT_STATEMENT (file)
3703 for (s = file->the_bfd->sections;
3704 s != (asection *) NULL;
3707 if (s->output_section == (asection *) NULL)
3709 /* This section of the file is not attatched, root
3710 around for a sensible place for it to go. */
3712 if (file->just_syms_flag)
3714 /* We are only retrieving symbol values from this
3715 file. We want the symbols to act as though the
3716 values in the file are absolute. */
3717 s->output_section = bfd_abs_section_ptr;
3718 s->output_offset = s->vma;
3720 else if (strcmp (s->name, "COMMON") == 0)
3722 /* This is a lonely common section which must have
3723 come from an archive. We attach to the section
3724 with the wildcard. */
3725 if (! link_info.relocateable
3726 || command_line.force_common_definition)
3728 if (default_common_section == NULL)
3731 /* This message happens when using the
3732 svr3.ifile linker script, so I have
3734 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3736 default_common_section =
3737 lang_output_section_statement_lookup (".bss");
3740 wild_doit (&default_common_section->children, s,
3741 default_common_section, file);
3744 else if (ldemul_place_orphan (file, s))
3748 lang_output_section_statement_type *os =
3749 lang_output_section_statement_lookup (s->name);
3751 wild_doit (&os->children, s, os, file);
3759 lang_set_flags (ptr, flags, invert)
3760 lang_memory_region_type *ptr;
3764 flagword *ptr_flags;
3766 ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
3772 *ptr_flags |= SEC_ALLOC;
3776 *ptr_flags |= SEC_READONLY;
3780 *ptr_flags |= SEC_DATA;
3784 *ptr_flags |= SEC_CODE;
3789 *ptr_flags |= SEC_LOAD;
3793 einfo (_("%P%F: invalid syntax in flags\n"));
3800 /* Call a function on each input file. This function will be called
3801 on an archive, but not on the elements. */
3804 lang_for_each_input_file (func)
3805 void (*func) PARAMS ((lang_input_statement_type *));
3807 lang_input_statement_type *f;
3809 for (f = (lang_input_statement_type *) input_file_chain.head;
3811 f = (lang_input_statement_type *) f->next_real_file)
3815 /* Call a function on each file. The function will be called on all
3816 the elements of an archive which are included in the link, but will
3817 not be called on the archive file itself. */
3820 lang_for_each_file (func)
3821 void (*func) PARAMS ((lang_input_statement_type *));
3823 LANG_FOR_EACH_INPUT_STATEMENT (f)
3834 lang_for_each_input_section (func)
3835 void (*func) PARAMS ((bfd *ab, asection *as));
3837 LANG_FOR_EACH_INPUT_STATEMENT (f)
3841 for (s = f->the_bfd->sections;
3842 s != (asection *) NULL;
3845 func (f->the_bfd, s);
3853 ldlang_add_file (entry)
3854 lang_input_statement_type *entry;
3858 lang_statement_append (&file_chain,
3859 (lang_statement_union_type *) entry,
3862 /* The BFD linker needs to have a list of all input BFDs involved in
3864 ASSERT (entry->the_bfd->link_next == (bfd *) NULL);
3865 ASSERT (entry->the_bfd != output_bfd);
3866 for (pp = &link_info.input_bfds;
3867 *pp != (bfd *) NULL;
3868 pp = &(*pp)->link_next)
3870 *pp = entry->the_bfd;
3871 entry->the_bfd->usrdata = (PTR) entry;
3872 bfd_set_gp_size (entry->the_bfd, g_switch_value);
3874 /* Look through the sections and check for any which should not be
3875 included in the link. We need to do this now, so that we can
3876 notice when the backend linker tries to report multiple
3877 definition errors for symbols which are in sections we aren't
3878 going to link. FIXME: It might be better to entirely ignore
3879 symbols which are defined in sections which are going to be
3880 discarded. This would require modifying the backend linker for
3881 each backend which might set the SEC_LINK_ONCE flag. If we do
3882 this, we should probably handle SEC_EXCLUDE in the same way. */
3884 bfd_map_over_sections (entry->the_bfd, section_already_linked, (PTR) entry);
3888 lang_add_output (name, from_script)
3892 /* Make -o on command line override OUTPUT in script. */
3893 if (had_output_filename == false || !from_script)
3895 output_filename = name;
3896 had_output_filename = true;
3900 static lang_output_section_statement_type *current_section;
3912 for (l = 0; l < 32; l++)
3914 if (i >= (unsigned int) x)
3922 lang_output_section_statement_type *
3923 lang_enter_output_section_statement (output_section_statement_name,
3924 address_exp, sectype, block_value,
3925 align, subalign, ebase)
3926 const char *output_section_statement_name;
3927 etree_type *address_exp;
3928 enum section_type sectype;
3929 bfd_vma block_value;
3931 etree_type *subalign;
3934 lang_output_section_statement_type *os;
3938 lang_output_section_statement_lookup (output_section_statement_name);
3940 /* Add this statement to tree. */
3942 add_statement (lang_output_section_statement_enum,
3943 output_section_statement);
3945 /* Make next things chain into subchain of this. */
3947 if (os->addr_tree == (etree_type *) NULL)
3949 os->addr_tree = address_exp;
3951 os->sectype = sectype;
3952 if (sectype != noload_section)
3953 os->flags = SEC_NO_FLAGS;
3955 os->flags = SEC_NEVER_LOAD;
3956 os->block_value = block_value ? block_value : 1;
3957 stat_ptr = &os->children;
3959 os->subsection_alignment =
3960 topower (exp_get_value_int (subalign, -1, "subsection alignment", 0));
3961 os->section_alignment =
3962 topower (exp_get_value_int (align, -1, "section alignment", 0));
3964 os->load_base = ebase;
3971 lang_output_statement_type *new =
3972 new_stat (lang_output_statement, stat_ptr);
3974 new->name = output_filename;
3977 /* Reset the current counters in the regions. */
3980 reset_memory_regions ()
3982 lang_memory_region_type *p = lang_memory_region_list;
3984 for (p = lang_memory_region_list;
3985 p != (lang_memory_region_type *) NULL;
3988 p->old_length = (bfd_size_type) (p->current - p->origin);
3989 p->current = p->origin;
3993 /* Expand a wild statement for a particular FILE, marking its sections KEEP
3994 as needed. SECTION may be NULL, in which case it is a wild card. */
3997 gc_section_callback (ptr, section, file, data)
3998 lang_wild_statement_type *ptr;
4000 lang_input_statement_type *file ATTRIBUTE_UNUSED;
4001 PTR data ATTRIBUTE_UNUSED;
4003 /* If the wild pattern was marked KEEP, the member sections
4004 should be as well. */
4005 if (ptr->keep_sections)
4006 section->flags |= SEC_KEEP;
4009 /* Handle a wild statement, marking it against GC. SECTION or FILE or both
4010 may be NULL, indicating that it is a wildcard. */
4013 lang_gc_wild (s, section, file)
4014 lang_wild_statement_type *s;
4015 const char *section;
4018 walk_wild (s, section, file, gc_section_callback, NULL);
4021 /* Iterate over sections marking them against GC. */
4024 lang_gc_sections_1 (s)
4025 lang_statement_union_type *s;
4027 for (; s != (lang_statement_union_type *) NULL; s = s->next)
4029 switch (s->header.type)
4031 case lang_wild_statement_enum:
4032 lang_gc_wild (&s->wild_statement,
4033 s->wild_statement.section_name,
4034 s->wild_statement.filename);
4036 case lang_constructors_statement_enum:
4037 lang_gc_sections_1 (constructor_list.head);
4039 case lang_output_section_statement_enum:
4040 lang_gc_sections_1 (s->output_section_statement.children.head);
4042 case lang_group_statement_enum:
4043 lang_gc_sections_1 (s->group_statement.children.head);
4054 struct bfd_link_hash_entry *h;
4055 ldlang_undef_chain_list_type *ulist, fake_list_start;
4057 /* Keep all sections so marked in the link script. */
4059 lang_gc_sections_1 (statement_list.head);
4061 /* Keep all sections containing symbols undefined on the command-line.
4062 Handle the entry symbol at the same time. */
4064 if (entry_symbol != NULL)
4066 fake_list_start.next = ldlang_undef_chain_list_head;
4067 fake_list_start.name = (char *) entry_symbol;
4068 ulist = &fake_list_start;
4071 ulist = ldlang_undef_chain_list_head;
4073 for (; ulist; ulist = ulist->next)
4075 h = bfd_link_hash_lookup (link_info.hash, ulist->name,
4076 false, false, false);
4078 if (h != (struct bfd_link_hash_entry *) NULL
4079 && (h->type == bfd_link_hash_defined
4080 || h->type == bfd_link_hash_defweak)
4081 && ! bfd_is_abs_section (h->u.def.section))
4083 h->u.def.section->flags |= SEC_KEEP;
4087 bfd_gc_sections (output_bfd, &link_info);
4093 lang_reasonable_defaults ();
4094 current_target = default_target;
4096 /* Open the output file. */
4097 lang_for_each_statement (ldlang_open_output);
4099 ldemul_create_output_section_statements ();
4101 /* Add to the hash table all undefineds on the command line. */
4102 lang_place_undefineds ();
4104 already_linked_table_init ();
4106 /* Create a bfd for each input file. */
4107 current_target = default_target;
4108 open_input_bfds (statement_list.head, false);
4110 ldemul_after_open ();
4112 already_linked_table_free ();
4114 /* Make sure that we're not mixing architectures. We call this
4115 after all the input files have been opened, but before we do any
4116 other processing, so that any operations merge_private_bfd_data
4117 does on the output file will be known during the rest of the
4121 /* Handle .exports instead of a version script if we're told to do so. */
4122 if (command_line.version_exports_section)
4123 lang_do_version_exports_section ();
4125 /* Build all sets based on the information gathered from the input
4127 ldctor_build_sets ();
4129 /* Remove unreferenced sections if asked to. */
4130 if (command_line.gc_sections)
4131 lang_gc_sections ();
4133 /* Size up the common data. */
4136 /* Run through the contours of the script and attach input sections
4137 to the correct output sections. */
4138 map_input_to_output_sections (statement_list.head, (char *) NULL,
4139 (lang_output_section_statement_type *) NULL);
4141 /* Find any sections not attached explicitly and handle them. */
4142 lang_place_orphans ();
4144 ldemul_before_allocation ();
4146 /* We must record the program headers before we try to fix the
4147 section positions, since they will affect SIZEOF_HEADERS. */
4148 lang_record_phdrs ();
4150 /* Now run around and relax if we can. */
4151 if (command_line.relax)
4153 /* First time round is a trial run to get the 'worst case'
4154 addresses of the objects if there was no relaxing. */
4155 lang_size_sections (statement_list.head,
4157 &(statement_list.head), 0, (bfd_vma) 0, false);
4159 /* Keep relaxing until bfd_relax_section gives up. */
4162 reset_memory_regions ();
4164 relax_again = false;
4166 /* Note: pe-dll.c does something like this also. If you find
4167 you need to change this code, you probably need to change
4168 pe-dll.c also. DJ */
4170 /* Do all the assignments with our current guesses as to
4172 lang_do_assignments (statement_list.head,
4174 (fill_type) 0, (bfd_vma) 0);
4176 /* Perform another relax pass - this time we know where the
4177 globals are, so can make better guess. */
4178 lang_size_sections (statement_list.head,
4180 &(statement_list.head), 0, (bfd_vma) 0, true);
4182 while (relax_again);
4186 /* Size up the sections. */
4187 lang_size_sections (statement_list.head,
4189 &(statement_list.head), 0, (bfd_vma) 0, false);
4192 /* See if anything special should be done now we know how big
4194 ldemul_after_allocation ();
4196 /* Fix any .startof. or .sizeof. symbols. */
4197 lang_set_startof ();
4199 /* Do all the assignments, now that we know the final resting places
4200 of all the symbols. */
4202 lang_do_assignments (statement_list.head,
4204 (fill_type) 0, (bfd_vma) 0);
4206 /* Make sure that the section addresses make sense. */
4207 if (! link_info.relocateable
4208 && command_line.check_section_addresses)
4209 lang_check_section_addresses ();
4217 /* EXPORTED TO YACC */
4220 lang_add_wild (section_name, sections_sorted, filename, filenames_sorted,
4221 keep_sections, exclude_filename_list)
4222 const char *const section_name;
4223 boolean sections_sorted;
4224 const char *const filename;
4225 boolean filenames_sorted;
4226 boolean keep_sections;
4227 struct name_list *exclude_filename_list;
4229 lang_wild_statement_type *new = new_stat (lang_wild_statement,
4232 if (section_name != (char *) NULL && strcmp (section_name, "COMMON") == 0)
4234 placed_commons = true;
4236 if (filename != NULL && ! wildcardp (filename))
4238 lang_has_input_file = true;
4240 new->section_name = section_name;
4241 new->sections_sorted = sections_sorted;
4242 new->filename = filename;
4243 new->filenames_sorted = filenames_sorted;
4244 new->keep_sections = keep_sections;
4245 new->exclude_filename_list = exclude_filename_list;
4246 lang_list_init (&new->children);
4250 lang_section_start (name, address)
4252 etree_type *address;
4254 lang_address_statement_type *ad = new_stat (lang_address_statement, stat_ptr);
4256 ad->section_name = name;
4257 ad->address = address;
4260 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4261 because of a -e argument on the command line, or zero if this is
4262 called by ENTRY in a linker script. Command line arguments take
4266 lang_add_entry (name, cmdline)
4270 if (entry_symbol == NULL
4272 || ! entry_from_cmdline)
4274 entry_symbol = name;
4275 entry_from_cmdline = cmdline;
4280 lang_add_target (name)
4283 lang_target_statement_type *new = new_stat (lang_target_statement,
4299 map_option_f = true;
4310 lang_fill_statement_type *new = new_stat (lang_fill_statement,
4317 lang_add_data (type, exp)
4319 union etree_union *exp;
4322 lang_data_statement_type *new = new_stat (lang_data_statement,
4330 /* Create a new reloc statement. RELOC is the BFD relocation type to
4331 generate. HOWTO is the corresponding howto structure (we could
4332 look this up, but the caller has already done so). SECTION is the
4333 section to generate a reloc against, or NAME is the name of the
4334 symbol to generate a reloc against. Exactly one of SECTION and
4335 NAME must be NULL. ADDEND is an expression for the addend. */
4338 lang_add_reloc (reloc, howto, section, name, addend)
4339 bfd_reloc_code_real_type reloc;
4340 reloc_howto_type *howto;
4343 union etree_union *addend;
4345 lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
4349 p->section = section;
4351 p->addend_exp = addend;
4353 p->addend_value = 0;
4354 p->output_section = NULL;
4358 lang_assignment_statement_type *
4359 lang_add_assignment (exp)
4362 lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
4370 lang_add_attribute (attribute)
4371 enum statement_enum attribute;
4373 new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
4380 if (startup_file != (char *) NULL)
4382 einfo (_("%P%Fmultiple STARTUP files\n"));
4384 first_file->filename = name;
4385 first_file->local_sym_name = name;
4386 first_file->real = true;
4388 startup_file = name;
4395 lang_float_flag = maybe;
4399 lang_leave_output_section_statement (fill, memspec, phdrs, lma_memspec)
4401 const char *memspec;
4402 struct lang_output_section_phdr_list *phdrs;
4403 const char *lma_memspec;
4405 current_section->fill = fill;
4406 current_section->region = lang_memory_region_lookup (memspec);
4407 if (strcmp (lma_memspec, "*default*") != 0)
4409 current_section->lma_region = lang_memory_region_lookup (lma_memspec);
4410 /* If no runtime region has been given, but the load region has
4411 been, use the load region. */
4412 if (strcmp (memspec, "*default*") == 0)
4413 current_section->region = lang_memory_region_lookup (lma_memspec);
4415 current_section->phdrs = phdrs;
4416 stat_ptr = &statement_list;
4419 /* Create an absolute symbol with the given name with the value of the
4420 address of first byte of the section named.
4422 If the symbol already exists, then do nothing. */
4425 lang_abs_symbol_at_beginning_of (secname, name)
4426 const char *secname;
4429 struct bfd_link_hash_entry *h;
4431 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4432 if (h == (struct bfd_link_hash_entry *) NULL)
4433 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4435 if (h->type == bfd_link_hash_new
4436 || h->type == bfd_link_hash_undefined)
4440 h->type = bfd_link_hash_defined;
4442 sec = bfd_get_section_by_name (output_bfd, secname);
4443 if (sec == (asection *) NULL)
4446 h->u.def.value = bfd_get_section_vma (output_bfd, sec);
4448 h->u.def.section = bfd_abs_section_ptr;
4452 /* Create an absolute symbol with the given name with the value of the
4453 address of the first byte after the end of the section named.
4455 If the symbol already exists, then do nothing. */
4458 lang_abs_symbol_at_end_of (secname, name)
4459 const char *secname;
4462 struct bfd_link_hash_entry *h;
4464 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4465 if (h == (struct bfd_link_hash_entry *) NULL)
4466 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4468 if (h->type == bfd_link_hash_new
4469 || h->type == bfd_link_hash_undefined)
4473 h->type = bfd_link_hash_defined;
4475 sec = bfd_get_section_by_name (output_bfd, secname);
4476 if (sec == (asection *) NULL)
4479 h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
4480 + bfd_section_size (output_bfd, sec) /
4481 bfd_octets_per_byte (output_bfd));
4483 h->u.def.section = bfd_abs_section_ptr;
4488 lang_statement_append (list, element, field)
4489 lang_statement_list_type *list;
4490 lang_statement_union_type *element;
4491 lang_statement_union_type **field;
4493 *(list->tail) = element;
4497 /* Set the output format type. -oformat overrides scripts. */
4500 lang_add_output_format (format, big, little, from_script)
4506 if (output_target == NULL || !from_script)
4508 if (command_line.endian == ENDIAN_BIG
4511 else if (command_line.endian == ENDIAN_LITTLE
4515 output_target = format;
4519 /* Enter a group. This creates a new lang_group_statement, and sets
4520 stat_ptr to build new statements within the group. */
4525 lang_group_statement_type *g;
4527 g = new_stat (lang_group_statement, stat_ptr);
4528 lang_list_init (&g->children);
4529 stat_ptr = &g->children;
4532 /* Leave a group. This just resets stat_ptr to start writing to the
4533 regular list of statements again. Note that this will not work if
4534 groups can occur inside anything else which can adjust stat_ptr,
4535 but currently they can't. */
4540 stat_ptr = &statement_list;
4543 /* Add a new program header. This is called for each entry in a PHDRS
4544 command in a linker script. */
4547 lang_new_phdr (name, type, filehdr, phdrs, at, flags)
4555 struct lang_phdr *n, **pp;
4557 n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));
4560 n->type = exp_get_value_int (type, 0, "program header type",
4561 lang_final_phase_enum);
4562 n->filehdr = filehdr;
4567 for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
4572 /* Record the program header information in the output BFD. FIXME: We
4573 should not be calling an ELF specific function here. */
4576 lang_record_phdrs ()
4580 struct lang_output_section_phdr_list *last;
4581 struct lang_phdr *l;
4582 lang_statement_union_type *u;
4585 secs = (asection **) xmalloc (alc * sizeof (asection *));
4587 for (l = lang_phdr_list; l != NULL; l = l->next)
4594 for (u = lang_output_section_statement.head;
4596 u = u->output_section_statement.next)
4598 lang_output_section_statement_type *os;
4599 struct lang_output_section_phdr_list *pl;
4601 os = &u->output_section_statement;
4608 if (os->sectype == noload_section
4609 || os->bfd_section == NULL
4610 || (os->bfd_section->flags & SEC_ALLOC) == 0)
4615 if (os->bfd_section == NULL)
4618 for (; pl != NULL; pl = pl->next)
4620 if (strcmp (pl->name, l->name) == 0)
4625 secs = ((asection **)
4626 xrealloc (secs, alc * sizeof (asection *)));
4628 secs[c] = os->bfd_section;
4635 if (l->flags == NULL)
4638 flags = exp_get_vma (l->flags, 0, "phdr flags",
4639 lang_final_phase_enum);
4644 at = exp_get_vma (l->at, 0, "phdr load address",
4645 lang_final_phase_enum);
4647 if (! bfd_record_phdr (output_bfd, l->type,
4648 l->flags == NULL ? false : true,
4650 l->at == NULL ? false : true,
4651 at, l->filehdr, l->phdrs, c, secs))
4652 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4657 /* Make sure all the phdr assignments succeeded. */
4658 for (u = lang_output_section_statement.head;
4660 u = u->output_section_statement.next)
4662 struct lang_output_section_phdr_list *pl;
4664 if (u->output_section_statement.bfd_section == NULL)
4667 for (pl = u->output_section_statement.phdrs;
4670 if (! pl->used && strcmp (pl->name, "NONE") != 0)
4671 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4672 u->output_section_statement.name, pl->name);
4676 /* Record a list of sections which may not be cross referenced. */
4679 lang_add_nocrossref (l)
4680 struct lang_nocrossref *l;
4682 struct lang_nocrossrefs *n;
4684 n = (struct lang_nocrossrefs *) xmalloc (sizeof *n);
4685 n->next = nocrossref_list;
4687 nocrossref_list = n;
4689 /* Set notice_all so that we get informed about all symbols. */
4690 link_info.notice_all = true;
4693 /* Overlay handling. We handle overlays with some static variables. */
4695 /* The overlay virtual address. */
4696 static etree_type *overlay_vma;
4698 /* The overlay load address. */
4699 static etree_type *overlay_lma;
4701 /* Whether nocrossrefs is set for this overlay. */
4702 static int overlay_nocrossrefs;
4704 /* An expression for the maximum section size seen so far. */
4705 static etree_type *overlay_max;
4707 /* A list of all the sections in this overlay. */
4709 struct overlay_list {
4710 struct overlay_list *next;
4711 lang_output_section_statement_type *os;
4714 static struct overlay_list *overlay_list;
4716 /* Start handling an overlay. */
4719 lang_enter_overlay (vma_expr, lma_expr, nocrossrefs)
4720 etree_type *vma_expr;
4721 etree_type *lma_expr;
4724 /* The grammar should prevent nested overlays from occurring. */
4725 ASSERT (overlay_vma == NULL
4726 && overlay_lma == NULL
4727 && overlay_list == NULL
4728 && overlay_max == NULL);
4730 overlay_vma = vma_expr;
4731 overlay_lma = lma_expr;
4732 overlay_nocrossrefs = nocrossrefs;
4735 /* Start a section in an overlay. We handle this by calling
4736 lang_enter_output_section_statement with the correct VMA and LMA. */
4739 lang_enter_overlay_section (name)
4742 struct overlay_list *n;
4745 lang_enter_output_section_statement (name, overlay_vma, normal_section,
4746 0, 0, 0, overlay_lma);
4748 /* If this is the first section, then base the VMA and LMA of future
4749 sections on this one. This will work correctly even if `.' is
4750 used in the addresses. */
4751 if (overlay_list == NULL)
4753 overlay_vma = exp_nameop (ADDR, name);
4754 overlay_lma = exp_nameop (LOADADDR, name);
4757 /* Remember the section. */
4758 n = (struct overlay_list *) xmalloc (sizeof *n);
4759 n->os = current_section;
4760 n->next = overlay_list;
4763 size = exp_nameop (SIZEOF, name);
4765 /* Adjust the LMA for the next section. */
4766 overlay_lma = exp_binop ('+', overlay_lma, size);
4768 /* Arrange to work out the maximum section end address. */
4769 if (overlay_max == NULL)
4772 overlay_max = exp_binop (MAX_K, overlay_max, size);
4775 /* Finish a section in an overlay. There isn't any special to do
4779 lang_leave_overlay_section (fill, phdrs)
4781 struct lang_output_section_phdr_list *phdrs;
4788 name = current_section->name;
4790 lang_leave_output_section_statement (fill, "*default*",
4791 phdrs, "*default*");
4793 /* Define the magic symbols. */
4795 clean = xmalloc (strlen (name) + 1);
4797 for (s1 = name; *s1 != '\0'; s1++)
4798 if (isalnum ((unsigned char) *s1) || *s1 == '_')
4802 buf = xmalloc (strlen (clean) + sizeof "__load_start_");
4803 sprintf (buf, "__load_start_%s", clean);
4804 lang_add_assignment (exp_assop ('=', buf,
4805 exp_nameop (LOADADDR, name)));
4807 buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
4808 sprintf (buf, "__load_stop_%s", clean);
4809 lang_add_assignment (exp_assop ('=', buf,
4811 exp_nameop (LOADADDR, name),
4812 exp_nameop (SIZEOF, name))));
4817 /* Finish an overlay. If there are any overlay wide settings, this
4818 looks through all the sections in the overlay and sets them. */
4821 lang_leave_overlay (fill, memspec, phdrs, lma_memspec)
4823 const char *memspec;
4824 struct lang_output_section_phdr_list *phdrs;
4825 const char *lma_memspec;
4827 lang_memory_region_type *region;
4828 lang_memory_region_type *lma_region;
4829 struct overlay_list *l;
4830 struct lang_nocrossref *nocrossref;
4832 if (memspec == NULL)
4835 region = lang_memory_region_lookup (memspec);
4837 if (lma_memspec == NULL)
4840 lma_region = lang_memory_region_lookup (lma_memspec);
4847 struct overlay_list *next;
4849 if (fill != 0 && l->os->fill == 0)
4851 if (region != NULL && l->os->region == NULL)
4852 l->os->region = region;
4853 /* We only set lma_region for the first overlay section, as
4854 subsequent overlay sections will have load_base set relative
4855 to the first section. Also, don't set lma_region if
4856 load_base is specified. FIXME: There should really be a test
4857 that `AT ( LDADDR )' doesn't conflict with `AT >LMA_REGION'
4858 rather than letting LDADDR simply override LMA_REGION. */
4859 if (lma_region != NULL && l->os->lma_region == NULL
4860 && l->next == NULL && l->os->load_base == NULL)
4861 l->os->lma_region = lma_region;
4862 if (phdrs != NULL && l->os->phdrs == NULL)
4863 l->os->phdrs = phdrs;
4865 if (overlay_nocrossrefs)
4867 struct lang_nocrossref *nc;
4869 nc = (struct lang_nocrossref *) xmalloc (sizeof *nc);
4870 nc->name = l->os->name;
4871 nc->next = nocrossref;
4880 if (nocrossref != NULL)
4881 lang_add_nocrossref (nocrossref);
4883 /* Update . for the end of the overlay. */
4884 lang_add_assignment (exp_assop ('=', ".",
4885 exp_binop ('+', overlay_vma, overlay_max)));
4889 overlay_nocrossrefs = 0;
4890 overlay_list = NULL;
4894 /* Version handling. This is only useful for ELF. */
4896 /* This global variable holds the version tree that we build. */
4898 struct bfd_elf_version_tree *lang_elf_version_info;
4901 lang_vers_match_lang_c (expr, sym)
4902 struct bfd_elf_version_expr *expr;
4905 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4907 return fnmatch (expr->pattern, sym, 0) == 0;
4911 lang_vers_match_lang_cplusplus (expr, sym)
4912 struct bfd_elf_version_expr *expr;
4918 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4921 alt_sym = cplus_demangle (sym, /* DMGL_NO_TPARAMS */ 0);
4924 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
4925 Should we early out false in this case? */
4926 result = fnmatch (expr->pattern, sym, 0) == 0;
4930 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
4938 lang_vers_match_lang_java (expr, sym)
4939 struct bfd_elf_version_expr *expr;
4945 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4948 alt_sym = cplus_demangle (sym, DMGL_JAVA);
4951 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
4952 Should we early out false in this case? */
4953 result = fnmatch (expr->pattern, sym, 0) == 0;
4957 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
4964 /* This is called for each variable name or match expression. */
4966 struct bfd_elf_version_expr *
4967 lang_new_vers_regex (orig, new, lang)
4968 struct bfd_elf_version_expr *orig;
4972 struct bfd_elf_version_expr *ret;
4974 ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret);
4978 if (lang == NULL || strcasecmp (lang, "C") == 0)
4979 ret->match = lang_vers_match_lang_c;
4980 else if (strcasecmp (lang, "C++") == 0)
4981 ret->match = lang_vers_match_lang_cplusplus;
4982 else if (strcasecmp (lang, "Java") == 0)
4983 ret->match = lang_vers_match_lang_java;
4986 einfo (_("%X%P: unknown language `%s' in version information\n"),
4988 ret->match = lang_vers_match_lang_c;
4994 /* This is called for each set of variable names and match
4997 struct bfd_elf_version_tree *
4998 lang_new_vers_node (globals, locals)
4999 struct bfd_elf_version_expr *globals;
5000 struct bfd_elf_version_expr *locals;
5002 struct bfd_elf_version_tree *ret;
5004 ret = (struct bfd_elf_version_tree *) xmalloc (sizeof *ret);
5008 ret->globals = globals;
5009 ret->locals = locals;
5011 ret->name_indx = (unsigned int) -1;
5016 /* This static variable keeps track of version indices. */
5018 static int version_index;
5020 /* This is called when we know the name and dependencies of the
5024 lang_register_vers_node (name, version, deps)
5026 struct bfd_elf_version_tree *version;
5027 struct bfd_elf_version_deps *deps;
5029 struct bfd_elf_version_tree *t, **pp;
5030 struct bfd_elf_version_expr *e1;
5032 /* Make sure this node has a unique name. */
5033 for (t = lang_elf_version_info; t != NULL; t = t->next)
5034 if (strcmp (t->name, name) == 0)
5035 einfo (_("%X%P: duplicate version tag `%s'\n"), name);
5037 /* Check the global and local match names, and make sure there
5038 aren't any duplicates. */
5040 for (e1 = version->globals; e1 != NULL; e1 = e1->next)
5042 for (t = lang_elf_version_info; t != NULL; t = t->next)
5044 struct bfd_elf_version_expr *e2;
5046 for (e2 = t->locals; e2 != NULL; e2 = e2->next)
5047 if (strcmp (e1->pattern, e2->pattern) == 0)
5048 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5053 for (e1 = version->locals; e1 != NULL; e1 = e1->next)
5055 for (t = lang_elf_version_info; t != NULL; t = t->next)
5057 struct bfd_elf_version_expr *e2;
5059 for (e2 = t->globals; e2 != NULL; e2 = e2->next)
5060 if (strcmp (e1->pattern, e2->pattern) == 0)
5061 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5066 version->deps = deps;
5067 version->name = name;
5069 version->vernum = version_index;
5071 for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
5076 /* This is called when we see a version dependency. */
5078 struct bfd_elf_version_deps *
5079 lang_add_vers_depend (list, name)
5080 struct bfd_elf_version_deps *list;
5083 struct bfd_elf_version_deps *ret;
5084 struct bfd_elf_version_tree *t;
5086 ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret);
5089 for (t = lang_elf_version_info; t != NULL; t = t->next)
5091 if (strcmp (t->name, name) == 0)
5093 ret->version_needed = t;
5098 einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
5104 lang_do_version_exports_section ()
5106 struct bfd_elf_version_expr *greg = NULL, *lreg;
5108 LANG_FOR_EACH_INPUT_STATEMENT (is)
5110 asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
5117 len = bfd_section_size (is->the_bfd, sec);
5118 contents = xmalloc (len);
5119 if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
5120 einfo (_("%X%P: unable to read .exports section contents"), sec);
5123 while (p < contents + len)
5125 greg = lang_new_vers_regex (greg, p, NULL);
5126 p = strchr (p, '\0') + 1;
5129 /* Do not free the contents, as we used them creating the regex. */
5131 /* Do not include this section in the link. */
5132 bfd_set_section_flags (is->the_bfd, sec,
5133 bfd_get_section_flags (is->the_bfd, sec) | SEC_EXCLUDE);
5136 lreg = lang_new_vers_regex (NULL, "*", NULL);
5137 lang_register_vers_node (command_line.version_exports_section,
5138 lang_new_vers_node (greg, lreg), NULL);
5142 lang_add_unique (name)
5145 struct unique_sections *ent;
5147 for (ent = unique_section_list; ent; ent = ent->next)
5148 if (strcmp (ent->name, name) == 0)
5151 ent = (struct unique_sections *) xmalloc (sizeof *ent);
5152 ent->name = xstrdup (name);
5153 ent->next = unique_section_list;
5154 unique_section_list = ent;