1 /* Linker command language support.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 Free Software Foundation, Inc.
6 This file is part of GLD, the Gnu Linker.
8 GLD is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GLD is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GLD; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
25 #include "libiberty.h"
26 #include "safe-ctype.h"
45 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
48 /* Locals variables. */
49 static struct obstack stat_obstack;
51 #define obstack_chunk_alloc xmalloc
52 #define obstack_chunk_free free
53 static const char *startup_file;
54 static lang_statement_list_type input_file_chain;
55 static bfd_boolean placed_commons = FALSE;
56 static lang_output_section_statement_type *default_common_section;
57 static bfd_boolean map_option_f;
58 static bfd_vma print_dot;
59 static lang_input_statement_type *first_file;
60 static const char *current_target;
61 static const char *output_target;
62 static lang_statement_list_type statement_list;
63 static struct lang_phdr *lang_phdr_list;
64 static struct bfd_hash_table lang_definedness_table;
66 /* Forward declarations. */
67 static void exp_init_os (etree_type *);
68 static bfd_boolean wildcardp (const char *);
69 static lang_input_statement_type *lookup_name (const char *);
70 static bfd_boolean load_symbols (lang_input_statement_type *,
71 lang_statement_list_type *);
72 static struct bfd_hash_entry *lang_definedness_newfunc
73 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
74 static void insert_undefined (const char *);
75 static void print_statement (lang_statement_union_type *,
76 lang_output_section_statement_type *);
77 static void print_statement_list (lang_statement_union_type *,
78 lang_output_section_statement_type *);
79 static void print_statements (void);
80 static bfd_boolean lang_one_common (struct bfd_link_hash_entry *, void *);
81 static void lang_record_phdrs (void);
82 static void lang_do_version_exports_section (void);
84 typedef void (*callback_t) (lang_wild_statement_type *, struct wildcard_list *,
85 asection *, lang_input_statement_type *, void *);
87 /* Exported variables. */
88 lang_output_section_statement_type *abs_output_section;
89 lang_statement_list_type lang_output_section_statement;
90 lang_statement_list_type *stat_ptr = &statement_list;
91 lang_statement_list_type file_chain = { NULL, NULL };
92 struct bfd_sym_chain entry_symbol = { NULL, NULL };
93 const char *entry_section = ".text";
94 bfd_boolean entry_from_cmdline;
95 bfd_boolean lang_has_input_file = FALSE;
96 bfd_boolean had_output_filename = FALSE;
97 bfd_boolean lang_float_flag = FALSE;
98 bfd_boolean delete_output_file_on_failure = FALSE;
99 struct lang_nocrossrefs *nocrossref_list;
100 struct unique_sections *unique_section_list;
101 static bfd_boolean ldlang_sysrooted_script = FALSE;
102 int lang_statement_iteration = 0;
104 etree_type *base; /* Relocation base - or null */
106 #define new_stat(x, y) \
107 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
109 #define outside_section_address(q) \
110 ((q)->output_offset + (q)->output_section->vma)
112 #define outside_symbol_address(q) \
113 ((q)->value + outside_section_address (q->section))
115 #define SECTION_NAME_MAP_LENGTH (16)
118 stat_alloc (size_t size)
120 return obstack_alloc (&stat_obstack, size);
124 unique_section_p (const char *secnam)
126 struct unique_sections *unam;
128 for (unam = unique_section_list; unam; unam = unam->next)
129 if (wildcardp (unam->name)
130 ? fnmatch (unam->name, secnam, 0) == 0
131 : strcmp (unam->name, secnam) == 0)
139 /* Generic traversal routines for finding matching sections. */
142 walk_wild_section (lang_wild_statement_type *ptr,
143 lang_input_statement_type *file,
149 if (file->just_syms_flag)
152 for (s = file->the_bfd->sections; s != NULL; s = s->next)
154 struct wildcard_list *sec;
156 sec = ptr->section_list;
158 (*callback) (ptr, sec, s, file, data);
162 bfd_boolean skip = FALSE;
163 struct name_list *list_tmp;
165 /* Don't process sections from files which were
167 for (list_tmp = sec->spec.exclude_name_list;
169 list_tmp = list_tmp->next)
171 if (wildcardp (list_tmp->name))
172 skip = fnmatch (list_tmp->name, file->filename, 0) == 0;
174 skip = strcmp (list_tmp->name, file->filename) == 0;
176 /* If this file is part of an archive, and the archive is
177 excluded, exclude this file. */
178 if (! skip && file->the_bfd != NULL
179 && file->the_bfd->my_archive != NULL
180 && file->the_bfd->my_archive->filename != NULL)
182 if (wildcardp (list_tmp->name))
183 skip = fnmatch (list_tmp->name,
184 file->the_bfd->my_archive->filename,
187 skip = strcmp (list_tmp->name,
188 file->the_bfd->my_archive->filename) == 0;
195 if (!skip && sec->spec.name != NULL)
197 const char *sname = bfd_get_section_name (file->the_bfd, s);
199 if (wildcardp (sec->spec.name))
200 skip = fnmatch (sec->spec.name, sname, 0) != 0;
202 skip = strcmp (sec->spec.name, sname) != 0;
206 (*callback) (ptr, sec, s, file, data);
213 /* Handle a wild statement for a single file F. */
216 walk_wild_file (lang_wild_statement_type *s,
217 lang_input_statement_type *f,
221 if (f->the_bfd == NULL
222 || ! bfd_check_format (f->the_bfd, bfd_archive))
223 walk_wild_section (s, f, callback, data);
228 /* This is an archive file. We must map each member of the
229 archive separately. */
230 member = bfd_openr_next_archived_file (f->the_bfd, NULL);
231 while (member != NULL)
233 /* When lookup_name is called, it will call the add_symbols
234 entry point for the archive. For each element of the
235 archive which is included, BFD will call ldlang_add_file,
236 which will set the usrdata field of the member to the
237 lang_input_statement. */
238 if (member->usrdata != NULL)
240 walk_wild_section (s, member->usrdata, callback, data);
243 member = bfd_openr_next_archived_file (f->the_bfd, member);
249 walk_wild (lang_wild_statement_type *s, callback_t callback, void *data)
251 const char *file_spec = s->filename;
253 if (file_spec == NULL)
255 /* Perform the iteration over all files in the list. */
256 LANG_FOR_EACH_INPUT_STATEMENT (f)
258 walk_wild_file (s, f, callback, data);
261 else if (wildcardp (file_spec))
263 LANG_FOR_EACH_INPUT_STATEMENT (f)
265 if (fnmatch (file_spec, f->filename, FNM_FILE_NAME) == 0)
266 walk_wild_file (s, f, callback, data);
271 lang_input_statement_type *f;
273 /* Perform the iteration over a single file. */
274 f = lookup_name (file_spec);
276 walk_wild_file (s, f, callback, data);
280 /* lang_for_each_statement walks the parse tree and calls the provided
281 function for each node. */
284 lang_for_each_statement_worker (void (*func) (lang_statement_union_type *),
285 lang_statement_union_type *s)
287 for (; s != NULL; s = s->header.next)
291 switch (s->header.type)
293 case lang_constructors_statement_enum:
294 lang_for_each_statement_worker (func, constructor_list.head);
296 case lang_output_section_statement_enum:
297 lang_for_each_statement_worker
299 s->output_section_statement.children.head);
301 case lang_wild_statement_enum:
302 lang_for_each_statement_worker
304 s->wild_statement.children.head);
306 case lang_group_statement_enum:
307 lang_for_each_statement_worker (func,
308 s->group_statement.children.head);
310 case lang_data_statement_enum:
311 case lang_reloc_statement_enum:
312 case lang_object_symbols_statement_enum:
313 case lang_output_statement_enum:
314 case lang_target_statement_enum:
315 case lang_input_section_enum:
316 case lang_input_statement_enum:
317 case lang_assignment_statement_enum:
318 case lang_padding_statement_enum:
319 case lang_address_statement_enum:
320 case lang_fill_statement_enum:
330 lang_for_each_statement (void (*func) (lang_statement_union_type *))
332 lang_for_each_statement_worker (func, statement_list.head);
335 /*----------------------------------------------------------------------*/
338 lang_list_init (lang_statement_list_type *list)
341 list->tail = &list->head;
344 /* Build a new statement node for the parse tree. */
346 static lang_statement_union_type *
347 new_statement (enum statement_enum type,
349 lang_statement_list_type *list)
351 lang_statement_union_type *new;
353 new = stat_alloc (size);
354 new->header.type = type;
355 new->header.next = NULL;
356 lang_statement_append (list, new, &new->header.next);
360 /* Build a new input file node for the language. There are several
361 ways in which we treat an input file, eg, we only look at symbols,
362 or prefix it with a -l etc.
364 We can be supplied with requests for input files more than once;
365 they may, for example be split over several lines like foo.o(.text)
366 foo.o(.data) etc, so when asked for a file we check that we haven't
367 got it already so we don't duplicate the bfd. */
369 static lang_input_statement_type *
370 new_afile (const char *name,
371 lang_input_file_enum_type file_type,
373 bfd_boolean add_to_list)
375 lang_input_statement_type *p;
378 p = new_stat (lang_input_statement, stat_ptr);
381 p = stat_alloc (sizeof (lang_input_statement_type));
382 p->header.next = NULL;
385 lang_has_input_file = TRUE;
387 p->sysrooted = FALSE;
390 case lang_input_file_is_symbols_only_enum:
392 p->is_archive = FALSE;
394 p->local_sym_name = name;
395 p->just_syms_flag = TRUE;
396 p->search_dirs_flag = FALSE;
398 case lang_input_file_is_fake_enum:
400 p->is_archive = FALSE;
402 p->local_sym_name = name;
403 p->just_syms_flag = FALSE;
404 p->search_dirs_flag = FALSE;
406 case lang_input_file_is_l_enum:
407 p->is_archive = TRUE;
410 p->local_sym_name = concat ("-l", name, NULL);
411 p->just_syms_flag = FALSE;
412 p->search_dirs_flag = TRUE;
414 case lang_input_file_is_marker_enum:
416 p->is_archive = FALSE;
418 p->local_sym_name = name;
419 p->just_syms_flag = FALSE;
420 p->search_dirs_flag = TRUE;
422 case lang_input_file_is_search_file_enum:
423 p->sysrooted = ldlang_sysrooted_script;
425 p->is_archive = FALSE;
427 p->local_sym_name = name;
428 p->just_syms_flag = FALSE;
429 p->search_dirs_flag = TRUE;
431 case lang_input_file_is_file_enum:
433 p->is_archive = FALSE;
435 p->local_sym_name = name;
436 p->just_syms_flag = FALSE;
437 p->search_dirs_flag = FALSE;
444 p->next_real_file = NULL;
447 p->dynamic = config.dynamic_link;
448 p->whole_archive = whole_archive;
450 lang_statement_append (&input_file_chain,
451 (lang_statement_union_type *) p,
456 lang_input_statement_type *
457 lang_add_input_file (const char *name,
458 lang_input_file_enum_type file_type,
461 lang_has_input_file = TRUE;
462 return new_afile (name, file_type, target, TRUE);
465 /* Build enough state so that the parser can build its tree. */
470 obstack_begin (&stat_obstack, 1000);
472 stat_ptr = &statement_list;
474 lang_list_init (stat_ptr);
476 lang_list_init (&input_file_chain);
477 lang_list_init (&lang_output_section_statement);
478 lang_list_init (&file_chain);
479 first_file = lang_add_input_file (NULL, lang_input_file_is_marker_enum,
482 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME);
484 abs_output_section->bfd_section = bfd_abs_section_ptr;
486 /* The value "3" is ad-hoc, somewhat related to the expected number of
487 DEFINED expressions in a linker script. For most default linker
488 scripts, there are none. Why a hash table then? Well, it's somewhat
489 simpler to re-use working machinery than using a linked list in terms
490 of code-complexity here in ld, besides the initialization which just
491 looks like other code here. */
492 if (bfd_hash_table_init_n (&lang_definedness_table,
493 lang_definedness_newfunc, 3) != TRUE)
494 einfo (_("%P%F: out of memory during initialization"));
496 /* Callers of exp_fold_tree need to increment this. */
497 lang_statement_iteration = 0;
500 /*----------------------------------------------------------------------
501 A region is an area of memory declared with the
502 MEMORY { name:org=exp, len=exp ... }
505 We maintain a list of all the regions here.
507 If no regions are specified in the script, then the default is used
508 which is created when looked up to be the entire data space.
510 If create is true we are creating a region inside a MEMORY block.
511 In this case it is probably an error to create a region that has
512 already been created. If we are not inside a MEMORY block it is
513 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
514 and so we issue a warning. */
516 static lang_memory_region_type *lang_memory_region_list;
517 static lang_memory_region_type **lang_memory_region_list_tail = &lang_memory_region_list;
519 lang_memory_region_type *
520 lang_memory_region_lookup (const char *const name, bfd_boolean create)
522 lang_memory_region_type *p;
523 lang_memory_region_type *new;
525 /* NAME is NULL for LMA memspecs if no region was specified. */
529 for (p = lang_memory_region_list; p != NULL; p = p->next)
530 if (strcmp (p->name, name) == 0)
533 einfo (_("%P:%S: warning: redeclaration of memory region '%s'\n"), name);
538 /* This code used to always use the first region in the list as the
539 default region. I changed it to instead use a region
540 encompassing all of memory as the default region. This permits
541 NOLOAD sections to work reasonably without requiring a region.
542 People should specify what region they mean, if they really want
544 if (strcmp (name, DEFAULT_MEMORY_REGION) == 0)
546 if (lang_memory_region_list != NULL)
547 return lang_memory_region_list;
551 if (!create && strcmp (name, DEFAULT_MEMORY_REGION))
552 einfo (_("%P:%S: warning: memory region %s not declared\n"), name);
554 new = stat_alloc (sizeof (lang_memory_region_type));
556 new->name = xstrdup (name);
559 *lang_memory_region_list_tail = new;
560 lang_memory_region_list_tail = &new->next;
564 new->length = ~(bfd_size_type) 0;
566 new->had_full_message = FALSE;
571 static lang_memory_region_type *
572 lang_memory_default (asection *section)
574 lang_memory_region_type *p;
576 flagword sec_flags = section->flags;
578 /* Override SEC_DATA to mean a writable section. */
579 if ((sec_flags & (SEC_ALLOC | SEC_READONLY | SEC_CODE)) == SEC_ALLOC)
580 sec_flags |= SEC_DATA;
582 for (p = lang_memory_region_list; p != NULL; p = p->next)
584 if ((p->flags & sec_flags) != 0
585 && (p->not_flags & sec_flags) == 0)
590 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
593 lang_output_section_statement_type *
594 lang_output_section_find (const char *const name)
596 lang_statement_union_type *u;
597 lang_output_section_statement_type *lookup;
599 for (u = lang_output_section_statement.head; u != NULL; u = lookup->next)
601 lookup = &u->output_section_statement;
602 if (strcmp (name, lookup->name) == 0)
608 lang_output_section_statement_type *
609 lang_output_section_statement_lookup (const char *const name)
611 lang_output_section_statement_type *lookup;
613 lookup = lang_output_section_find (name);
616 lookup = new_stat (lang_output_section_statement, stat_ptr);
617 lookup->region = NULL;
618 lookup->lma_region = NULL;
620 lookup->block_value = 1;
624 lookup->bfd_section = NULL;
625 lookup->processed = FALSE;
626 lookup->sectype = normal_section;
627 lookup->addr_tree = NULL;
628 lang_list_init (&lookup->children);
630 lookup->memspec = NULL;
632 lookup->subsection_alignment = -1;
633 lookup->section_alignment = -1;
634 lookup->load_base = NULL;
635 lookup->update_dot_tree = NULL;
636 lookup->phdrs = NULL;
638 lang_statement_append (&lang_output_section_statement,
639 (lang_statement_union_type *) lookup,
646 lang_map_flags (flagword flag)
648 if (flag & SEC_ALLOC)
654 if (flag & SEC_READONLY)
667 lang_memory_region_type *m;
669 minfo (_("\nMemory Configuration\n\n"));
670 fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
671 _("Name"), _("Origin"), _("Length"), _("Attributes"));
673 for (m = lang_memory_region_list; m != NULL; m = m->next)
678 fprintf (config.map_file, "%-16s ", m->name);
680 sprintf_vma (buf, m->origin);
681 minfo ("0x%s ", buf);
689 minfo ("0x%V", m->length);
690 if (m->flags || m->not_flags)
698 lang_map_flags (m->flags);
704 lang_map_flags (m->not_flags);
711 fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
716 /* Initialize an output section. */
719 init_os (lang_output_section_statement_type *s)
721 section_userdata_type *new;
723 if (s->bfd_section != NULL)
726 if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
727 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME);
729 new = stat_alloc (sizeof (section_userdata_type));
731 s->bfd_section = bfd_get_section_by_name (output_bfd, s->name);
732 if (s->bfd_section == NULL)
733 s->bfd_section = bfd_make_section (output_bfd, s->name);
734 if (s->bfd_section == NULL)
736 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
737 output_bfd->xvec->name, s->name);
739 s->bfd_section->output_section = s->bfd_section;
741 /* We initialize an output sections output offset to minus its own
742 vma to allow us to output a section through itself. */
743 s->bfd_section->output_offset = 0;
744 get_userdata (s->bfd_section) = new;
746 /* If there is a base address, make sure that any sections it might
747 mention are initialized. */
748 if (s->addr_tree != NULL)
749 exp_init_os (s->addr_tree);
751 if (s->load_base != NULL)
752 exp_init_os (s->load_base);
755 /* Make sure that all output sections mentioned in an expression are
759 exp_init_os (etree_type *exp)
761 switch (exp->type.node_class)
764 exp_init_os (exp->assign.src);
768 exp_init_os (exp->binary.lhs);
769 exp_init_os (exp->binary.rhs);
773 exp_init_os (exp->trinary.cond);
774 exp_init_os (exp->trinary.lhs);
775 exp_init_os (exp->trinary.rhs);
779 exp_init_os (exp->unary.child);
783 switch (exp->type.node_code)
789 lang_output_section_statement_type *os;
791 os = lang_output_section_find (exp->name.name);
792 if (os != NULL && os->bfd_section == NULL)
803 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
804 once into the output. This routine checks each section, and
805 arrange to discard it if a section of the same name has already
806 been linked. If the section has COMDAT information, then it uses
807 that to decide whether the section should be included. This code
808 assumes that all relevant sections have the SEC_LINK_ONCE flag set;
809 that is, it does not depend solely upon the section name.
810 section_already_linked is called via bfd_map_over_sections. */
812 /* This is the shape of the elements inside the already_linked hash
813 table. It maps a name onto a list of already_linked elements with
814 the same name. It's possible to get more than one element in a
815 list if the COMDAT sections have different names. */
817 struct already_linked_hash_entry
819 struct bfd_hash_entry root;
820 struct already_linked *entry;
823 struct already_linked
825 struct already_linked *next;
829 /* The hash table. */
831 static struct bfd_hash_table already_linked_table;
834 section_already_linked (bfd *abfd, asection *sec, void *data)
836 lang_input_statement_type *entry = data;
839 struct already_linked *l;
840 struct already_linked_hash_entry *already_linked_list;
842 /* If we are only reading symbols from this object, then we want to
843 discard all sections. */
844 if (entry->just_syms_flag)
846 bfd_link_just_syms (sec, &link_info);
850 flags = bfd_get_section_flags (abfd, sec);
852 if ((flags & SEC_LINK_ONCE) == 0)
855 /* FIXME: When doing a relocatable link, we may have trouble
856 copying relocations in other sections that refer to local symbols
857 in the section being discarded. Those relocations will have to
858 be converted somehow; as of this writing I'm not sure that any of
859 the backends handle that correctly.
861 It is tempting to instead not discard link once sections when
862 doing a relocatable link (technically, they should be discarded
863 whenever we are building constructors). However, that fails,
864 because the linker winds up combining all the link once sections
865 into a single large link once section, which defeats the purpose
866 of having link once sections in the first place.
868 Also, not merging link once sections in a relocatable link
869 causes trouble for MIPS ELF, which relies on link once semantics
870 to handle the .reginfo section correctly. */
872 name = bfd_get_section_name (abfd, sec);
874 already_linked_list =
875 ((struct already_linked_hash_entry *)
876 bfd_hash_lookup (&already_linked_table, name, TRUE, FALSE));
878 for (l = already_linked_list->entry; l != NULL; l = l->next)
880 if (sec->comdat == NULL
881 || l->sec->comdat == NULL
882 || strcmp (sec->comdat->name, l->sec->comdat->name) == 0)
884 /* The section has already been linked. See if we should
886 switch (flags & SEC_LINK_DUPLICATES)
891 case SEC_LINK_DUPLICATES_DISCARD:
894 case SEC_LINK_DUPLICATES_ONE_ONLY:
895 if (sec->comdat == NULL)
896 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
899 einfo (_("%P: %B: warning: ignoring duplicate `%s' section symbol `%s'\n"),
900 abfd, name, sec->comdat->name);
903 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
904 /* FIXME: We should really dig out the contents of both
905 sections and memcmp them. The COFF/PE spec says that
906 the Microsoft linker does not implement this
907 correctly, so I'm not going to bother doing it
910 case SEC_LINK_DUPLICATES_SAME_SIZE:
911 if (bfd_section_size (abfd, sec)
912 != bfd_section_size (l->sec->owner, l->sec))
913 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
918 /* Set the output_section field so that lang_add_section
919 does not create a lang_input_section structure for this
920 section. Since there might be a symbol in the section
921 being discarded, we must retain a pointer to the section
922 which we are really going to use. */
923 sec->output_section = bfd_abs_section_ptr;
924 sec->kept_section = l->sec;
926 if (flags & SEC_GROUP)
927 bfd_discard_group (abfd, sec);
933 /* This is the first section with this name. Record it. Allocate
934 the memory from the same obstack as the hash table is kept in. */
936 l = bfd_hash_allocate (&already_linked_table, sizeof *l);
939 l->next = already_linked_list->entry;
940 already_linked_list->entry = l;
943 /* Support routines for the hash table used by section_already_linked,
944 initialize the table, fill in an entry and remove the table. */
946 static struct bfd_hash_entry *
947 already_linked_newfunc (struct bfd_hash_entry *entry ATTRIBUTE_UNUSED,
948 struct bfd_hash_table *table,
949 const char *string ATTRIBUTE_UNUSED)
951 struct already_linked_hash_entry *ret =
952 bfd_hash_allocate (table, sizeof (struct already_linked_hash_entry));
960 already_linked_table_init (void)
962 if (! bfd_hash_table_init_n (&already_linked_table,
963 already_linked_newfunc,
965 einfo (_("%P%F: Failed to create hash table\n"));
969 already_linked_table_free (void)
971 bfd_hash_table_free (&already_linked_table);
974 /* The wild routines.
976 These expand statements like *(.text) and foo.o to a list of
977 explicit actions, like foo.o(.text), bar.o(.text) and
978 foo.o(.text, .data). */
980 /* Return TRUE if the PATTERN argument is a wildcard pattern.
981 Although backslashes are treated specially if a pattern contains
982 wildcards, we do not consider the mere presence of a backslash to
983 be enough to cause the pattern to be treated as a wildcard.
984 That lets us handle DOS filenames more naturally. */
987 wildcardp (const char *pattern)
991 for (s = pattern; *s != '\0'; ++s)
999 /* Add SECTION to the output section OUTPUT. Do this by creating a
1000 lang_input_section statement which is placed at PTR. FILE is the
1001 input file which holds SECTION. */
1004 lang_add_section (lang_statement_list_type *ptr,
1006 lang_output_section_statement_type *output,
1007 lang_input_statement_type *file)
1010 bfd_boolean discard;
1012 flags = bfd_get_section_flags (section->owner, section);
1016 /* Discard sections marked with SEC_EXCLUDE if we are doing a final
1017 link. Discard debugging sections marked with SEC_EXCLUDE on a
1018 relocatable link too. */
1019 if ((flags & SEC_EXCLUDE) != 0
1020 && ((flags & SEC_DEBUGGING) != 0 || !link_info.relocatable))
1023 /* Discard input sections which are assigned to a section named
1024 DISCARD_SECTION_NAME. */
1025 if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
1028 /* Discard debugging sections if we are stripping debugging
1030 if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
1031 && (flags & SEC_DEBUGGING) != 0)
1036 if (section->output_section == NULL)
1038 /* This prevents future calls from assigning this section. */
1039 section->output_section = bfd_abs_section_ptr;
1044 if (section->output_section == NULL)
1047 lang_input_section_type *new;
1050 if (output->bfd_section == NULL)
1053 first = ! output->bfd_section->linker_has_input;
1054 output->bfd_section->linker_has_input = 1;
1056 /* Add a section reference to the list. */
1057 new = new_stat (lang_input_section, ptr);
1059 new->section = section;
1061 section->output_section = output->bfd_section;
1063 flags = section->flags;
1065 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1066 to an output section, because we want to be able to include a
1067 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1068 section (I don't know why we want to do this, but we do).
1069 build_link_order in ldwrite.c handles this case by turning
1070 the embedded SEC_NEVER_LOAD section into a fill. */
1072 flags &= ~ SEC_NEVER_LOAD;
1074 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1075 already been processed. One reason to do this is that on pe
1076 format targets, .text$foo sections go into .text and it's odd
1077 to see .text with SEC_LINK_ONCE set. */
1079 if (! link_info.relocatable)
1080 flags &= ~ (SEC_LINK_ONCE | SEC_LINK_DUPLICATES);
1082 /* If this is not the first input section, and the SEC_READONLY
1083 flag is not currently set, then don't set it just because the
1084 input section has it set. */
1086 if (! first && (section->output_section->flags & SEC_READONLY) == 0)
1087 flags &= ~ SEC_READONLY;
1089 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
1091 && ((section->output_section->flags & (SEC_MERGE | SEC_STRINGS))
1092 != (flags & (SEC_MERGE | SEC_STRINGS))
1093 || ((flags & SEC_MERGE)
1094 && section->output_section->entsize != section->entsize)))
1096 section->output_section->flags &= ~ (SEC_MERGE | SEC_STRINGS);
1097 flags &= ~ (SEC_MERGE | SEC_STRINGS);
1100 /* For now make .tbss normal section. */
1101 if ((flags & SEC_THREAD_LOCAL) && ! link_info.relocatable)
1104 section->output_section->flags |= flags;
1106 if (flags & SEC_MERGE)
1107 section->output_section->entsize = section->entsize;
1109 /* If SEC_READONLY is not set in the input section, then clear
1110 it from the output section. */
1111 if ((section->flags & SEC_READONLY) == 0)
1112 section->output_section->flags &= ~SEC_READONLY;
1114 switch (output->sectype)
1116 case normal_section:
1121 case overlay_section:
1122 output->bfd_section->flags &= ~SEC_ALLOC;
1124 case noload_section:
1125 output->bfd_section->flags &= ~SEC_LOAD;
1126 output->bfd_section->flags |= SEC_NEVER_LOAD;
1130 /* Copy over SEC_SMALL_DATA. */
1131 if (section->flags & SEC_SMALL_DATA)
1132 section->output_section->flags |= SEC_SMALL_DATA;
1134 if (section->alignment_power > output->bfd_section->alignment_power)
1135 output->bfd_section->alignment_power = section->alignment_power;
1137 /* If supplied an alignment, then force it. */
1138 if (output->section_alignment != -1)
1139 output->bfd_section->alignment_power = output->section_alignment;
1141 if (section->flags & SEC_BLOCK)
1143 section->output_section->flags |= SEC_BLOCK;
1144 /* FIXME: This value should really be obtained from the bfd... */
1145 output->block_value = 128;
1150 /* Handle wildcard sorting. This returns the lang_input_section which
1151 should follow the one we are going to create for SECTION and FILE,
1152 based on the sorting requirements of WILD. It returns NULL if the
1153 new section should just go at the end of the current list. */
1155 static lang_statement_union_type *
1156 wild_sort (lang_wild_statement_type *wild,
1157 struct wildcard_list *sec,
1158 lang_input_statement_type *file,
1161 const char *section_name;
1162 lang_statement_union_type *l;
1164 if (!wild->filenames_sorted && (sec == NULL || !sec->spec.sorted))
1167 section_name = bfd_get_section_name (file->the_bfd, section);
1168 for (l = wild->children.head; l != NULL; l = l->header.next)
1170 lang_input_section_type *ls;
1172 if (l->header.type != lang_input_section_enum)
1174 ls = &l->input_section;
1176 /* Sorting by filename takes precedence over sorting by section
1179 if (wild->filenames_sorted)
1181 const char *fn, *ln;
1185 /* The PE support for the .idata section as generated by
1186 dlltool assumes that files will be sorted by the name of
1187 the archive and then the name of the file within the
1190 if (file->the_bfd != NULL
1191 && bfd_my_archive (file->the_bfd) != NULL)
1193 fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
1198 fn = file->filename;
1202 if (ls->ifile->the_bfd != NULL
1203 && bfd_my_archive (ls->ifile->the_bfd) != NULL)
1205 ln = bfd_get_filename (bfd_my_archive (ls->ifile->the_bfd));
1210 ln = ls->ifile->filename;
1214 i = strcmp (fn, ln);
1223 fn = file->filename;
1225 ln = ls->ifile->filename;
1227 i = strcmp (fn, ln);
1235 /* Here either the files are not sorted by name, or we are
1236 looking at the sections for this file. */
1238 if (sec != NULL && sec->spec.sorted)
1240 if (strcmp (section_name,
1241 bfd_get_section_name (ls->ifile->the_bfd,
1251 /* Expand a wild statement for a particular FILE. SECTION may be
1252 NULL, in which case it is a wild card. */
1255 output_section_callback (lang_wild_statement_type *ptr,
1256 struct wildcard_list *sec,
1258 lang_input_statement_type *file,
1261 lang_statement_union_type *before;
1263 /* Exclude sections that match UNIQUE_SECTION_LIST. */
1264 if (unique_section_p (bfd_get_section_name (file->the_bfd, section)))
1267 /* If the wild pattern was marked KEEP, the member sections
1268 should be as well. */
1269 if (ptr->keep_sections)
1270 section->flags |= SEC_KEEP;
1272 before = wild_sort (ptr, sec, file, section);
1274 /* Here BEFORE points to the lang_input_section which
1275 should follow the one we are about to add. If BEFORE
1276 is NULL, then the section should just go at the end
1277 of the current list. */
1280 lang_add_section (&ptr->children, section,
1281 (lang_output_section_statement_type *) output,
1285 lang_statement_list_type list;
1286 lang_statement_union_type **pp;
1288 lang_list_init (&list);
1289 lang_add_section (&list, section,
1290 (lang_output_section_statement_type *) output,
1293 /* If we are discarding the section, LIST.HEAD will
1295 if (list.head != NULL)
1297 ASSERT (list.head->header.next == NULL);
1299 for (pp = &ptr->children.head;
1301 pp = &(*pp)->header.next)
1302 ASSERT (*pp != NULL);
1304 list.head->header.next = *pp;
1310 /* This is passed a file name which must have been seen already and
1311 added to the statement tree. We will see if it has been opened
1312 already and had its symbols read. If not then we'll read it. */
1314 static lang_input_statement_type *
1315 lookup_name (const char *name)
1317 lang_input_statement_type *search;
1319 for (search = (lang_input_statement_type *) input_file_chain.head;
1321 search = (lang_input_statement_type *) search->next_real_file)
1323 if (search->filename == NULL && name == NULL)
1325 if (search->filename != NULL
1327 && strcmp (search->filename, name) == 0)
1332 search = new_afile (name, lang_input_file_is_file_enum, default_target,
1335 /* If we have already added this file, or this file is not real
1336 (FIXME: can that ever actually happen?) or the name is NULL
1337 (FIXME: can that ever actually happen?) don't add this file. */
1340 || search->filename == NULL)
1343 if (! load_symbols (search, NULL))
1349 /* Get the symbols for an input file. */
1352 load_symbols (lang_input_statement_type *entry,
1353 lang_statement_list_type *place)
1360 ldfile_open_file (entry);
1362 if (! bfd_check_format (entry->the_bfd, bfd_archive)
1363 && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
1366 lang_statement_list_type *hold;
1367 bfd_boolean bad_load = TRUE;
1368 bfd_boolean save_ldlang_sysrooted_script;
1370 err = bfd_get_error ();
1372 /* See if the emulation has some special knowledge. */
1373 if (ldemul_unrecognized_file (entry))
1376 if (err == bfd_error_file_ambiguously_recognized)
1380 einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
1381 einfo (_("%B: matching formats:"), entry->the_bfd);
1382 for (p = matching; *p != NULL; p++)
1386 else if (err != bfd_error_file_not_recognized
1388 einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
1392 bfd_close (entry->the_bfd);
1393 entry->the_bfd = NULL;
1395 /* Try to interpret the file as a linker script. */
1396 ldfile_open_command_file (entry->filename);
1400 save_ldlang_sysrooted_script = ldlang_sysrooted_script;
1401 ldlang_sysrooted_script = entry->sysrooted;
1403 ldfile_assumed_script = TRUE;
1404 parser_input = input_script;
1406 ldfile_assumed_script = FALSE;
1408 ldlang_sysrooted_script = save_ldlang_sysrooted_script;
1414 if (ldemul_recognized_file (entry))
1417 /* We don't call ldlang_add_file for an archive. Instead, the
1418 add_symbols entry point will call ldlang_add_file, via the
1419 add_archive_element callback, for each element of the archive
1421 switch (bfd_get_format (entry->the_bfd))
1427 ldlang_add_file (entry);
1428 if (trace_files || trace_file_tries)
1429 info_msg ("%I\n", entry);
1433 if (entry->whole_archive)
1436 bfd_boolean loaded = TRUE;
1440 member = bfd_openr_next_archived_file (entry->the_bfd, member);
1445 if (! bfd_check_format (member, bfd_object))
1447 einfo (_("%F%B: member %B in archive is not an object\n"),
1448 entry->the_bfd, member);
1452 if (! ((*link_info.callbacks->add_archive_element)
1453 (&link_info, member, "--whole-archive")))
1456 if (! bfd_link_add_symbols (member, &link_info))
1458 einfo (_("%F%B: could not read symbols: %E\n"), member);
1463 entry->loaded = loaded;
1469 if (bfd_link_add_symbols (entry->the_bfd, &link_info))
1470 entry->loaded = TRUE;
1472 einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
1474 return entry->loaded;
1477 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
1478 may be NULL, indicating that it is a wildcard. Separate
1479 lang_input_section statements are created for each part of the
1480 expansion; they are added after the wild statement S. OUTPUT is
1481 the output section. */
1484 wild (lang_wild_statement_type *s,
1485 const char *target ATTRIBUTE_UNUSED,
1486 lang_output_section_statement_type *output)
1488 struct wildcard_list *sec;
1490 walk_wild (s, output_section_callback, output);
1492 for (sec = s->section_list; sec != NULL; sec = sec->next)
1494 if (default_common_section != NULL)
1496 if (sec->spec.name != NULL && strcmp (sec->spec.name, "COMMON") == 0)
1498 /* Remember the section that common is going to in case we
1499 later get something which doesn't know where to put it. */
1500 default_common_section = output;
1505 /* Return TRUE iff target is the sought target. */
1508 get_target (const bfd_target *target, void *data)
1510 const char *sought = data;
1512 return strcmp (target->name, sought) == 0;
1515 /* Like strcpy() but convert to lower case as well. */
1518 stricpy (char *dest, char *src)
1522 while ((c = *src++) != 0)
1523 *dest++ = TOLOWER (c);
1528 /* Remove the first occurrence of needle (if any) in haystack
1532 strcut (char *haystack, char *needle)
1534 haystack = strstr (haystack, needle);
1540 for (src = haystack + strlen (needle); *src;)
1541 *haystack++ = *src++;
1547 /* Compare two target format name strings.
1548 Return a value indicating how "similar" they are. */
1551 name_compare (char *first, char *second)
1557 copy1 = xmalloc (strlen (first) + 1);
1558 copy2 = xmalloc (strlen (second) + 1);
1560 /* Convert the names to lower case. */
1561 stricpy (copy1, first);
1562 stricpy (copy2, second);
1564 /* Remove size and endian strings from the name. */
1565 strcut (copy1, "big");
1566 strcut (copy1, "little");
1567 strcut (copy2, "big");
1568 strcut (copy2, "little");
1570 /* Return a value based on how many characters match,
1571 starting from the beginning. If both strings are
1572 the same then return 10 * their length. */
1573 for (result = 0; copy1[result] == copy2[result]; result++)
1574 if (copy1[result] == 0)
1586 /* Set by closest_target_match() below. */
1587 static const bfd_target *winner;
1589 /* Scan all the valid bfd targets looking for one that has the endianness
1590 requirement that was specified on the command line, and is the nearest
1591 match to the original output target. */
1594 closest_target_match (const bfd_target *target, void *data)
1596 const bfd_target *original = data;
1598 if (command_line.endian == ENDIAN_BIG
1599 && target->byteorder != BFD_ENDIAN_BIG)
1602 if (command_line.endian == ENDIAN_LITTLE
1603 && target->byteorder != BFD_ENDIAN_LITTLE)
1606 /* Must be the same flavour. */
1607 if (target->flavour != original->flavour)
1610 /* If we have not found a potential winner yet, then record this one. */
1617 /* Oh dear, we now have two potential candidates for a successful match.
1618 Compare their names and choose the better one. */
1619 if (name_compare (target->name, original->name)
1620 > name_compare (winner->name, original->name))
1623 /* Keep on searching until wqe have checked them all. */
1627 /* Return the BFD target format of the first input file. */
1630 get_first_input_target (void)
1632 char *target = NULL;
1634 LANG_FOR_EACH_INPUT_STATEMENT (s)
1636 if (s->header.type == lang_input_statement_enum
1639 ldfile_open_file (s);
1641 if (s->the_bfd != NULL
1642 && bfd_check_format (s->the_bfd, bfd_object))
1644 target = bfd_get_target (s->the_bfd);
1656 lang_get_output_target (void)
1660 /* Has the user told us which output format to use? */
1661 if (output_target != NULL)
1662 return output_target;
1664 /* No - has the current target been set to something other than
1666 if (current_target != default_target)
1667 return current_target;
1669 /* No - can we determine the format of the first input file? */
1670 target = get_first_input_target ();
1674 /* Failed - use the default output target. */
1675 return default_target;
1678 /* Open the output file. */
1681 open_output (const char *name)
1685 output_target = lang_get_output_target ();
1687 /* Has the user requested a particular endianness on the command
1689 if (command_line.endian != ENDIAN_UNSET)
1691 const bfd_target *target;
1692 enum bfd_endian desired_endian;
1694 /* Get the chosen target. */
1695 target = bfd_search_for_target (get_target, (void *) output_target);
1697 /* If the target is not supported, we cannot do anything. */
1700 if (command_line.endian == ENDIAN_BIG)
1701 desired_endian = BFD_ENDIAN_BIG;
1703 desired_endian = BFD_ENDIAN_LITTLE;
1705 /* See if the target has the wrong endianness. This should
1706 not happen if the linker script has provided big and
1707 little endian alternatives, but some scrips don't do
1709 if (target->byteorder != desired_endian)
1711 /* If it does, then see if the target provides
1712 an alternative with the correct endianness. */
1713 if (target->alternative_target != NULL
1714 && (target->alternative_target->byteorder == desired_endian))
1715 output_target = target->alternative_target->name;
1718 /* Try to find a target as similar as possible to
1719 the default target, but which has the desired
1720 endian characteristic. */
1721 bfd_search_for_target (closest_target_match,
1724 /* Oh dear - we could not find any targets that
1725 satisfy our requirements. */
1727 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1729 output_target = winner->name;
1735 output = bfd_openw (name, output_target);
1739 if (bfd_get_error () == bfd_error_invalid_target)
1740 einfo (_("%P%F: target %s not found\n"), output_target);
1742 einfo (_("%P%F: cannot open output file %s: %E\n"), name);
1745 delete_output_file_on_failure = TRUE;
1748 output->flags |= D_PAGED;
1751 if (! bfd_set_format (output, bfd_object))
1752 einfo (_("%P%F:%s: can not make object file: %E\n"), name);
1753 if (! bfd_set_arch_mach (output,
1754 ldfile_output_architecture,
1755 ldfile_output_machine))
1756 einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
1758 link_info.hash = bfd_link_hash_table_create (output);
1759 if (link_info.hash == NULL)
1760 einfo (_("%P%F: can not create link hash table: %E\n"));
1762 bfd_set_gp_size (output, g_switch_value);
1767 ldlang_open_output (lang_statement_union_type *statement)
1769 switch (statement->header.type)
1771 case lang_output_statement_enum:
1772 ASSERT (output_bfd == NULL);
1773 output_bfd = open_output (statement->output_statement.name);
1774 ldemul_set_output_arch ();
1775 if (config.magic_demand_paged && !link_info.relocatable)
1776 output_bfd->flags |= D_PAGED;
1778 output_bfd->flags &= ~D_PAGED;
1779 if (config.text_read_only)
1780 output_bfd->flags |= WP_TEXT;
1782 output_bfd->flags &= ~WP_TEXT;
1783 if (link_info.traditional_format)
1784 output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
1786 output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
1789 case lang_target_statement_enum:
1790 current_target = statement->target_statement.target;
1797 /* Open all the input files. */
1800 open_input_bfds (lang_statement_union_type *s, bfd_boolean force)
1802 for (; s != NULL; s = s->header.next)
1804 switch (s->header.type)
1806 case lang_constructors_statement_enum:
1807 open_input_bfds (constructor_list.head, force);
1809 case lang_output_section_statement_enum:
1810 open_input_bfds (s->output_section_statement.children.head, force);
1812 case lang_wild_statement_enum:
1813 /* Maybe we should load the file's symbols. */
1814 if (s->wild_statement.filename
1815 && ! wildcardp (s->wild_statement.filename))
1816 (void) lookup_name (s->wild_statement.filename);
1817 open_input_bfds (s->wild_statement.children.head, force);
1819 case lang_group_statement_enum:
1821 struct bfd_link_hash_entry *undefs;
1823 /* We must continually search the entries in the group
1824 until no new symbols are added to the list of undefined
1829 undefs = link_info.hash->undefs_tail;
1830 open_input_bfds (s->group_statement.children.head, TRUE);
1832 while (undefs != link_info.hash->undefs_tail);
1835 case lang_target_statement_enum:
1836 current_target = s->target_statement.target;
1838 case lang_input_statement_enum:
1839 if (s->input_statement.real)
1841 lang_statement_list_type add;
1843 s->input_statement.target = current_target;
1845 /* If we are being called from within a group, and this
1846 is an archive which has already been searched, then
1847 force it to be researched unless the whole archive
1848 has been loaded already. */
1850 && !s->input_statement.whole_archive
1851 && s->input_statement.loaded
1852 && bfd_check_format (s->input_statement.the_bfd,
1854 s->input_statement.loaded = FALSE;
1856 lang_list_init (&add);
1858 if (! load_symbols (&s->input_statement, &add))
1859 config.make_executable = FALSE;
1861 if (add.head != NULL)
1863 *add.tail = s->header.next;
1864 s->header.next = add.head;
1874 /* If there are [COMMONS] statements, put a wild one into the bss
1878 lang_reasonable_defaults (void)
1881 lang_output_section_statement_lookup (".text");
1882 lang_output_section_statement_lookup (".data");
1884 default_common_section = lang_output_section_statement_lookup (".bss");
1886 if (!placed_commons)
1888 lang_wild_statement_type *new =
1889 new_stat (lang_wild_statement,
1890 &default_common_section->children);
1892 new->section_name = "COMMON";
1893 new->filename = NULL;
1894 lang_list_init (&new->children);
1899 /* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions. */
1902 lang_track_definedness (const char *name)
1904 if (bfd_hash_lookup (&lang_definedness_table, name, TRUE, FALSE) == NULL)
1905 einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name);
1908 /* New-function for the definedness hash table. */
1910 static struct bfd_hash_entry *
1911 lang_definedness_newfunc (struct bfd_hash_entry *entry,
1912 struct bfd_hash_table *table ATTRIBUTE_UNUSED,
1913 const char *name ATTRIBUTE_UNUSED)
1915 struct lang_definedness_hash_entry *ret
1916 = (struct lang_definedness_hash_entry *) entry;
1919 ret = (struct lang_definedness_hash_entry *)
1920 bfd_hash_allocate (table, sizeof (struct lang_definedness_hash_entry));
1923 einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name);
1925 ret->iteration = -1;
1929 /* Return the iteration when the definition of NAME was last updated. A
1930 value of -1 means that the symbol is not defined in the linker script
1931 or the command line, but may be defined in the linker symbol table. */
1934 lang_symbol_definition_iteration (const char *name)
1936 struct lang_definedness_hash_entry *defentry
1937 = (struct lang_definedness_hash_entry *)
1938 bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
1940 /* We've already created this one on the presence of DEFINED in the
1941 script, so it can't be NULL unless something is borked elsewhere in
1943 if (defentry == NULL)
1946 return defentry->iteration;
1949 /* Update the definedness state of NAME. */
1952 lang_update_definedness (const char *name, struct bfd_link_hash_entry *h)
1954 struct lang_definedness_hash_entry *defentry
1955 = (struct lang_definedness_hash_entry *)
1956 bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
1958 /* We don't keep track of symbols not tested with DEFINED. */
1959 if (defentry == NULL)
1962 /* If the symbol was already defined, and not from an earlier statement
1963 iteration, don't update the definedness iteration, because that'd
1964 make the symbol seem defined in the linker script at this point, and
1965 it wasn't; it was defined in some object. If we do anyway, DEFINED
1966 would start to yield false before this point and the construct "sym =
1967 DEFINED (sym) ? sym : X;" would change sym to X despite being defined
1969 if (h->type != bfd_link_hash_undefined
1970 && h->type != bfd_link_hash_common
1971 && h->type != bfd_link_hash_new
1972 && defentry->iteration == -1)
1975 defentry->iteration = lang_statement_iteration;
1978 /* Add the supplied name to the symbol table as an undefined reference.
1979 This is a two step process as the symbol table doesn't even exist at
1980 the time the ld command line is processed. First we put the name
1981 on a list, then, once the output file has been opened, transfer the
1982 name to the symbol table. */
1984 typedef struct bfd_sym_chain ldlang_undef_chain_list_type;
1986 #define ldlang_undef_chain_list_head entry_symbol.next
1989 ldlang_add_undef (const char *const name)
1991 ldlang_undef_chain_list_type *new =
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 = xstrdup (name);
1999 if (output_bfd != NULL)
2000 insert_undefined (new->name);
2003 /* Insert NAME as undefined in the symbol table. */
2006 insert_undefined (const char *name)
2008 struct bfd_link_hash_entry *h;
2010 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, FALSE, TRUE);
2012 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2013 if (h->type == bfd_link_hash_new)
2015 h->type = bfd_link_hash_undefined;
2016 h->u.undef.abfd = NULL;
2017 bfd_link_add_undef (link_info.hash, h);
2021 /* Run through the list of undefineds created above and place them
2022 into the linker hash table as undefined symbols belonging to the
2026 lang_place_undefineds (void)
2028 ldlang_undef_chain_list_type *ptr;
2030 for (ptr = ldlang_undef_chain_list_head; ptr != NULL; ptr = ptr->next)
2031 insert_undefined (ptr->name);
2034 /* Open input files and attach to output sections. */
2037 map_input_to_output_sections
2038 (lang_statement_union_type *s, const char *target,
2039 lang_output_section_statement_type *output_section_statement)
2041 for (; s != NULL; s = s->header.next)
2043 switch (s->header.type)
2045 case lang_wild_statement_enum:
2046 wild (&s->wild_statement, target, output_section_statement);
2048 case lang_constructors_statement_enum:
2049 map_input_to_output_sections (constructor_list.head,
2051 output_section_statement);
2053 case lang_output_section_statement_enum:
2054 map_input_to_output_sections (s->output_section_statement.children.head,
2056 &s->output_section_statement);
2058 case lang_output_statement_enum:
2060 case lang_target_statement_enum:
2061 target = s->target_statement.target;
2063 case lang_group_statement_enum:
2064 map_input_to_output_sections (s->group_statement.children.head,
2066 output_section_statement);
2068 case lang_fill_statement_enum:
2069 case lang_input_section_enum:
2070 case lang_object_symbols_statement_enum:
2071 case lang_data_statement_enum:
2072 case lang_reloc_statement_enum:
2073 case lang_padding_statement_enum:
2074 case lang_input_statement_enum:
2075 if (output_section_statement != NULL
2076 && output_section_statement->bfd_section == NULL)
2077 init_os (output_section_statement);
2079 case lang_assignment_statement_enum:
2080 if (output_section_statement != NULL
2081 && output_section_statement->bfd_section == NULL)
2082 init_os (output_section_statement);
2084 /* Make sure that any sections mentioned in the assignment
2086 exp_init_os (s->assignment_statement.exp);
2088 case lang_afile_asection_pair_statement_enum:
2091 case lang_address_statement_enum:
2092 /* Mark the specified section with the supplied address. */
2094 lang_output_section_statement_type *os =
2095 lang_output_section_statement_lookup
2096 (s->address_statement.section_name);
2098 if (os->bfd_section == NULL)
2100 os->addr_tree = s->address_statement.address;
2107 /* An output section might have been removed after its statement was
2108 added. For example, ldemul_before_allocation can remove dynamic
2109 sections if they turn out to be not needed. Clean them up here. */
2112 strip_excluded_output_sections (void)
2114 lang_statement_union_type *u;
2116 for (u = lang_output_section_statement.head;
2118 u = u->output_section_statement.next)
2120 lang_output_section_statement_type *os;
2123 os = &u->output_section_statement;
2124 s = os->bfd_section;
2125 if (s != NULL && (s->flags & SEC_EXCLUDE) != 0)
2129 os->bfd_section = NULL;
2131 for (p = &output_bfd->sections; *p; p = &(*p)->next)
2134 bfd_section_list_remove (output_bfd, p);
2135 output_bfd->section_count--;
2143 print_output_section_statement
2144 (lang_output_section_statement_type *output_section_statement)
2146 asection *section = output_section_statement->bfd_section;
2149 if (output_section_statement != abs_output_section)
2151 minfo ("\n%s", output_section_statement->name);
2153 if (section != NULL)
2155 print_dot = section->vma;
2157 len = strlen (output_section_statement->name);
2158 if (len >= SECTION_NAME_MAP_LENGTH - 1)
2163 while (len < SECTION_NAME_MAP_LENGTH)
2169 minfo ("0x%V %W", section->vma, section->_raw_size);
2171 if (output_section_statement->load_base != NULL)
2175 addr = exp_get_abs_int (output_section_statement->load_base, 0,
2176 "load base", lang_final_phase_enum);
2177 minfo (_(" load address 0x%V"), addr);
2184 print_statement_list (output_section_statement->children.head,
2185 output_section_statement);
2189 print_assignment (lang_assignment_statement_type *assignment,
2190 lang_output_section_statement_type *output_section)
2193 etree_value_type result;
2195 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2198 result = exp_fold_tree (assignment->exp->assign.src, output_section,
2199 lang_final_phase_enum, print_dot, &print_dot);
2205 value = result.value + result.section->bfd_section->vma;
2206 dst = assignment->exp->assign.dst;
2208 minfo ("0x%V", value);
2209 if (dst[0] == '.' && dst[1] == 0)
2222 exp_print_tree (assignment->exp);
2228 print_input_statement (lang_input_statement_type *statm)
2230 if (statm->filename != NULL)
2232 fprintf (config.map_file, "LOAD %s\n", statm->filename);
2236 /* Print all symbols defined in a particular section. This is called
2237 via bfd_link_hash_traverse. */
2240 print_one_symbol (struct bfd_link_hash_entry *hash_entry, void *ptr)
2242 asection *sec = ptr;
2244 if ((hash_entry->type == bfd_link_hash_defined
2245 || hash_entry->type == bfd_link_hash_defweak)
2246 && sec == hash_entry->u.def.section)
2250 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2253 (hash_entry->u.def.value
2254 + hash_entry->u.def.section->output_offset
2255 + hash_entry->u.def.section->output_section->vma));
2257 minfo (" %T\n", hash_entry->root.string);
2263 /* Print information about an input section to the map file. */
2266 print_input_section (lang_input_section_type *in)
2268 asection *i = in->section;
2269 bfd_size_type size = i->_cooked_size != 0 ? i->_cooked_size : i->_raw_size;
2270 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2271 ldfile_output_machine);
2276 minfo ("%s", i->name);
2278 if (i->output_section != NULL)
2282 len = 1 + strlen (i->name);
2283 if (len >= SECTION_NAME_MAP_LENGTH - 1)
2288 while (len < SECTION_NAME_MAP_LENGTH)
2294 minfo ("0x%V %W %B\n",
2295 i->output_section->vma + i->output_offset, size / opb,
2298 if (i->_cooked_size != 0 && i->_cooked_size != i->_raw_size)
2300 len = SECTION_NAME_MAP_LENGTH + 3;
2312 minfo (_("%W (size before relaxing)\n"), i->_raw_size);
2315 bfd_link_hash_traverse (link_info.hash, print_one_symbol, i);
2317 print_dot = i->output_section->vma + i->output_offset + size / opb;
2323 print_fill_statement (lang_fill_statement_type *fill)
2327 fputs (" FILL mask 0x", config.map_file);
2328 for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--)
2329 fprintf (config.map_file, "%02x", *p);
2330 fputs ("\n", config.map_file);
2334 print_data_statement (lang_data_statement_type *data)
2340 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2341 ldfile_output_machine);
2343 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2346 addr = data->output_vma;
2347 if (data->output_section != NULL)
2348 addr += data->output_section->vma;
2376 minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
2378 if (data->exp->type.node_class != etree_value)
2381 exp_print_tree (data->exp);
2386 print_dot = addr + size / opb;
2390 /* Print an address statement. These are generated by options like
2394 print_address_statement (lang_address_statement_type *address)
2396 minfo (_("Address of section %s set to "), address->section_name);
2397 exp_print_tree (address->address);
2401 /* Print a reloc statement. */
2404 print_reloc_statement (lang_reloc_statement_type *reloc)
2409 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2410 ldfile_output_machine);
2412 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2415 addr = reloc->output_vma;
2416 if (reloc->output_section != NULL)
2417 addr += reloc->output_section->vma;
2419 size = bfd_get_reloc_size (reloc->howto);
2421 minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
2423 if (reloc->name != NULL)
2424 minfo ("%s+", reloc->name);
2426 minfo ("%s+", reloc->section->name);
2428 exp_print_tree (reloc->addend_exp);
2432 print_dot = addr + size / opb;
2436 print_padding_statement (lang_padding_statement_type *s)
2440 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2441 ldfile_output_machine);
2445 len = sizeof " *fill*" - 1;
2446 while (len < SECTION_NAME_MAP_LENGTH)
2452 addr = s->output_offset;
2453 if (s->output_section != NULL)
2454 addr += s->output_section->vma;
2455 minfo ("0x%V %W ", addr, s->size);
2457 if (s->fill->size != 0)
2461 for (p = s->fill->data, size = s->fill->size; size != 0; p++, size--)
2462 fprintf (config.map_file, "%02x", *p);
2467 print_dot = addr + s->size / opb;
2471 print_wild_statement (lang_wild_statement_type *w,
2472 lang_output_section_statement_type *os)
2474 struct wildcard_list *sec;
2478 if (w->filenames_sorted)
2480 if (w->filename != NULL)
2481 minfo ("%s", w->filename);
2484 if (w->filenames_sorted)
2488 for (sec = w->section_list; sec; sec = sec->next)
2490 if (sec->spec.sorted)
2492 if (sec->spec.exclude_name_list != NULL)
2495 minfo ("EXCLUDE_FILE(%s", sec->spec.exclude_name_list->name);
2496 for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next)
2497 minfo (" %s", tmp->name);
2500 if (sec->spec.name != NULL)
2501 minfo ("%s", sec->spec.name);
2504 if (sec->spec.sorted)
2513 print_statement_list (w->children.head, os);
2516 /* Print a group statement. */
2519 print_group (lang_group_statement_type *s,
2520 lang_output_section_statement_type *os)
2522 fprintf (config.map_file, "START GROUP\n");
2523 print_statement_list (s->children.head, os);
2524 fprintf (config.map_file, "END GROUP\n");
2527 /* Print the list of statements in S.
2528 This can be called for any statement type. */
2531 print_statement_list (lang_statement_union_type *s,
2532 lang_output_section_statement_type *os)
2536 print_statement (s, os);
2541 /* Print the first statement in statement list S.
2542 This can be called for any statement type. */
2545 print_statement (lang_statement_union_type *s,
2546 lang_output_section_statement_type *os)
2548 switch (s->header.type)
2551 fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
2554 case lang_constructors_statement_enum:
2555 if (constructor_list.head != NULL)
2557 if (constructors_sorted)
2558 minfo (" SORT (CONSTRUCTORS)\n");
2560 minfo (" CONSTRUCTORS\n");
2561 print_statement_list (constructor_list.head, os);
2564 case lang_wild_statement_enum:
2565 print_wild_statement (&s->wild_statement, os);
2567 case lang_address_statement_enum:
2568 print_address_statement (&s->address_statement);
2570 case lang_object_symbols_statement_enum:
2571 minfo (" CREATE_OBJECT_SYMBOLS\n");
2573 case lang_fill_statement_enum:
2574 print_fill_statement (&s->fill_statement);
2576 case lang_data_statement_enum:
2577 print_data_statement (&s->data_statement);
2579 case lang_reloc_statement_enum:
2580 print_reloc_statement (&s->reloc_statement);
2582 case lang_input_section_enum:
2583 print_input_section (&s->input_section);
2585 case lang_padding_statement_enum:
2586 print_padding_statement (&s->padding_statement);
2588 case lang_output_section_statement_enum:
2589 print_output_section_statement (&s->output_section_statement);
2591 case lang_assignment_statement_enum:
2592 print_assignment (&s->assignment_statement, os);
2594 case lang_target_statement_enum:
2595 fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
2597 case lang_output_statement_enum:
2598 minfo ("OUTPUT(%s", s->output_statement.name);
2599 if (output_target != NULL)
2600 minfo (" %s", output_target);
2603 case lang_input_statement_enum:
2604 print_input_statement (&s->input_statement);
2606 case lang_group_statement_enum:
2607 print_group (&s->group_statement, os);
2609 case lang_afile_asection_pair_statement_enum:
2616 print_statements (void)
2618 print_statement_list (statement_list.head, abs_output_section);
2621 /* Print the first N statements in statement list S to STDERR.
2622 If N == 0, nothing is printed.
2623 If N < 0, the entire list is printed.
2624 Intended to be called from GDB. */
2627 dprint_statement (lang_statement_union_type *s, int n)
2629 FILE *map_save = config.map_file;
2631 config.map_file = stderr;
2634 print_statement_list (s, abs_output_section);
2637 while (s && --n >= 0)
2639 print_statement (s, abs_output_section);
2644 config.map_file = map_save;
2648 insert_pad (lang_statement_union_type **ptr,
2650 unsigned int alignment_needed,
2651 asection *output_section,
2654 static fill_type zero_fill = { 1, { 0 } };
2655 lang_statement_union_type *pad;
2657 pad = ((lang_statement_union_type *)
2658 ((char *) ptr - offsetof (lang_statement_union_type, header.next)));
2659 if (ptr != &statement_list.head
2660 && pad->header.type == lang_padding_statement_enum
2661 && pad->padding_statement.output_section == output_section)
2663 /* Use the existing pad statement. The above test on output
2664 section is probably redundant, but it doesn't hurt to check. */
2668 /* Make a new padding statement, linked into existing chain. */
2669 pad = stat_alloc (sizeof (lang_padding_statement_type));
2670 pad->header.next = *ptr;
2672 pad->header.type = lang_padding_statement_enum;
2673 pad->padding_statement.output_section = output_section;
2676 pad->padding_statement.fill = fill;
2678 pad->padding_statement.output_offset = dot - output_section->vma;
2679 pad->padding_statement.size = alignment_needed;
2680 output_section->_raw_size += alignment_needed;
2683 /* Work out how much this section will move the dot point. */
2686 size_input_section (lang_statement_union_type **this_ptr,
2687 lang_output_section_statement_type *output_section_statement,
2691 lang_input_section_type *is = &((*this_ptr)->input_section);
2692 asection *i = is->section;
2694 if (!is->ifile->just_syms_flag)
2696 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2697 ldfile_output_machine);
2698 unsigned int alignment_needed;
2701 /* Align this section first to the input sections requirement,
2702 then to the output section's requirement. If this alignment
2703 is greater than any seen before, then record it too. Perform
2704 the alignment by inserting a magic 'padding' statement. */
2706 if (output_section_statement->subsection_alignment != -1)
2707 i->alignment_power = output_section_statement->subsection_alignment;
2709 o = output_section_statement->bfd_section;
2710 if (o->alignment_power < i->alignment_power)
2711 o->alignment_power = i->alignment_power;
2713 alignment_needed = align_power (dot, i->alignment_power) - dot;
2715 if (alignment_needed != 0)
2717 insert_pad (this_ptr, fill, alignment_needed * opb, o, dot);
2718 dot += alignment_needed;
2721 /* Remember where in the output section this input section goes. */
2723 i->output_offset = dot - o->vma;
2725 /* Mark how big the output section must be to contain this now. */
2726 if (i->_cooked_size != 0)
2727 dot += i->_cooked_size / opb;
2729 dot += i->_raw_size / opb;
2730 o->_raw_size = (dot - o->vma) * opb;
2734 i->output_offset = i->vma - output_section_statement->bfd_section->vma;
2740 #define IGNORE_SECTION(bfd, s) \
2741 (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD)) \
2742 != (SEC_ALLOC | SEC_LOAD)) \
2743 || bfd_section_size (bfd, s) == 0)
2745 /* Check to see if any allocated sections overlap with other allocated
2746 sections. This can happen when the linker script specifically specifies
2747 the output section addresses of the two sections. */
2750 lang_check_section_addresses (void)
2753 unsigned opb = bfd_octets_per_byte (output_bfd);
2755 /* Scan all sections in the output list. */
2756 for (s = output_bfd->sections; s != NULL; s = s->next)
2760 /* Ignore sections which are not loaded or which have no contents. */
2761 if (IGNORE_SECTION (output_bfd, s))
2764 /* Once we reach section 's' stop our seach. This prevents two
2765 warning messages from being produced, one for 'section A overlaps
2766 section B' and one for 'section B overlaps section A'. */
2767 for (os = output_bfd->sections; os != s; os = os->next)
2774 /* Only consider loadable sections with real contents. */
2775 if (IGNORE_SECTION (output_bfd, os))
2778 /* We must check the sections' LMA addresses not their
2779 VMA addresses because overlay sections can have
2780 overlapping VMAs but they must have distinct LMAs. */
2781 s_start = bfd_section_lma (output_bfd, s);
2782 os_start = bfd_section_lma (output_bfd, os);
2783 s_end = s_start + bfd_section_size (output_bfd, s) / opb - 1;
2784 os_end = os_start + bfd_section_size (output_bfd, os) / opb - 1;
2786 /* Look for an overlap. */
2787 if ((s_end < os_start) || (s_start > os_end))
2791 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2792 s->name, s_start, s_end, os->name, os_start, os_end);
2794 /* Once we have found one overlap for this section,
2795 stop looking for others. */
2801 /* Make sure the new address is within the region. We explicitly permit the
2802 current address to be at the exact end of the region when the address is
2803 non-zero, in case the region is at the end of addressable memory and the
2804 calculation wraps around. */
2807 os_region_check (lang_output_section_statement_type *os,
2808 struct memory_region_struct *region,
2812 if ((region->current < region->origin
2813 || (region->current - region->origin > region->length))
2814 && ((region->current != region->origin + region->length)
2819 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2821 os->bfd_section->owner,
2822 os->bfd_section->name,
2827 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2829 os->bfd_section->owner,
2830 os->bfd_section->name);
2832 /* Reset the region pointer. */
2833 region->current = region->origin;
2837 /* Set the sizes for all the output sections. */
2840 lang_size_sections_1
2841 (lang_statement_union_type *s,
2842 lang_output_section_statement_type *output_section_statement,
2843 lang_statement_union_type **prev,
2847 bfd_boolean check_regions)
2849 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2850 ldfile_output_machine);
2852 /* Size up the sections from their constituent parts. */
2853 for (; s != NULL; s = s->header.next)
2855 switch (s->header.type)
2857 case lang_output_section_statement_enum:
2860 lang_output_section_statement_type *os;
2862 os = &s->output_section_statement;
2863 if (os->bfd_section == NULL)
2864 /* This section was never actually created. */
2867 /* If this is a COFF shared library section, use the size and
2868 address from the input section. FIXME: This is COFF
2869 specific; it would be cleaner if there were some other way
2870 to do this, but nothing simple comes to mind. */
2871 if ((os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
2875 if (os->children.head == NULL
2876 || os->children.head->header.next != NULL
2877 || os->children.head->header.type != lang_input_section_enum)
2878 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2881 input = os->children.head->input_section.section;
2882 bfd_set_section_vma (os->bfd_section->owner,
2884 bfd_section_vma (input->owner, input));
2885 os->bfd_section->_raw_size = input->_raw_size;
2889 if (bfd_is_abs_section (os->bfd_section))
2891 /* No matter what happens, an abs section starts at zero. */
2892 ASSERT (os->bfd_section->vma == 0);
2896 if (os->addr_tree == NULL)
2898 /* No address specified for this section, get one
2899 from the region specification. */
2900 if (os->region == NULL
2901 || (((bfd_get_section_flags (output_bfd, os->bfd_section)
2902 & (SEC_ALLOC | SEC_LOAD)) != 0)
2903 && os->region->name[0] == '*'
2904 && strcmp (os->region->name, DEFAULT_MEMORY_REGION) == 0))
2906 os->region = lang_memory_default (os->bfd_section);
2909 /* If a loadable section is using the default memory
2910 region, and some non default memory regions were
2911 defined, issue an error message. */
2912 if (!IGNORE_SECTION (output_bfd, os->bfd_section)
2913 && (bfd_get_section_flags (output_bfd, os->bfd_section)
2914 & SEC_NEVER_LOAD) == 0
2915 && ! link_info.relocatable
2917 && strcmp (os->region->name, DEFAULT_MEMORY_REGION) == 0
2918 && lang_memory_region_list != NULL
2919 && (strcmp (lang_memory_region_list->name,
2920 DEFAULT_MEMORY_REGION) != 0
2921 || lang_memory_region_list->next != NULL))
2923 /* By default this is an error rather than just a
2924 warning because if we allocate the section to the
2925 default memory region we can end up creating an
2926 excessivly large binary, or even seg faulting when
2927 attmepting to perform a negative seek. See
2928 http://sources.redhat.com/ml/binutils/2003-04/msg00423.html
2929 for an example of this. This behaviour can be
2930 overridden by the using the --no-check-sections
2932 if (command_line.check_section_addresses)
2933 einfo (_("%P%F: error: no memory region specified for loadable section `%s'\n"),
2934 bfd_get_section_name (output_bfd,
2937 einfo (_("%P: warning: no memory region specified for loadable section `%s'\n"),
2938 bfd_get_section_name (output_bfd,
2942 dot = os->region->current;
2944 if (os->section_alignment == -1)
2949 dot = align_power (dot,
2950 os->bfd_section->alignment_power);
2952 if (dot != olddot && config.warn_section_align)
2953 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2954 os->name, (unsigned int) (dot - olddot));
2961 r = exp_fold_tree (os->addr_tree,
2963 lang_allocating_phase_enum,
2966 einfo (_("%F%S: non constant address expression for section %s\n"),
2969 dot = r.value + r.section->bfd_section->vma;
2972 /* The section starts here.
2973 First, align to what the section needs. */
2975 if (os->section_alignment != -1)
2976 dot = align_power (dot, os->section_alignment);
2978 bfd_set_section_vma (0, os->bfd_section, dot);
2980 os->bfd_section->output_offset = 0;
2983 lang_size_sections_1 (os->children.head, os, &os->children.head,
2984 os->fill, dot, relax, check_regions);
2986 /* Put the section within the requested block size, or
2987 align at the block boundary. */
2988 after = align_n (os->bfd_section->vma
2989 + os->bfd_section->_raw_size / opb,
2990 (bfd_vma) os->block_value);
2992 if (bfd_is_abs_section (os->bfd_section))
2993 ASSERT (after == os->bfd_section->vma);
2994 else if ((os->bfd_section->flags & SEC_HAS_CONTENTS) == 0
2995 && (os->bfd_section->flags & SEC_THREAD_LOCAL)
2996 && ! link_info.relocatable)
2997 os->bfd_section->_raw_size = 0;
2999 os->bfd_section->_raw_size =
3000 (after - os->bfd_section->vma) * opb;
3002 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
3003 os->processed = TRUE;
3005 if (os->update_dot_tree != 0)
3006 exp_fold_tree (os->update_dot_tree, abs_output_section,
3007 lang_allocating_phase_enum, dot, &dot);
3009 /* Update dot in the region ?
3010 We only do this if the section is going to be allocated,
3011 since unallocated sections do not contribute to the region's
3012 overall size in memory.
3014 If the SEC_NEVER_LOAD bit is not set, it will affect the
3015 addresses of sections after it. We have to update
3017 if (os->region != NULL
3018 && ((bfd_get_section_flags (output_bfd, os->bfd_section)
3019 & SEC_NEVER_LOAD) == 0
3020 || (bfd_get_section_flags (output_bfd, os->bfd_section)
3021 & (SEC_ALLOC | SEC_LOAD))))
3023 os->region->current = dot;
3026 /* Make sure the new address is within the region. */
3027 os_region_check (os, os->region, os->addr_tree,
3028 os->bfd_section->vma);
3030 /* If there's no load address specified, use the run
3031 region as the load region. */
3032 if (os->lma_region == NULL && os->load_base == NULL)
3033 os->lma_region = os->region;
3035 if (os->lma_region != NULL && os->lma_region != os->region)
3037 /* Set load_base, which will be handled later. */
3038 os->load_base = exp_intop (os->lma_region->current);
3039 os->lma_region->current +=
3040 os->bfd_section->_raw_size / opb;
3042 os_region_check (os, os->lma_region, NULL,
3043 os->bfd_section->lma);
3049 case lang_constructors_statement_enum:
3050 dot = lang_size_sections_1 (constructor_list.head,
3051 output_section_statement,
3052 &s->wild_statement.children.head,
3053 fill, dot, relax, check_regions);
3056 case lang_data_statement_enum:
3058 unsigned int size = 0;
3060 s->data_statement.output_vma =
3061 dot - output_section_statement->bfd_section->vma;
3062 s->data_statement.output_section =
3063 output_section_statement->bfd_section;
3065 switch (s->data_statement.type)
3086 output_section_statement->bfd_section->_raw_size += size;
3087 /* The output section gets contents, and then we inspect for
3088 any flags set in the input script which override any ALLOC. */
3089 output_section_statement->bfd_section->flags |= SEC_HAS_CONTENTS;
3090 if (!(output_section_statement->flags & SEC_NEVER_LOAD))
3092 output_section_statement->bfd_section->flags |=
3093 SEC_ALLOC | SEC_LOAD;
3098 case lang_reloc_statement_enum:
3102 s->reloc_statement.output_vma =
3103 dot - output_section_statement->bfd_section->vma;
3104 s->reloc_statement.output_section =
3105 output_section_statement->bfd_section;
3106 size = bfd_get_reloc_size (s->reloc_statement.howto);
3108 output_section_statement->bfd_section->_raw_size += size;
3112 case lang_wild_statement_enum:
3114 dot = lang_size_sections_1 (s->wild_statement.children.head,
3115 output_section_statement,
3116 &s->wild_statement.children.head,
3117 fill, dot, relax, check_regions);
3121 case lang_object_symbols_statement_enum:
3122 link_info.create_object_symbols_section =
3123 output_section_statement->bfd_section;
3125 case lang_output_statement_enum:
3126 case lang_target_statement_enum:
3128 case lang_input_section_enum:
3132 i = (*prev)->input_section.section;
3135 if (i->_cooked_size == 0)
3136 i->_cooked_size = i->_raw_size;
3142 if (! bfd_relax_section (i->owner, i, &link_info, &again))
3143 einfo (_("%P%F: can't relax section: %E\n"));
3147 dot = size_input_section (prev, output_section_statement,
3148 output_section_statement->fill, dot);
3151 case lang_input_statement_enum:
3153 case lang_fill_statement_enum:
3154 s->fill_statement.output_section =
3155 output_section_statement->bfd_section;
3157 fill = s->fill_statement.fill;
3159 case lang_assignment_statement_enum:
3161 bfd_vma newdot = dot;
3163 exp_fold_tree (s->assignment_statement.exp,
3164 output_section_statement,
3165 lang_allocating_phase_enum,
3171 if (output_section_statement == abs_output_section)
3173 /* If we don't have an output section, then just adjust
3174 the default memory address. */
3175 lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE)->current = newdot;
3179 /* Insert a pad after this statement. We can't
3180 put the pad before when relaxing, in case the
3181 assignment references dot. */
3182 insert_pad (&s->header.next, fill, (newdot - dot) * opb,
3183 output_section_statement->bfd_section, dot);
3185 /* Don't neuter the pad below when relaxing. */
3194 case lang_padding_statement_enum:
3195 /* If this is the first time lang_size_sections is called,
3196 we won't have any padding statements. If this is the
3197 second or later passes when relaxing, we should allow
3198 padding to shrink. If padding is needed on this pass, it
3199 will be added back in. */
3200 s->padding_statement.size = 0;
3202 /* Make sure output_offset is valid. If relaxation shrinks
3203 the section and this pad isn't needed, it's possible to
3204 have output_offset larger than the final size of the
3205 section. bfd_set_section_contents will complain even for
3206 a pad size of zero. */
3207 s->padding_statement.output_offset
3208 = dot - output_section_statement->bfd_section->vma;
3211 case lang_group_statement_enum:
3212 dot = lang_size_sections_1 (s->group_statement.children.head,
3213 output_section_statement,
3214 &s->group_statement.children.head,
3215 fill, dot, relax, check_regions);
3222 /* We can only get here when relaxing is turned on. */
3223 case lang_address_statement_enum:
3226 prev = &s->header.next;
3233 (lang_statement_union_type *s,
3234 lang_output_section_statement_type *output_section_statement,
3235 lang_statement_union_type **prev,
3239 bfd_boolean check_regions)
3244 /* Callers of exp_fold_tree need to increment this. */
3245 lang_statement_iteration++;
3247 exp_data_seg.phase = exp_dataseg_none;
3248 result = lang_size_sections_1 (s, output_section_statement, prev, fill,
3249 dot, relax, check_regions);
3250 if (exp_data_seg.phase == exp_dataseg_end_seen)
3252 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
3253 a page could be saved in the data segment. */
3254 bfd_vma first, last;
3256 first = -exp_data_seg.base & (exp_data_seg.pagesize - 1);
3257 last = exp_data_seg.end & (exp_data_seg.pagesize - 1);
3259 && ((exp_data_seg.base & ~(exp_data_seg.pagesize - 1))
3260 != (exp_data_seg.end & ~(exp_data_seg.pagesize - 1)))
3261 && first + last <= exp_data_seg.pagesize)
3263 exp_data_seg.phase = exp_dataseg_adjust;
3264 result = lang_size_sections_1 (s, output_section_statement, prev,
3265 fill, dot, relax, check_regions);
3269 /* Some backend relaxers want to refer to the output section size. Give
3270 them a section size that does not change on the next call while they
3271 relax. We can't set this at top because lang_reset_memory_regions
3272 which is called before we get here, sets _raw_size to 0 on relaxing
3274 for (o = output_bfd->sections; o != NULL; o = o->next)
3275 o->_cooked_size = o->_raw_size;
3280 /* Worker function for lang_do_assignments. Recursiveness goes here. */
3283 lang_do_assignments_1
3284 (lang_statement_union_type *s,
3285 lang_output_section_statement_type *output_section_statement,
3289 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3290 ldfile_output_machine);
3292 for (; s != NULL; s = s->header.next)
3294 switch (s->header.type)
3296 case lang_constructors_statement_enum:
3297 dot = lang_do_assignments_1 (constructor_list.head,
3298 output_section_statement,
3303 case lang_output_section_statement_enum:
3305 lang_output_section_statement_type *os;
3307 os = &(s->output_section_statement);
3308 if (os->bfd_section != NULL)
3310 dot = os->bfd_section->vma;
3311 (void) lang_do_assignments_1 (os->children.head, os,
3313 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
3318 /* If nothing has been placed into the output section then
3319 it won't have a bfd_section. */
3320 if (os->bfd_section)
3322 os->bfd_section->lma
3323 = exp_get_abs_int (os->load_base, 0, "load base",
3324 lang_final_phase_enum);
3329 case lang_wild_statement_enum:
3331 dot = lang_do_assignments_1 (s->wild_statement.children.head,
3332 output_section_statement,
3337 case lang_object_symbols_statement_enum:
3338 case lang_output_statement_enum:
3339 case lang_target_statement_enum:
3341 case lang_common_statement_enum:
3344 case lang_data_statement_enum:
3346 etree_value_type value;
3348 value = exp_fold_tree (s->data_statement.exp,
3350 lang_final_phase_enum, dot, &dot);
3351 s->data_statement.value = value.value;
3353 einfo (_("%F%P: invalid data statement\n"));
3357 switch (s->data_statement.type)
3381 case lang_reloc_statement_enum:
3383 etree_value_type value;
3385 value = exp_fold_tree (s->reloc_statement.addend_exp,
3387 lang_final_phase_enum, dot, &dot);
3388 s->reloc_statement.addend_value = value.value;
3390 einfo (_("%F%P: invalid reloc statement\n"));
3392 dot += bfd_get_reloc_size (s->reloc_statement.howto) / opb;
3395 case lang_input_section_enum:
3397 asection *in = s->input_section.section;
3399 if (in->_cooked_size != 0)
3400 dot += in->_cooked_size / opb;
3402 dot += in->_raw_size / opb;
3406 case lang_input_statement_enum:
3408 case lang_fill_statement_enum:
3409 fill = s->fill_statement.fill;
3411 case lang_assignment_statement_enum:
3413 exp_fold_tree (s->assignment_statement.exp,
3414 output_section_statement,
3415 lang_final_phase_enum,
3421 case lang_padding_statement_enum:
3422 dot += s->padding_statement.size / opb;
3425 case lang_group_statement_enum:
3426 dot = lang_do_assignments_1 (s->group_statement.children.head,
3427 output_section_statement,
3435 case lang_address_statement_enum:
3444 lang_do_assignments (lang_statement_union_type *s,
3445 lang_output_section_statement_type
3446 *output_section_statement,
3450 /* Callers of exp_fold_tree need to increment this. */
3451 lang_statement_iteration++;
3452 lang_do_assignments_1 (s, output_section_statement, fill, dot);
3455 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3456 operator .startof. (section_name), it produces an undefined symbol
3457 .startof.section_name. Similarly, when it sees
3458 .sizeof. (section_name), it produces an undefined symbol
3459 .sizeof.section_name. For all the output sections, we look for
3460 such symbols, and set them to the correct value. */
3463 lang_set_startof (void)
3467 if (link_info.relocatable)
3470 for (s = output_bfd->sections; s != NULL; s = s->next)
3472 const char *secname;
3474 struct bfd_link_hash_entry *h;
3476 secname = bfd_get_section_name (output_bfd, s);
3477 buf = xmalloc (10 + strlen (secname));
3479 sprintf (buf, ".startof.%s", secname);
3480 h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
3481 if (h != NULL && h->type == bfd_link_hash_undefined)
3483 h->type = bfd_link_hash_defined;
3484 h->u.def.value = bfd_get_section_vma (output_bfd, s);
3485 h->u.def.section = bfd_abs_section_ptr;
3488 sprintf (buf, ".sizeof.%s", secname);
3489 h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
3490 if (h != NULL && h->type == bfd_link_hash_undefined)
3494 opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3495 ldfile_output_machine);
3496 h->type = bfd_link_hash_defined;
3497 if (s->_cooked_size != 0)
3498 h->u.def.value = s->_cooked_size / opb;
3500 h->u.def.value = s->_raw_size / opb;
3501 h->u.def.section = bfd_abs_section_ptr;
3511 struct bfd_link_hash_entry *h;
3514 if (link_info.relocatable || link_info.shared)
3519 if (entry_symbol.name == NULL)
3521 /* No entry has been specified. Look for start, but don't warn
3522 if we don't find it. */
3523 entry_symbol.name = "start";
3527 h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
3528 FALSE, FALSE, TRUE);
3530 && (h->type == bfd_link_hash_defined
3531 || h->type == bfd_link_hash_defweak)
3532 && h->u.def.section->output_section != NULL)
3536 val = (h->u.def.value
3537 + bfd_get_section_vma (output_bfd,
3538 h->u.def.section->output_section)
3539 + h->u.def.section->output_offset);
3540 if (! bfd_set_start_address (output_bfd, val))
3541 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol.name);
3548 /* We couldn't find the entry symbol. Try parsing it as a
3550 val = bfd_scan_vma (entry_symbol.name, &send, 0);
3553 if (! bfd_set_start_address (output_bfd, val))
3554 einfo (_("%P%F: can't set start address\n"));
3560 /* Can't find the entry symbol, and it's not a number. Use
3561 the first address in the text section. */
3562 ts = bfd_get_section_by_name (output_bfd, entry_section);
3566 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3568 bfd_get_section_vma (output_bfd, ts));
3569 if (! bfd_set_start_address (output_bfd,
3570 bfd_get_section_vma (output_bfd,
3572 einfo (_("%P%F: can't set start address\n"));
3577 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3583 bfd_hash_table_free (&lang_definedness_table);
3586 /* This is a small function used when we want to ignore errors from
3590 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
3592 /* Don't do anything. */
3595 /* Check that the architecture of all the input files is compatible
3596 with the output file. Also call the backend to let it do any
3597 other checking that is needed. */
3602 lang_statement_union_type *file;
3604 const bfd_arch_info_type *compatible;
3606 for (file = file_chain.head; file != NULL; file = file->input_statement.next)
3608 input_bfd = file->input_statement.the_bfd;
3609 compatible = bfd_arch_get_compatible (input_bfd, output_bfd,
3610 command_line.accept_unknown_input_arch);
3612 /* In general it is not possible to perform a relocatable
3613 link between differing object formats when the input
3614 file has relocations, because the relocations in the
3615 input format may not have equivalent representations in
3616 the output format (and besides BFD does not translate
3617 relocs for other link purposes than a final link). */
3618 if ((link_info.relocatable || link_info.emitrelocations)
3619 && (compatible == NULL
3620 || bfd_get_flavour (input_bfd) != bfd_get_flavour (output_bfd))
3621 && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
3623 einfo (_("%P%F: Relocatable linking with relocations from format %s (%B) to format %s (%B) is not supported\n"),
3624 bfd_get_target (input_bfd), input_bfd,
3625 bfd_get_target (output_bfd), output_bfd);
3626 /* einfo with %F exits. */
3629 if (compatible == NULL)
3631 if (command_line.warn_mismatch)
3632 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3633 bfd_printable_name (input_bfd), input_bfd,
3634 bfd_printable_name (output_bfd));
3636 else if (bfd_count_sections (input_bfd))
3638 /* If the input bfd has no contents, it shouldn't set the
3639 private data of the output bfd. */
3641 bfd_error_handler_type pfn = NULL;
3643 /* If we aren't supposed to warn about mismatched input
3644 files, temporarily set the BFD error handler to a
3645 function which will do nothing. We still want to call
3646 bfd_merge_private_bfd_data, since it may set up
3647 information which is needed in the output file. */
3648 if (! command_line.warn_mismatch)
3649 pfn = bfd_set_error_handler (ignore_bfd_errors);
3650 if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
3652 if (command_line.warn_mismatch)
3653 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3656 if (! command_line.warn_mismatch)
3657 bfd_set_error_handler (pfn);
3662 /* Look through all the global common symbols and attach them to the
3663 correct section. The -sort-common command line switch may be used
3664 to roughly sort the entries by size. */
3669 if (command_line.inhibit_common_definition)
3671 if (link_info.relocatable
3672 && ! command_line.force_common_definition)
3675 if (! config.sort_common)
3676 bfd_link_hash_traverse (link_info.hash, lang_one_common, NULL);
3681 for (power = 4; power >= 0; power--)
3682 bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
3686 /* Place one common symbol in the correct section. */
3689 lang_one_common (struct bfd_link_hash_entry *h, void *info)
3691 unsigned int power_of_two;
3694 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3695 ldfile_output_machine);
3697 if (h->type != bfd_link_hash_common)
3701 power_of_two = h->u.c.p->alignment_power;
3703 if (config.sort_common
3704 && power_of_two < (unsigned int) *(int *) info)
3707 section = h->u.c.p->section;
3709 /* Increase the size of the section. */
3710 section->_cooked_size = align_n ((section->_cooked_size + opb - 1) / opb,
3711 (bfd_vma) 1 << power_of_two) * opb;
3713 /* Adjust the alignment if necessary. */
3714 if (power_of_two > section->alignment_power)
3715 section->alignment_power = power_of_two;
3717 /* Change the symbol from common to defined. */
3718 h->type = bfd_link_hash_defined;
3719 h->u.def.section = section;
3720 h->u.def.value = section->_cooked_size;
3722 /* Increase the size of the section. */
3723 section->_cooked_size += size;
3725 /* Make sure the section is allocated in memory, and make sure that
3726 it is no longer a common section. */
3727 section->flags |= SEC_ALLOC;
3728 section->flags &= ~SEC_IS_COMMON;
3730 if (config.map_file != NULL)
3732 static bfd_boolean header_printed;
3737 if (! header_printed)
3739 minfo (_("\nAllocating common symbols\n"));
3740 minfo (_("Common symbol size file\n\n"));
3741 header_printed = TRUE;
3744 name = demangle (h->root.string);
3746 len = strlen (name);
3761 if (size <= 0xffffffff)
3762 sprintf (buf, "%lx", (unsigned long) size);
3764 sprintf_vma (buf, size);
3774 minfo ("%B\n", section->owner);
3780 /* Run through the input files and ensure that every input section has
3781 somewhere to go. If one is found without a destination then create
3782 an input request and place it into the statement tree. */
3785 lang_place_orphans (void)
3787 LANG_FOR_EACH_INPUT_STATEMENT (file)
3791 for (s = file->the_bfd->sections; s != NULL; s = s->next)
3793 if (s->output_section == NULL)
3795 /* This section of the file is not attached, root
3796 around for a sensible place for it to go. */
3798 if (file->just_syms_flag)
3802 else if (strcmp (s->name, "COMMON") == 0)
3804 /* This is a lonely common section which must have
3805 come from an archive. We attach to the section
3806 with the wildcard. */
3807 if (! link_info.relocatable
3808 || command_line.force_common_definition)
3810 if (default_common_section == NULL)
3813 /* This message happens when using the
3814 svr3.ifile linker script, so I have
3816 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3818 default_common_section =
3819 lang_output_section_statement_lookup (".bss");
3822 lang_add_section (&default_common_section->children, s,
3823 default_common_section, file);
3826 else if (ldemul_place_orphan (file, s))
3830 lang_output_section_statement_type *os;
3832 os = lang_output_section_statement_lookup (s->name);
3833 lang_add_section (&os->children, s, os, file);
3841 lang_set_flags (lang_memory_region_type *ptr, const char *flags, int invert)
3843 flagword *ptr_flags;
3845 ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
3851 *ptr_flags |= SEC_ALLOC;
3855 *ptr_flags |= SEC_READONLY;
3859 *ptr_flags |= SEC_DATA;
3863 *ptr_flags |= SEC_CODE;
3868 *ptr_flags |= SEC_LOAD;
3872 einfo (_("%P%F: invalid syntax in flags\n"));
3879 /* Call a function on each input file. This function will be called
3880 on an archive, but not on the elements. */
3883 lang_for_each_input_file (void (*func) (lang_input_statement_type *))
3885 lang_input_statement_type *f;
3887 for (f = (lang_input_statement_type *) input_file_chain.head;
3889 f = (lang_input_statement_type *) f->next_real_file)
3893 /* Call a function on each file. The function will be called on all
3894 the elements of an archive which are included in the link, but will
3895 not be called on the archive file itself. */
3898 lang_for_each_file (void (*func) (lang_input_statement_type *))
3900 LANG_FOR_EACH_INPUT_STATEMENT (f)
3911 lang_for_each_input_section (void (*func) (bfd *ab, asection *as))
3913 LANG_FOR_EACH_INPUT_STATEMENT (f)
3917 for (s = f->the_bfd->sections; s != NULL; s = s->next)
3918 func (f->the_bfd, s);
3925 ldlang_add_file (lang_input_statement_type *entry)
3929 lang_statement_append (&file_chain,
3930 (lang_statement_union_type *) entry,
3933 /* The BFD linker needs to have a list of all input BFDs involved in
3935 ASSERT (entry->the_bfd->link_next == NULL);
3936 ASSERT (entry->the_bfd != output_bfd);
3937 for (pp = &link_info.input_bfds; *pp != NULL; pp = &(*pp)->link_next)
3939 *pp = entry->the_bfd;
3940 entry->the_bfd->usrdata = entry;
3941 bfd_set_gp_size (entry->the_bfd, g_switch_value);
3943 /* Look through the sections and check for any which should not be
3944 included in the link. We need to do this now, so that we can
3945 notice when the backend linker tries to report multiple
3946 definition errors for symbols which are in sections we aren't
3947 going to link. FIXME: It might be better to entirely ignore
3948 symbols which are defined in sections which are going to be
3949 discarded. This would require modifying the backend linker for
3950 each backend which might set the SEC_LINK_ONCE flag. If we do
3951 this, we should probably handle SEC_EXCLUDE in the same way. */
3953 bfd_map_over_sections (entry->the_bfd, section_already_linked, entry);
3957 lang_add_output (const char *name, int from_script)
3959 /* Make -o on command line override OUTPUT in script. */
3960 if (!had_output_filename || !from_script)
3962 output_filename = name;
3963 had_output_filename = TRUE;
3967 static lang_output_section_statement_type *current_section;
3978 for (l = 0; l < 32; l++)
3980 if (i >= (unsigned int) x)
3988 lang_output_section_statement_type *
3989 lang_enter_output_section_statement (const char *output_section_statement_name,
3990 etree_type *address_exp,
3991 enum section_type sectype,
3992 bfd_vma block_value,
3994 etree_type *subalign,
3997 lang_output_section_statement_type *os;
4001 lang_output_section_statement_lookup (output_section_statement_name);
4003 /* Add this statement to tree. */
4005 add_statement (lang_output_section_statement_enum,
4006 output_section_statement);
4008 /* Make next things chain into subchain of this. */
4010 if (os->addr_tree == NULL)
4012 os->addr_tree = address_exp;
4014 os->sectype = sectype;
4015 if (sectype != noload_section)
4016 os->flags = SEC_NO_FLAGS;
4018 os->flags = SEC_NEVER_LOAD;
4019 os->block_value = block_value ? block_value : 1;
4020 stat_ptr = &os->children;
4022 os->subsection_alignment =
4023 topower (exp_get_value_int (subalign, -1, "subsection alignment", 0));
4024 os->section_alignment =
4025 topower (exp_get_value_int (align, -1, "section alignment", 0));
4027 os->load_base = ebase;
4034 lang_output_statement_type *new =
4035 new_stat (lang_output_statement, stat_ptr);
4037 new->name = output_filename;
4040 /* Reset the current counters in the regions. */
4043 lang_reset_memory_regions (void)
4045 lang_memory_region_type *p = lang_memory_region_list;
4048 for (p = lang_memory_region_list; p != NULL; p = p->next)
4050 p->old_length = (bfd_size_type) (p->current - p->origin);
4051 p->current = p->origin;
4054 for (o = output_bfd->sections; o != NULL; o = o->next)
4058 /* If the wild pattern was marked KEEP, the member sections
4059 should be as well. */
4062 gc_section_callback (lang_wild_statement_type *ptr,
4063 struct wildcard_list *sec ATTRIBUTE_UNUSED,
4065 lang_input_statement_type *file ATTRIBUTE_UNUSED,
4066 void *data ATTRIBUTE_UNUSED)
4068 if (ptr->keep_sections)
4069 section->flags |= SEC_KEEP;
4072 /* Handle a wild statement, marking it against GC. */
4075 lang_gc_wild (lang_wild_statement_type *s)
4077 walk_wild (s, gc_section_callback, NULL);
4080 /* Iterate over sections marking them against GC. */
4083 lang_gc_sections_1 (lang_statement_union_type *s)
4085 for (; s != NULL; s = s->header.next)
4087 switch (s->header.type)
4089 case lang_wild_statement_enum:
4090 lang_gc_wild (&s->wild_statement);
4092 case lang_constructors_statement_enum:
4093 lang_gc_sections_1 (constructor_list.head);
4095 case lang_output_section_statement_enum:
4096 lang_gc_sections_1 (s->output_section_statement.children.head);
4098 case lang_group_statement_enum:
4099 lang_gc_sections_1 (s->group_statement.children.head);
4108 lang_gc_sections (void)
4110 struct bfd_link_hash_entry *h;
4111 ldlang_undef_chain_list_type *ulist;
4113 /* Keep all sections so marked in the link script. */
4115 lang_gc_sections_1 (statement_list.head);
4117 /* Keep all sections containing symbols undefined on the command-line,
4118 and the section containing the entry symbol. */
4120 for (ulist = link_info.gc_sym_list; ulist; ulist = ulist->next)
4122 h = bfd_link_hash_lookup (link_info.hash, ulist->name,
4123 FALSE, FALSE, FALSE);
4126 && (h->type == bfd_link_hash_defined
4127 || h->type == bfd_link_hash_defweak)
4128 && ! bfd_is_abs_section (h->u.def.section))
4130 h->u.def.section->flags |= SEC_KEEP;
4134 bfd_gc_sections (output_bfd, &link_info);
4140 lang_reasonable_defaults ();
4141 current_target = default_target;
4143 /* Open the output file. */
4144 lang_for_each_statement (ldlang_open_output);
4146 ldemul_create_output_section_statements ();
4148 /* Add to the hash table all undefineds on the command line. */
4149 lang_place_undefineds ();
4151 already_linked_table_init ();
4153 /* Create a bfd for each input file. */
4154 current_target = default_target;
4155 open_input_bfds (statement_list.head, FALSE);
4157 link_info.gc_sym_list = &entry_symbol;
4158 if (entry_symbol.name == NULL)
4159 link_info.gc_sym_list = ldlang_undef_chain_list_head;
4161 ldemul_after_open ();
4163 already_linked_table_free ();
4165 /* Make sure that we're not mixing architectures. We call this
4166 after all the input files have been opened, but before we do any
4167 other processing, so that any operations merge_private_bfd_data
4168 does on the output file will be known during the rest of the
4172 /* Handle .exports instead of a version script if we're told to do so. */
4173 if (command_line.version_exports_section)
4174 lang_do_version_exports_section ();
4176 /* Build all sets based on the information gathered from the input
4178 ldctor_build_sets ();
4180 /* Remove unreferenced sections if asked to. */
4181 if (command_line.gc_sections)
4182 lang_gc_sections ();
4184 /* If there were any SEC_MERGE sections, finish their merging, so that
4185 section sizes can be computed. This has to be done after GC of sections,
4186 so that GCed sections are not merged, but before assigning output
4187 sections, since removing whole input sections is hard then. */
4188 bfd_merge_sections (output_bfd, &link_info);
4190 /* Size up the common data. */
4193 /* Run through the contours of the script and attach input sections
4194 to the correct output sections. */
4195 map_input_to_output_sections (statement_list.head, NULL, NULL);
4197 /* Find any sections not attached explicitly and handle them. */
4198 lang_place_orphans ();
4200 if (! link_info.relocatable)
4202 /* Look for a text section and set the readonly attribute in it. */
4203 asection *found = bfd_get_section_by_name (output_bfd, ".text");
4207 if (config.text_read_only)
4208 found->flags |= SEC_READONLY;
4210 found->flags &= ~SEC_READONLY;
4214 /* Do anything special before sizing sections. This is where ELF
4215 and other back-ends size dynamic sections. */
4216 ldemul_before_allocation ();
4218 if (!link_info.relocatable)
4219 strip_excluded_output_sections ();
4221 /* We must record the program headers before we try to fix the
4222 section positions, since they will affect SIZEOF_HEADERS. */
4223 lang_record_phdrs ();
4225 /* Size up the sections. */
4226 lang_size_sections (statement_list.head, abs_output_section,
4227 &statement_list.head, 0, 0, NULL,
4228 command_line.relax ? FALSE : TRUE);
4230 /* Now run around and relax if we can. */
4231 if (command_line.relax)
4233 /* Keep relaxing until bfd_relax_section gives up. */
4234 bfd_boolean relax_again;
4238 lang_reset_memory_regions ();
4240 relax_again = FALSE;
4242 /* Note: pe-dll.c does something like this also. If you find
4243 you need to change this code, you probably need to change
4244 pe-dll.c also. DJ */
4246 /* Do all the assignments with our current guesses as to
4248 lang_do_assignments (statement_list.head, abs_output_section,
4251 /* Perform another relax pass - this time we know where the
4252 globals are, so can make a better guess. */
4253 lang_size_sections (statement_list.head, abs_output_section,
4254 &statement_list.head, 0, 0, &relax_again, FALSE);
4256 /* If the normal relax is done and the relax finalize pass
4257 is not performed yet, we perform another relax pass. */
4258 if (!relax_again && !link_info.relax_finalizing)
4260 link_info.relax_finalizing = TRUE;
4264 while (relax_again);
4266 /* Final extra sizing to report errors. */
4267 lang_reset_memory_regions ();
4268 lang_do_assignments (statement_list.head, abs_output_section, NULL, 0);
4269 lang_size_sections (statement_list.head, abs_output_section,
4270 &statement_list.head, 0, 0, NULL, TRUE);
4273 /* See if anything special should be done now we know how big
4275 ldemul_after_allocation ();
4277 /* Fix any .startof. or .sizeof. symbols. */
4278 lang_set_startof ();
4280 /* Do all the assignments, now that we know the final resting places
4281 of all the symbols. */
4283 lang_do_assignments (statement_list.head, abs_output_section, NULL, 0);
4285 /* Make sure that the section addresses make sense. */
4286 if (! link_info.relocatable
4287 && command_line.check_section_addresses)
4288 lang_check_section_addresses ();
4296 /* EXPORTED TO YACC */
4299 lang_add_wild (struct wildcard_spec *filespec,
4300 struct wildcard_list *section_list,
4301 bfd_boolean keep_sections)
4303 struct wildcard_list *curr, *next;
4304 lang_wild_statement_type *new;
4306 /* Reverse the list as the parser puts it back to front. */
4307 for (curr = section_list, section_list = NULL;
4309 section_list = curr, curr = next)
4311 if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
4312 placed_commons = TRUE;
4315 curr->next = section_list;
4318 if (filespec != NULL && filespec->name != NULL)
4320 if (strcmp (filespec->name, "*") == 0)
4321 filespec->name = NULL;
4322 else if (! wildcardp (filespec->name))
4323 lang_has_input_file = TRUE;
4326 new = new_stat (lang_wild_statement, stat_ptr);
4327 new->filename = NULL;
4328 new->filenames_sorted = FALSE;
4329 if (filespec != NULL)
4331 new->filename = filespec->name;
4332 new->filenames_sorted = filespec->sorted;
4334 new->section_list = section_list;
4335 new->keep_sections = keep_sections;
4336 lang_list_init (&new->children);
4340 lang_section_start (const char *name, etree_type *address)
4342 lang_address_statement_type *ad;
4344 ad = new_stat (lang_address_statement, stat_ptr);
4345 ad->section_name = name;
4346 ad->address = address;
4349 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4350 because of a -e argument on the command line, or zero if this is
4351 called by ENTRY in a linker script. Command line arguments take
4355 lang_add_entry (const char *name, bfd_boolean cmdline)
4357 if (entry_symbol.name == NULL
4359 || ! entry_from_cmdline)
4361 entry_symbol.name = name;
4362 entry_from_cmdline = cmdline;
4367 lang_add_target (const char *name)
4369 lang_target_statement_type *new = new_stat (lang_target_statement,
4377 lang_add_map (const char *name)
4384 map_option_f = TRUE;
4392 lang_add_fill (fill_type *fill)
4394 lang_fill_statement_type *new = new_stat (lang_fill_statement,
4401 lang_add_data (int type, union etree_union *exp)
4404 lang_data_statement_type *new = new_stat (lang_data_statement,
4412 /* Create a new reloc statement. RELOC is the BFD relocation type to
4413 generate. HOWTO is the corresponding howto structure (we could
4414 look this up, but the caller has already done so). SECTION is the
4415 section to generate a reloc against, or NAME is the name of the
4416 symbol to generate a reloc against. Exactly one of SECTION and
4417 NAME must be NULL. ADDEND is an expression for the addend. */
4420 lang_add_reloc (bfd_reloc_code_real_type reloc,
4421 reloc_howto_type *howto,
4424 union etree_union *addend)
4426 lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
4430 p->section = section;
4432 p->addend_exp = addend;
4434 p->addend_value = 0;
4435 p->output_section = NULL;
4439 lang_assignment_statement_type *
4440 lang_add_assignment (etree_type *exp)
4442 lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
4450 lang_add_attribute (enum statement_enum attribute)
4452 new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
4456 lang_startup (const char *name)
4458 if (startup_file != NULL)
4460 einfo (_("%P%Fmultiple STARTUP files\n"));
4462 first_file->filename = name;
4463 first_file->local_sym_name = name;
4464 first_file->real = TRUE;
4466 startup_file = name;
4470 lang_float (bfd_boolean maybe)
4472 lang_float_flag = maybe;
4476 /* Work out the load- and run-time regions from a script statement, and
4477 store them in *LMA_REGION and *REGION respectively.
4479 MEMSPEC is the name of the run-time region, or the value of
4480 DEFAULT_MEMORY_REGION if the statement didn't specify one.
4481 LMA_MEMSPEC is the name of the load-time region, or null if the
4482 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
4483 had an explicit load address.
4485 It is an error to specify both a load region and a load address. */
4488 lang_get_regions (struct memory_region_struct **region,
4489 struct memory_region_struct **lma_region,
4490 const char *memspec,
4491 const char *lma_memspec,
4494 *lma_region = lang_memory_region_lookup (lma_memspec, FALSE);
4496 /* If no runtime region has been given, but the load region has
4497 been, use the load region. */
4498 if (lma_memspec != 0 && strcmp (memspec, DEFAULT_MEMORY_REGION) == 0)
4499 *region = *lma_region;
4501 *region = lang_memory_region_lookup (memspec, FALSE);
4503 if (have_lma_p && lma_memspec != 0)
4504 einfo (_("%X%P:%S: section has both a load address and a load region\n"));
4508 lang_leave_output_section_statement
4509 (fill_type *fill, const char *memspec,
4510 struct lang_output_section_phdr_list *phdrs, const char *lma_memspec)
4512 lang_get_regions (¤t_section->region,
4513 ¤t_section->lma_region,
4514 memspec, lma_memspec,
4515 current_section->load_base != 0);
4516 current_section->fill = fill;
4517 current_section->phdrs = phdrs;
4518 stat_ptr = &statement_list;
4521 /* Create an absolute symbol with the given name with the value of the
4522 address of first byte of the section named.
4524 If the symbol already exists, then do nothing. */
4527 lang_abs_symbol_at_beginning_of (const char *secname, const char *name)
4529 struct bfd_link_hash_entry *h;
4531 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
4533 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4535 if (h->type == bfd_link_hash_new
4536 || h->type == bfd_link_hash_undefined)
4540 h->type = bfd_link_hash_defined;
4542 sec = bfd_get_section_by_name (output_bfd, secname);
4546 h->u.def.value = bfd_get_section_vma (output_bfd, sec);
4548 h->u.def.section = bfd_abs_section_ptr;
4552 /* Create an absolute symbol with the given name with the value of the
4553 address of the first byte after the end of the section named.
4555 If the symbol already exists, then do nothing. */
4558 lang_abs_symbol_at_end_of (const char *secname, const char *name)
4560 struct bfd_link_hash_entry *h;
4562 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
4564 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4566 if (h->type == bfd_link_hash_new
4567 || h->type == bfd_link_hash_undefined)
4571 h->type = bfd_link_hash_defined;
4573 sec = bfd_get_section_by_name (output_bfd, secname);
4577 h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
4578 + bfd_section_size (output_bfd, sec) /
4579 bfd_octets_per_byte (output_bfd));
4581 h->u.def.section = bfd_abs_section_ptr;
4586 lang_statement_append (lang_statement_list_type *list,
4587 lang_statement_union_type *element,
4588 lang_statement_union_type **field)
4590 *(list->tail) = element;
4594 /* Set the output format type. -oformat overrides scripts. */
4597 lang_add_output_format (const char *format,
4602 if (output_target == NULL || !from_script)
4604 if (command_line.endian == ENDIAN_BIG
4607 else if (command_line.endian == ENDIAN_LITTLE
4611 output_target = format;
4615 /* Enter a group. This creates a new lang_group_statement, and sets
4616 stat_ptr to build new statements within the group. */
4619 lang_enter_group (void)
4621 lang_group_statement_type *g;
4623 g = new_stat (lang_group_statement, stat_ptr);
4624 lang_list_init (&g->children);
4625 stat_ptr = &g->children;
4628 /* Leave a group. This just resets stat_ptr to start writing to the
4629 regular list of statements again. Note that this will not work if
4630 groups can occur inside anything else which can adjust stat_ptr,
4631 but currently they can't. */
4634 lang_leave_group (void)
4636 stat_ptr = &statement_list;
4639 /* Add a new program header. This is called for each entry in a PHDRS
4640 command in a linker script. */
4643 lang_new_phdr (const char *name,
4645 bfd_boolean filehdr,
4650 struct lang_phdr *n, **pp;
4652 n = stat_alloc (sizeof (struct lang_phdr));
4655 n->type = exp_get_value_int (type, 0, "program header type",
4656 lang_final_phase_enum);
4657 n->filehdr = filehdr;
4662 for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
4667 /* Record the program header information in the output BFD. FIXME: We
4668 should not be calling an ELF specific function here. */
4671 lang_record_phdrs (void)
4675 struct lang_output_section_phdr_list *last;
4676 struct lang_phdr *l;
4677 lang_statement_union_type *u;
4680 secs = xmalloc (alc * sizeof (asection *));
4682 for (l = lang_phdr_list; l != NULL; l = l->next)
4689 for (u = lang_output_section_statement.head;
4691 u = u->output_section_statement.next)
4693 lang_output_section_statement_type *os;
4694 struct lang_output_section_phdr_list *pl;
4696 os = &u->output_section_statement;
4703 if (os->sectype == noload_section
4704 || os->bfd_section == NULL
4705 || (os->bfd_section->flags & SEC_ALLOC) == 0)
4710 if (os->bfd_section == NULL)
4713 for (; pl != NULL; pl = pl->next)
4715 if (strcmp (pl->name, l->name) == 0)
4720 secs = xrealloc (secs, alc * sizeof (asection *));
4722 secs[c] = os->bfd_section;
4729 if (l->flags == NULL)
4732 flags = exp_get_vma (l->flags, 0, "phdr flags",
4733 lang_final_phase_enum);
4738 at = exp_get_vma (l->at, 0, "phdr load address",
4739 lang_final_phase_enum);
4741 if (! bfd_record_phdr (output_bfd, l->type,
4742 l->flags != NULL, flags, l->at != NULL,
4743 at, l->filehdr, l->phdrs, c, secs))
4744 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4749 /* Make sure all the phdr assignments succeeded. */
4750 for (u = lang_output_section_statement.head;
4752 u = u->output_section_statement.next)
4754 struct lang_output_section_phdr_list *pl;
4756 if (u->output_section_statement.bfd_section == NULL)
4759 for (pl = u->output_section_statement.phdrs;
4762 if (! pl->used && strcmp (pl->name, "NONE") != 0)
4763 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4764 u->output_section_statement.name, pl->name);
4768 /* Record a list of sections which may not be cross referenced. */
4771 lang_add_nocrossref (struct lang_nocrossref *l)
4773 struct lang_nocrossrefs *n;
4775 n = xmalloc (sizeof *n);
4776 n->next = nocrossref_list;
4778 nocrossref_list = n;
4780 /* Set notice_all so that we get informed about all symbols. */
4781 link_info.notice_all = TRUE;
4784 /* Overlay handling. We handle overlays with some static variables. */
4786 /* The overlay virtual address. */
4787 static etree_type *overlay_vma;
4788 /* And subsection alignment. */
4789 static etree_type *overlay_subalign;
4791 /* An expression for the maximum section size seen so far. */
4792 static etree_type *overlay_max;
4794 /* A list of all the sections in this overlay. */
4796 struct overlay_list {
4797 struct overlay_list *next;
4798 lang_output_section_statement_type *os;
4801 static struct overlay_list *overlay_list;
4803 /* Start handling an overlay. */
4806 lang_enter_overlay (etree_type *vma_expr, etree_type *subalign)
4808 /* The grammar should prevent nested overlays from occurring. */
4809 ASSERT (overlay_vma == NULL
4810 && overlay_subalign == NULL
4811 && overlay_max == NULL);
4813 overlay_vma = vma_expr;
4814 overlay_subalign = subalign;
4817 /* Start a section in an overlay. We handle this by calling
4818 lang_enter_output_section_statement with the correct VMA.
4819 lang_leave_overlay sets up the LMA and memory regions. */
4822 lang_enter_overlay_section (const char *name)
4824 struct overlay_list *n;
4827 lang_enter_output_section_statement (name, overlay_vma, normal_section,
4828 0, 0, overlay_subalign, 0);
4830 /* If this is the first section, then base the VMA of future
4831 sections on this one. This will work correctly even if `.' is
4832 used in the addresses. */
4833 if (overlay_list == NULL)
4834 overlay_vma = exp_nameop (ADDR, name);
4836 /* Remember the section. */
4837 n = xmalloc (sizeof *n);
4838 n->os = current_section;
4839 n->next = overlay_list;
4842 size = exp_nameop (SIZEOF, name);
4844 /* Arrange to work out the maximum section end address. */
4845 if (overlay_max == NULL)
4848 overlay_max = exp_binop (MAX_K, overlay_max, size);
4851 /* Finish a section in an overlay. There isn't any special to do
4855 lang_leave_overlay_section (fill_type *fill,
4856 struct lang_output_section_phdr_list *phdrs)
4863 name = current_section->name;
4865 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
4866 region and that no load-time region has been specified. It doesn't
4867 really matter what we say here, since lang_leave_overlay will
4869 lang_leave_output_section_statement (fill, DEFAULT_MEMORY_REGION, phdrs, 0);
4871 /* Define the magic symbols. */
4873 clean = xmalloc (strlen (name) + 1);
4875 for (s1 = name; *s1 != '\0'; s1++)
4876 if (ISALNUM (*s1) || *s1 == '_')
4880 buf = xmalloc (strlen (clean) + sizeof "__load_start_");
4881 sprintf (buf, "__load_start_%s", clean);
4882 lang_add_assignment (exp_assop ('=', buf,
4883 exp_nameop (LOADADDR, name)));
4885 buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
4886 sprintf (buf, "__load_stop_%s", clean);
4887 lang_add_assignment (exp_assop ('=', buf,
4889 exp_nameop (LOADADDR, name),
4890 exp_nameop (SIZEOF, name))));
4895 /* Finish an overlay. If there are any overlay wide settings, this
4896 looks through all the sections in the overlay and sets them. */
4899 lang_leave_overlay (etree_type *lma_expr,
4902 const char *memspec,
4903 struct lang_output_section_phdr_list *phdrs,
4904 const char *lma_memspec)
4906 lang_memory_region_type *region;
4907 lang_memory_region_type *lma_region;
4908 struct overlay_list *l;
4909 struct lang_nocrossref *nocrossref;
4911 lang_get_regions (®ion, &lma_region,
4912 memspec, lma_memspec,
4917 /* After setting the size of the last section, set '.' to end of the
4919 if (overlay_list != NULL)
4920 overlay_list->os->update_dot_tree
4921 = exp_assop ('=', ".", exp_binop ('+', overlay_vma, overlay_max));
4926 struct overlay_list *next;
4928 if (fill != NULL && l->os->fill == NULL)
4931 l->os->region = region;
4932 l->os->lma_region = lma_region;
4934 /* The first section has the load address specified in the
4935 OVERLAY statement. The rest are worked out from that.
4936 The base address is not needed (and should be null) if
4937 an LMA region was specified. */
4939 l->os->load_base = lma_expr;
4940 else if (lma_region == 0)
4941 l->os->load_base = exp_binop ('+',
4942 exp_nameop (LOADADDR, l->next->os->name),
4943 exp_nameop (SIZEOF, l->next->os->name));
4945 if (phdrs != NULL && l->os->phdrs == NULL)
4946 l->os->phdrs = phdrs;
4950 struct lang_nocrossref *nc;
4952 nc = xmalloc (sizeof *nc);
4953 nc->name = l->os->name;
4954 nc->next = nocrossref;
4963 if (nocrossref != NULL)
4964 lang_add_nocrossref (nocrossref);
4967 overlay_list = NULL;
4971 /* Version handling. This is only useful for ELF. */
4973 /* This global variable holds the version tree that we build. */
4975 struct bfd_elf_version_tree *lang_elf_version_info;
4977 /* If PREV is NULL, return first version pattern matching particular symbol.
4978 If PREV is non-NULL, return first version pattern matching particular
4979 symbol after PREV (previously returned by lang_vers_match). */
4981 static struct bfd_elf_version_expr *
4982 lang_vers_match (struct bfd_elf_version_expr_head *head,
4983 struct bfd_elf_version_expr *prev,
4986 const char *cxx_sym = sym;
4987 const char *java_sym = sym;
4988 struct bfd_elf_version_expr *expr = NULL;
4990 if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
4992 cxx_sym = cplus_demangle (sym, /* DMGL_NO_TPARAMS */ 0);
4996 if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
4998 java_sym = cplus_demangle (sym, DMGL_JAVA);
5003 if (head->htab && (prev == NULL || prev->symbol))
5005 struct bfd_elf_version_expr e;
5007 switch (prev ? prev->mask : 0)
5010 if (head->mask & BFD_ELF_VERSION_C_TYPE)
5013 expr = htab_find (head->htab, &e);
5014 while (expr && strcmp (expr->symbol, sym) == 0)
5015 if (expr->mask == BFD_ELF_VERSION_C_TYPE)
5021 case BFD_ELF_VERSION_C_TYPE:
5022 if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
5025 expr = htab_find (head->htab, &e);
5026 while (expr && strcmp (expr->symbol, sym) == 0)
5027 if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
5033 case BFD_ELF_VERSION_CXX_TYPE:
5034 if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
5036 e.symbol = java_sym;
5037 expr = htab_find (head->htab, &e);
5038 while (expr && strcmp (expr->symbol, sym) == 0)
5039 if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
5050 /* Finally, try the wildcards. */
5051 if (prev == NULL || prev->symbol)
5052 expr = head->remaining;
5059 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5062 if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
5064 else if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
5068 if (fnmatch (expr->pattern, s, 0) == 0)
5075 free ((char *) cxx_sym);
5076 if (java_sym != sym)
5077 free ((char *) java_sym);
5081 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
5082 return a string pointing to the symbol name. */
5085 realsymbol (const char *pattern)
5088 bfd_boolean changed = FALSE, backslash = FALSE;
5089 char *s, *symbol = xmalloc (strlen (pattern) + 1);
5091 for (p = pattern, s = symbol; *p != '\0'; ++p)
5093 /* It is a glob pattern only if there is no preceding
5095 if (! backslash && (*p == '?' || *p == '*' || *p == '['))
5103 /* Remove the preceding backslash. */
5110 backslash = *p == '\\';
5125 /* This is called for each variable name or match expression. */
5127 struct bfd_elf_version_expr *
5128 lang_new_vers_pattern (struct bfd_elf_version_expr *orig,
5132 struct bfd_elf_version_expr *ret;
5134 ret = xmalloc (sizeof *ret);
5139 ret->symbol = realsymbol (new);
5141 if (lang == NULL || strcasecmp (lang, "C") == 0)
5142 ret->mask = BFD_ELF_VERSION_C_TYPE;
5143 else if (strcasecmp (lang, "C++") == 0)
5144 ret->mask = BFD_ELF_VERSION_CXX_TYPE;
5145 else if (strcasecmp (lang, "Java") == 0)
5146 ret->mask = BFD_ELF_VERSION_JAVA_TYPE;
5149 einfo (_("%X%P: unknown language `%s' in version information\n"),
5151 ret->mask = BFD_ELF_VERSION_C_TYPE;
5154 return ldemul_new_vers_pattern (ret);
5157 /* This is called for each set of variable names and match
5160 struct bfd_elf_version_tree *
5161 lang_new_vers_node (struct bfd_elf_version_expr *globals,
5162 struct bfd_elf_version_expr *locals)
5164 struct bfd_elf_version_tree *ret;
5166 ret = xcalloc (1, sizeof *ret);
5167 ret->globals.list = globals;
5168 ret->locals.list = locals;
5169 ret->match = lang_vers_match;
5170 ret->name_indx = (unsigned int) -1;
5174 /* This static variable keeps track of version indices. */
5176 static int version_index;
5179 version_expr_head_hash (const void *p)
5181 const struct bfd_elf_version_expr *e = p;
5183 return htab_hash_string (e->symbol);
5187 version_expr_head_eq (const void *p1, const void *p2)
5189 const struct bfd_elf_version_expr *e1 = p1;
5190 const struct bfd_elf_version_expr *e2 = p2;
5192 return strcmp (e1->symbol, e2->symbol) == 0;
5196 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head *head)
5199 struct bfd_elf_version_expr *e, *next;
5200 struct bfd_elf_version_expr **list_loc, **remaining_loc;
5202 for (e = head->list; e; e = e->next)
5206 head->mask |= e->mask;
5211 head->htab = htab_create (count * 2, version_expr_head_hash,
5212 version_expr_head_eq, NULL);
5213 list_loc = &head->list;
5214 remaining_loc = &head->remaining;
5215 for (e = head->list; e; e = next)
5221 remaining_loc = &e->next;
5225 void **loc = htab_find_slot (head->htab, e, INSERT);
5229 struct bfd_elf_version_expr *e1, *last;
5235 if (e1->mask == e->mask)
5243 while (e1 && strcmp (e1->symbol, e->symbol) == 0);
5247 /* This is a duplicate. */
5248 /* FIXME: Memory leak. Sometimes pattern is not
5249 xmalloced alone, but in larger chunk of memory. */
5250 /* free (e->symbol); */
5255 e->next = last->next;
5263 list_loc = &e->next;
5267 *remaining_loc = NULL;
5268 *list_loc = head->remaining;
5271 head->remaining = head->list;
5274 /* This is called when we know the name and dependencies of the
5278 lang_register_vers_node (const char *name,
5279 struct bfd_elf_version_tree *version,
5280 struct bfd_elf_version_deps *deps)
5282 struct bfd_elf_version_tree *t, **pp;
5283 struct bfd_elf_version_expr *e1;
5288 if ((name[0] == '\0' && lang_elf_version_info != NULL)
5289 || (lang_elf_version_info && lang_elf_version_info->name[0] == '\0'))
5291 einfo (_("%X%P: anonymous version tag cannot be combined with other version tags\n"));
5296 /* Make sure this node has a unique name. */
5297 for (t = lang_elf_version_info; t != NULL; t = t->next)
5298 if (strcmp (t->name, name) == 0)
5299 einfo (_("%X%P: duplicate version tag `%s'\n"), name);
5301 lang_finalize_version_expr_head (&version->globals);
5302 lang_finalize_version_expr_head (&version->locals);
5304 /* Check the global and local match names, and make sure there
5305 aren't any duplicates. */
5307 for (e1 = version->globals.list; e1 != NULL; e1 = e1->next)
5309 for (t = lang_elf_version_info; t != NULL; t = t->next)
5311 struct bfd_elf_version_expr *e2;
5313 if (t->locals.htab && e1->symbol)
5315 e2 = htab_find (t->locals.htab, e1);
5316 while (e2 && strcmp (e1->symbol, e2->symbol) == 0)
5318 if (e1->mask == e2->mask)
5319 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5324 else if (!e1->symbol)
5325 for (e2 = t->locals.remaining; e2 != NULL; e2 = e2->next)
5326 if (strcmp (e1->pattern, e2->pattern) == 0 && e1->mask == e2->mask)
5327 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5332 for (e1 = version->locals.list; e1 != NULL; e1 = e1->next)
5334 for (t = lang_elf_version_info; t != NULL; t = t->next)
5336 struct bfd_elf_version_expr *e2;
5338 if (t->globals.htab && e1->symbol)
5340 e2 = htab_find (t->globals.htab, e1);
5341 while (e2 && strcmp (e1->symbol, e2->symbol) == 0)
5343 if (e1->mask == e2->mask)
5344 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5349 else if (!e1->symbol)
5350 for (e2 = t->globals.remaining; e2 != NULL; e2 = e2->next)
5351 if (strcmp (e1->pattern, e2->pattern) == 0 && e1->mask == e2->mask)
5352 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5357 version->deps = deps;
5358 version->name = name;
5359 if (name[0] != '\0')
5362 version->vernum = version_index;
5365 version->vernum = 0;
5367 for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
5372 /* This is called when we see a version dependency. */
5374 struct bfd_elf_version_deps *
5375 lang_add_vers_depend (struct bfd_elf_version_deps *list, const char *name)
5377 struct bfd_elf_version_deps *ret;
5378 struct bfd_elf_version_tree *t;
5380 ret = xmalloc (sizeof *ret);
5383 for (t = lang_elf_version_info; t != NULL; t = t->next)
5385 if (strcmp (t->name, name) == 0)
5387 ret->version_needed = t;
5392 einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
5398 lang_do_version_exports_section (void)
5400 struct bfd_elf_version_expr *greg = NULL, *lreg;
5402 LANG_FOR_EACH_INPUT_STATEMENT (is)
5404 asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
5411 len = bfd_section_size (is->the_bfd, sec);
5412 contents = xmalloc (len);
5413 if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
5414 einfo (_("%X%P: unable to read .exports section contents\n"), sec);
5417 while (p < contents + len)
5419 greg = lang_new_vers_pattern (greg, p, NULL);
5420 p = strchr (p, '\0') + 1;
5423 /* Do not free the contents, as we used them creating the regex. */
5425 /* Do not include this section in the link. */
5426 bfd_set_section_flags (is->the_bfd, sec,
5427 bfd_get_section_flags (is->the_bfd, sec) | SEC_EXCLUDE);
5430 lreg = lang_new_vers_pattern (NULL, "*", NULL);
5431 lang_register_vers_node (command_line.version_exports_section,
5432 lang_new_vers_node (greg, lreg), NULL);
5436 lang_add_unique (const char *name)
5438 struct unique_sections *ent;
5440 for (ent = unique_section_list; ent; ent = ent->next)
5441 if (strcmp (ent->name, name) == 0)
5444 ent = xmalloc (sizeof *ent);
5445 ent->name = xstrdup (name);
5446 ent->next = unique_section_list;
5447 unique_section_list = ent;