1 /* Linker command language support.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
6 This file is part of the GNU Binutils.
8 This program 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 3 of the License, or
11 (at your option) any later version.
13 This program 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 this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
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
;
50 static struct obstack map_obstack
;
52 #define obstack_chunk_alloc xmalloc
53 #define obstack_chunk_free free
54 static const char *startup_file
;
55 static bfd_boolean placed_commons
= FALSE
;
56 static bfd_boolean stripped_excluded_sections
= FALSE
;
57 static lang_output_section_statement_type
*default_common_section
;
58 static bfd_boolean map_option_f
;
59 static bfd_vma print_dot
;
60 static lang_input_statement_type
*first_file
;
61 static const char *current_target
;
62 static const char *output_target
;
63 static lang_statement_list_type statement_list
;
64 static struct bfd_hash_table lang_definedness_table
;
66 /* Forward declarations. */
67 static void exp_init_os (etree_type
*);
68 static void init_map_userdata (bfd
*, asection
*, void *);
69 static lang_input_statement_type
*lookup_name (const char *);
70 static struct bfd_hash_entry
*lang_definedness_newfunc
71 (struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *);
72 static void insert_undefined (const char *);
73 static bfd_boolean
sort_def_symbol (struct bfd_link_hash_entry
*, void *);
74 static void print_statement (lang_statement_union_type
*,
75 lang_output_section_statement_type
*);
76 static void print_statement_list (lang_statement_union_type
*,
77 lang_output_section_statement_type
*);
78 static void print_statements (void);
79 static void print_input_section (asection
*);
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);
83 static void lang_finalize_version_expr_head
84 (struct bfd_elf_version_expr_head
*);
86 /* Exported variables. */
87 lang_output_section_statement_type
*abs_output_section
;
88 lang_statement_list_type lang_output_section_statement
;
89 lang_statement_list_type
*stat_ptr
= &statement_list
;
90 lang_statement_list_type file_chain
= { NULL
, NULL
};
91 lang_statement_list_type input_file_chain
;
92 struct bfd_sym_chain entry_symbol
= { NULL
, NULL
};
93 static const char *entry_symbol_default
= "start";
94 const char *entry_section
= ".text";
95 bfd_boolean entry_from_cmdline
;
96 bfd_boolean lang_has_input_file
= FALSE
;
97 bfd_boolean had_output_filename
= FALSE
;
98 bfd_boolean lang_float_flag
= FALSE
;
99 bfd_boolean delete_output_file_on_failure
= FALSE
;
100 struct lang_phdr
*lang_phdr_list
;
101 struct lang_nocrossrefs
*nocrossref_list
;
102 static struct unique_sections
*unique_section_list
;
103 static bfd_boolean ldlang_sysrooted_script
= FALSE
;
105 /* Functions that traverse the linker script and might evaluate
106 DEFINED() need to increment this. */
107 int lang_statement_iteration
= 0;
109 etree_type
*base
; /* Relocation base - or null */
111 /* Return TRUE if the PATTERN argument is a wildcard pattern.
112 Although backslashes are treated specially if a pattern contains
113 wildcards, we do not consider the mere presence of a backslash to
114 be enough to cause the pattern to be treated as a wildcard.
115 That lets us handle DOS filenames more naturally. */
116 #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
118 #define new_stat(x, y) \
119 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
121 #define outside_section_address(q) \
122 ((q)->output_offset + (q)->output_section->vma)
124 #define outside_symbol_address(q) \
125 ((q)->value + outside_section_address (q->section))
127 #define SECTION_NAME_MAP_LENGTH (16)
130 stat_alloc (size_t size
)
132 return obstack_alloc (&stat_obstack
, size
);
136 unique_section_p (const asection
*sec
)
138 struct unique_sections
*unam
;
141 if (link_info
.relocatable
142 && sec
->owner
!= NULL
143 && bfd_is_group_section (sec
->owner
, sec
))
147 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
148 if (wildcardp (unam
->name
)
149 ? fnmatch (unam
->name
, secnam
, 0) == 0
150 : strcmp (unam
->name
, secnam
) == 0)
158 /* Generic traversal routines for finding matching sections. */
160 /* Try processing a section against a wildcard. This just calls
161 the callback unless the filename exclusion list is present
162 and excludes the file. It's hardly ever present so this
163 function is very fast. */
166 walk_wild_consider_section (lang_wild_statement_type
*ptr
,
167 lang_input_statement_type
*file
,
169 struct wildcard_list
*sec
,
173 bfd_boolean skip
= FALSE
;
174 struct name_list
*list_tmp
;
176 /* Don't process sections from files which were
178 for (list_tmp
= sec
->spec
.exclude_name_list
;
180 list_tmp
= list_tmp
->next
)
182 bfd_boolean is_wildcard
= wildcardp (list_tmp
->name
);
184 skip
= fnmatch (list_tmp
->name
, file
->filename
, 0) == 0;
186 skip
= strcmp (list_tmp
->name
, file
->filename
) == 0;
188 /* If this file is part of an archive, and the archive is
189 excluded, exclude this file. */
190 if (! skip
&& file
->the_bfd
!= NULL
191 && file
->the_bfd
->my_archive
!= NULL
192 && file
->the_bfd
->my_archive
->filename
!= NULL
)
195 skip
= fnmatch (list_tmp
->name
,
196 file
->the_bfd
->my_archive
->filename
,
199 skip
= strcmp (list_tmp
->name
,
200 file
->the_bfd
->my_archive
->filename
) == 0;
208 (*callback
) (ptr
, sec
, s
, file
, data
);
211 /* Lowest common denominator routine that can handle everything correctly,
215 walk_wild_section_general (lang_wild_statement_type
*ptr
,
216 lang_input_statement_type
*file
,
221 struct wildcard_list
*sec
;
223 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
225 sec
= ptr
->section_list
;
227 (*callback
) (ptr
, sec
, s
, file
, data
);
231 bfd_boolean skip
= FALSE
;
233 if (sec
->spec
.name
!= NULL
)
235 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
237 if (wildcardp (sec
->spec
.name
))
238 skip
= fnmatch (sec
->spec
.name
, sname
, 0) != 0;
240 skip
= strcmp (sec
->spec
.name
, sname
) != 0;
244 walk_wild_consider_section (ptr
, file
, s
, sec
, callback
, data
);
251 /* Routines to find a single section given its name. If there's more
252 than one section with that name, we report that. */
256 asection
*found_section
;
257 bfd_boolean multiple_sections_found
;
258 } section_iterator_callback_data
;
261 section_iterator_callback (bfd
*bfd ATTRIBUTE_UNUSED
, asection
*s
, void *data
)
263 section_iterator_callback_data
*d
= data
;
265 if (d
->found_section
!= NULL
)
267 d
->multiple_sections_found
= TRUE
;
271 d
->found_section
= s
;
276 find_section (lang_input_statement_type
*file
,
277 struct wildcard_list
*sec
,
278 bfd_boolean
*multiple_sections_found
)
280 section_iterator_callback_data cb_data
= { NULL
, FALSE
};
282 bfd_get_section_by_name_if (file
->the_bfd
, sec
->spec
.name
,
283 section_iterator_callback
, &cb_data
);
284 *multiple_sections_found
= cb_data
.multiple_sections_found
;
285 return cb_data
.found_section
;
288 /* Code for handling simple wildcards without going through fnmatch,
289 which can be expensive because of charset translations etc. */
291 /* A simple wild is a literal string followed by a single '*',
292 where the literal part is at least 4 characters long. */
295 is_simple_wild (const char *name
)
297 size_t len
= strcspn (name
, "*?[");
298 return len
>= 4 && name
[len
] == '*' && name
[len
+ 1] == '\0';
302 match_simple_wild (const char *pattern
, const char *name
)
304 /* The first four characters of the pattern are guaranteed valid
305 non-wildcard characters. So we can go faster. */
306 if (pattern
[0] != name
[0] || pattern
[1] != name
[1]
307 || pattern
[2] != name
[2] || pattern
[3] != name
[3])
312 while (*pattern
!= '*')
313 if (*name
++ != *pattern
++)
319 /* Compare sections ASEC and BSEC according to SORT. */
322 compare_section (sort_type sort
, asection
*asec
, asection
*bsec
)
331 case by_alignment_name
:
332 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
333 - bfd_section_alignment (asec
->owner
, asec
));
339 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
340 bfd_get_section_name (bsec
->owner
, bsec
));
343 case by_name_alignment
:
344 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
345 bfd_get_section_name (bsec
->owner
, bsec
));
351 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
352 - bfd_section_alignment (asec
->owner
, asec
));
359 /* Build a Binary Search Tree to sort sections, unlike insertion sort
360 used in wild_sort(). BST is considerably faster if the number of
361 of sections are large. */
363 static lang_section_bst_type
**
364 wild_sort_fast (lang_wild_statement_type
*wild
,
365 struct wildcard_list
*sec
,
366 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
369 lang_section_bst_type
**tree
;
372 if (!wild
->filenames_sorted
373 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
375 /* Append at the right end of tree. */
377 tree
= &((*tree
)->right
);
383 /* Find the correct node to append this section. */
384 if (compare_section (sec
->spec
.sorted
, section
, (*tree
)->section
) < 0)
385 tree
= &((*tree
)->left
);
387 tree
= &((*tree
)->right
);
393 /* Use wild_sort_fast to build a BST to sort sections. */
396 output_section_callback_fast (lang_wild_statement_type
*ptr
,
397 struct wildcard_list
*sec
,
399 lang_input_statement_type
*file
,
400 void *output ATTRIBUTE_UNUSED
)
402 lang_section_bst_type
*node
;
403 lang_section_bst_type
**tree
;
405 if (unique_section_p (section
))
408 node
= xmalloc (sizeof (lang_section_bst_type
));
411 node
->section
= section
;
413 tree
= wild_sort_fast (ptr
, sec
, file
, section
);
418 /* Convert a sorted sections' BST back to list form. */
421 output_section_callback_tree_to_list (lang_wild_statement_type
*ptr
,
422 lang_section_bst_type
*tree
,
426 output_section_callback_tree_to_list (ptr
, tree
->left
, output
);
428 lang_add_section (&ptr
->children
, tree
->section
,
429 (lang_output_section_statement_type
*) output
);
432 output_section_callback_tree_to_list (ptr
, tree
->right
, output
);
437 /* Specialized, optimized routines for handling different kinds of
441 walk_wild_section_specs1_wild0 (lang_wild_statement_type
*ptr
,
442 lang_input_statement_type
*file
,
446 /* We can just do a hash lookup for the section with the right name.
447 But if that lookup discovers more than one section with the name
448 (should be rare), we fall back to the general algorithm because
449 we would otherwise have to sort the sections to make sure they
450 get processed in the bfd's order. */
451 bfd_boolean multiple_sections_found
;
452 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
453 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
455 if (multiple_sections_found
)
456 walk_wild_section_general (ptr
, file
, callback
, data
);
458 walk_wild_consider_section (ptr
, file
, s0
, sec0
, callback
, data
);
462 walk_wild_section_specs1_wild1 (lang_wild_statement_type
*ptr
,
463 lang_input_statement_type
*file
,
468 struct wildcard_list
*wildsec0
= ptr
->handler_data
[0];
470 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
472 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
473 bfd_boolean skip
= !match_simple_wild (wildsec0
->spec
.name
, sname
);
476 walk_wild_consider_section (ptr
, file
, s
, wildsec0
, callback
, data
);
481 walk_wild_section_specs2_wild1 (lang_wild_statement_type
*ptr
,
482 lang_input_statement_type
*file
,
487 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
488 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
489 bfd_boolean multiple_sections_found
;
490 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
492 if (multiple_sections_found
)
494 walk_wild_section_general (ptr
, file
, callback
, data
);
498 /* Note that if the section was not found, s0 is NULL and
499 we'll simply never succeed the s == s0 test below. */
500 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
502 /* Recall that in this code path, a section cannot satisfy more
503 than one spec, so if s == s0 then it cannot match
506 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
509 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
510 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
513 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
,
520 walk_wild_section_specs3_wild2 (lang_wild_statement_type
*ptr
,
521 lang_input_statement_type
*file
,
526 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
527 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
528 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
529 bfd_boolean multiple_sections_found
;
530 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
532 if (multiple_sections_found
)
534 walk_wild_section_general (ptr
, file
, callback
, data
);
538 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
541 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
544 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
545 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
548 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
, data
);
551 skip
= !match_simple_wild (wildsec2
->spec
.name
, sname
);
553 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
561 walk_wild_section_specs4_wild2 (lang_wild_statement_type
*ptr
,
562 lang_input_statement_type
*file
,
567 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
568 struct wildcard_list
*sec1
= ptr
->handler_data
[1];
569 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
570 struct wildcard_list
*wildsec3
= ptr
->handler_data
[3];
571 bfd_boolean multiple_sections_found
;
572 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
), *s1
;
574 if (multiple_sections_found
)
576 walk_wild_section_general (ptr
, file
, callback
, data
);
580 s1
= find_section (file
, sec1
, &multiple_sections_found
);
581 if (multiple_sections_found
)
583 walk_wild_section_general (ptr
, file
, callback
, data
);
587 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
590 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
593 walk_wild_consider_section (ptr
, file
, s
, sec1
, callback
, data
);
596 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
597 bfd_boolean skip
= !match_simple_wild (wildsec2
->spec
.name
,
601 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
605 skip
= !match_simple_wild (wildsec3
->spec
.name
, sname
);
607 walk_wild_consider_section (ptr
, file
, s
, wildsec3
,
615 walk_wild_section (lang_wild_statement_type
*ptr
,
616 lang_input_statement_type
*file
,
620 if (file
->just_syms_flag
)
623 (*ptr
->walk_wild_section_handler
) (ptr
, file
, callback
, data
);
626 /* Returns TRUE when name1 is a wildcard spec that might match
627 something name2 can match. We're conservative: we return FALSE
628 only if the prefixes of name1 and name2 are different up to the
629 first wildcard character. */
632 wild_spec_can_overlap (const char *name1
, const char *name2
)
634 size_t prefix1_len
= strcspn (name1
, "?*[");
635 size_t prefix2_len
= strcspn (name2
, "?*[");
636 size_t min_prefix_len
;
638 /* Note that if there is no wildcard character, then we treat the
639 terminating 0 as part of the prefix. Thus ".text" won't match
640 ".text." or ".text.*", for example. */
641 if (name1
[prefix1_len
] == '\0')
643 if (name2
[prefix2_len
] == '\0')
646 min_prefix_len
= prefix1_len
< prefix2_len
? prefix1_len
: prefix2_len
;
648 return memcmp (name1
, name2
, min_prefix_len
) == 0;
651 /* Select specialized code to handle various kinds of wildcard
655 analyze_walk_wild_section_handler (lang_wild_statement_type
*ptr
)
658 int wild_name_count
= 0;
659 struct wildcard_list
*sec
;
663 ptr
->walk_wild_section_handler
= walk_wild_section_general
;
664 ptr
->handler_data
[0] = NULL
;
665 ptr
->handler_data
[1] = NULL
;
666 ptr
->handler_data
[2] = NULL
;
667 ptr
->handler_data
[3] = NULL
;
670 /* Count how many wildcard_specs there are, and how many of those
671 actually use wildcards in the name. Also, bail out if any of the
672 wildcard names are NULL. (Can this actually happen?
673 walk_wild_section used to test for it.) And bail out if any
674 of the wildcards are more complex than a simple string
675 ending in a single '*'. */
676 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
679 if (sec
->spec
.name
== NULL
)
681 if (wildcardp (sec
->spec
.name
))
684 if (!is_simple_wild (sec
->spec
.name
))
689 /* The zero-spec case would be easy to optimize but it doesn't
690 happen in practice. Likewise, more than 4 specs doesn't
691 happen in practice. */
692 if (sec_count
== 0 || sec_count
> 4)
695 /* Check that no two specs can match the same section. */
696 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
698 struct wildcard_list
*sec2
;
699 for (sec2
= sec
->next
; sec2
!= NULL
; sec2
= sec2
->next
)
701 if (wild_spec_can_overlap (sec
->spec
.name
, sec2
->spec
.name
))
706 signature
= (sec_count
<< 8) + wild_name_count
;
710 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild0
;
713 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild1
;
716 ptr
->walk_wild_section_handler
= walk_wild_section_specs2_wild1
;
719 ptr
->walk_wild_section_handler
= walk_wild_section_specs3_wild2
;
722 ptr
->walk_wild_section_handler
= walk_wild_section_specs4_wild2
;
728 /* Now fill the data array with pointers to the specs, first the
729 specs with non-wildcard names, then the specs with wildcard
730 names. It's OK to process the specs in different order from the
731 given order, because we've already determined that no section
732 will match more than one spec. */
734 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
735 if (!wildcardp (sec
->spec
.name
))
736 ptr
->handler_data
[data_counter
++] = sec
;
737 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
738 if (wildcardp (sec
->spec
.name
))
739 ptr
->handler_data
[data_counter
++] = sec
;
742 /* Handle a wild statement for a single file F. */
745 walk_wild_file (lang_wild_statement_type
*s
,
746 lang_input_statement_type
*f
,
750 if (f
->the_bfd
== NULL
751 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
752 walk_wild_section (s
, f
, callback
, data
);
757 /* This is an archive file. We must map each member of the
758 archive separately. */
759 member
= bfd_openr_next_archived_file (f
->the_bfd
, NULL
);
760 while (member
!= NULL
)
762 /* When lookup_name is called, it will call the add_symbols
763 entry point for the archive. For each element of the
764 archive which is included, BFD will call ldlang_add_file,
765 which will set the usrdata field of the member to the
766 lang_input_statement. */
767 if (member
->usrdata
!= NULL
)
769 walk_wild_section (s
, member
->usrdata
, callback
, data
);
772 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
778 walk_wild (lang_wild_statement_type
*s
, callback_t callback
, void *data
)
780 const char *file_spec
= s
->filename
;
782 if (file_spec
== NULL
)
784 /* Perform the iteration over all files in the list. */
785 LANG_FOR_EACH_INPUT_STATEMENT (f
)
787 walk_wild_file (s
, f
, callback
, data
);
790 else if (wildcardp (file_spec
))
792 LANG_FOR_EACH_INPUT_STATEMENT (f
)
794 if (fnmatch (file_spec
, f
->filename
, 0) == 0)
795 walk_wild_file (s
, f
, callback
, data
);
800 lang_input_statement_type
*f
;
802 /* Perform the iteration over a single file. */
803 f
= lookup_name (file_spec
);
805 walk_wild_file (s
, f
, callback
, data
);
809 /* lang_for_each_statement walks the parse tree and calls the provided
810 function for each node. */
813 lang_for_each_statement_worker (void (*func
) (lang_statement_union_type
*),
814 lang_statement_union_type
*s
)
816 for (; s
!= NULL
; s
= s
->header
.next
)
820 switch (s
->header
.type
)
822 case lang_constructors_statement_enum
:
823 lang_for_each_statement_worker (func
, constructor_list
.head
);
825 case lang_output_section_statement_enum
:
826 lang_for_each_statement_worker
827 (func
, s
->output_section_statement
.children
.head
);
829 case lang_wild_statement_enum
:
830 lang_for_each_statement_worker (func
,
831 s
->wild_statement
.children
.head
);
833 case lang_group_statement_enum
:
834 lang_for_each_statement_worker (func
,
835 s
->group_statement
.children
.head
);
837 case lang_data_statement_enum
:
838 case lang_reloc_statement_enum
:
839 case lang_object_symbols_statement_enum
:
840 case lang_output_statement_enum
:
841 case lang_target_statement_enum
:
842 case lang_input_section_enum
:
843 case lang_input_statement_enum
:
844 case lang_assignment_statement_enum
:
845 case lang_padding_statement_enum
:
846 case lang_address_statement_enum
:
847 case lang_fill_statement_enum
:
857 lang_for_each_statement (void (*func
) (lang_statement_union_type
*))
859 lang_for_each_statement_worker (func
, statement_list
.head
);
862 /*----------------------------------------------------------------------*/
865 lang_list_init (lang_statement_list_type
*list
)
868 list
->tail
= &list
->head
;
871 /* Build a new statement node for the parse tree. */
873 static lang_statement_union_type
*
874 new_statement (enum statement_enum type
,
876 lang_statement_list_type
*list
)
878 lang_statement_union_type
*new;
880 new = stat_alloc (size
);
881 new->header
.type
= type
;
882 new->header
.next
= NULL
;
883 lang_statement_append (list
, new, &new->header
.next
);
887 /* Build a new input file node for the language. There are several
888 ways in which we treat an input file, eg, we only look at symbols,
889 or prefix it with a -l etc.
891 We can be supplied with requests for input files more than once;
892 they may, for example be split over several lines like foo.o(.text)
893 foo.o(.data) etc, so when asked for a file we check that we haven't
894 got it already so we don't duplicate the bfd. */
896 static lang_input_statement_type
*
897 new_afile (const char *name
,
898 lang_input_file_enum_type file_type
,
900 bfd_boolean add_to_list
)
902 lang_input_statement_type
*p
;
905 p
= new_stat (lang_input_statement
, stat_ptr
);
908 p
= stat_alloc (sizeof (lang_input_statement_type
));
909 p
->header
.type
= lang_input_statement_enum
;
910 p
->header
.next
= NULL
;
913 lang_has_input_file
= TRUE
;
915 p
->sysrooted
= FALSE
;
917 if (file_type
== lang_input_file_is_l_enum
918 && name
[0] == ':' && name
[1] != '\0')
920 file_type
= lang_input_file_is_search_file_enum
;
926 case lang_input_file_is_symbols_only_enum
:
928 p
->is_archive
= FALSE
;
930 p
->local_sym_name
= name
;
931 p
->just_syms_flag
= TRUE
;
932 p
->search_dirs_flag
= FALSE
;
934 case lang_input_file_is_fake_enum
:
936 p
->is_archive
= FALSE
;
938 p
->local_sym_name
= name
;
939 p
->just_syms_flag
= FALSE
;
940 p
->search_dirs_flag
= FALSE
;
942 case lang_input_file_is_l_enum
:
943 p
->is_archive
= TRUE
;
946 p
->local_sym_name
= concat ("-l", name
, NULL
);
947 p
->just_syms_flag
= FALSE
;
948 p
->search_dirs_flag
= TRUE
;
950 case lang_input_file_is_marker_enum
:
952 p
->is_archive
= FALSE
;
954 p
->local_sym_name
= name
;
955 p
->just_syms_flag
= FALSE
;
956 p
->search_dirs_flag
= TRUE
;
958 case lang_input_file_is_search_file_enum
:
959 p
->sysrooted
= ldlang_sysrooted_script
;
961 p
->is_archive
= FALSE
;
963 p
->local_sym_name
= name
;
964 p
->just_syms_flag
= FALSE
;
965 p
->search_dirs_flag
= TRUE
;
967 case lang_input_file_is_file_enum
:
969 p
->is_archive
= FALSE
;
971 p
->local_sym_name
= name
;
972 p
->just_syms_flag
= FALSE
;
973 p
->search_dirs_flag
= FALSE
;
980 p
->next_real_file
= NULL
;
983 p
->dynamic
= config
.dynamic_link
;
984 p
->add_needed
= add_needed
;
985 p
->as_needed
= as_needed
;
986 p
->whole_archive
= whole_archive
;
988 lang_statement_append (&input_file_chain
,
989 (lang_statement_union_type
*) p
,
994 lang_input_statement_type
*
995 lang_add_input_file (const char *name
,
996 lang_input_file_enum_type file_type
,
999 return new_afile (name
, file_type
, target
, TRUE
);
1002 struct out_section_hash_entry
1004 struct bfd_hash_entry root
;
1005 lang_statement_union_type s
;
1008 /* The hash table. */
1010 static struct bfd_hash_table output_section_statement_table
;
1012 /* Support routines for the hash table used by lang_output_section_find,
1013 initialize the table, fill in an entry and remove the table. */
1015 static struct bfd_hash_entry
*
1016 output_section_statement_newfunc (struct bfd_hash_entry
*entry
,
1017 struct bfd_hash_table
*table
,
1020 lang_output_section_statement_type
**nextp
;
1021 struct out_section_hash_entry
*ret
;
1025 entry
= bfd_hash_allocate (table
, sizeof (*ret
));
1030 entry
= bfd_hash_newfunc (entry
, table
, string
);
1034 ret
= (struct out_section_hash_entry
*) entry
;
1035 memset (&ret
->s
, 0, sizeof (ret
->s
));
1036 ret
->s
.header
.type
= lang_output_section_statement_enum
;
1037 ret
->s
.output_section_statement
.subsection_alignment
= -1;
1038 ret
->s
.output_section_statement
.section_alignment
= -1;
1039 ret
->s
.output_section_statement
.block_value
= 1;
1040 lang_list_init (&ret
->s
.output_section_statement
.children
);
1041 lang_statement_append (stat_ptr
, &ret
->s
, &ret
->s
.header
.next
);
1043 /* For every output section statement added to the list, except the
1044 first one, lang_output_section_statement.tail points to the "next"
1045 field of the last element of the list. */
1046 if (lang_output_section_statement
.head
!= NULL
)
1047 ret
->s
.output_section_statement
.prev
1048 = ((lang_output_section_statement_type
*)
1049 ((char *) lang_output_section_statement
.tail
1050 - offsetof (lang_output_section_statement_type
, next
)));
1052 /* GCC's strict aliasing rules prevent us from just casting the
1053 address, so we store the pointer in a variable and cast that
1055 nextp
= &ret
->s
.output_section_statement
.next
;
1056 lang_statement_append (&lang_output_section_statement
,
1058 (lang_statement_union_type
**) nextp
);
1063 output_section_statement_table_init (void)
1065 if (!bfd_hash_table_init_n (&output_section_statement_table
,
1066 output_section_statement_newfunc
,
1067 sizeof (struct out_section_hash_entry
),
1069 einfo (_("%P%F: can not create hash table: %E\n"));
1073 output_section_statement_table_free (void)
1075 bfd_hash_table_free (&output_section_statement_table
);
1078 /* Build enough state so that the parser can build its tree. */
1083 obstack_begin (&stat_obstack
, 1000);
1085 stat_ptr
= &statement_list
;
1087 output_section_statement_table_init ();
1089 lang_list_init (stat_ptr
);
1091 lang_list_init (&input_file_chain
);
1092 lang_list_init (&lang_output_section_statement
);
1093 lang_list_init (&file_chain
);
1094 first_file
= lang_add_input_file (NULL
, lang_input_file_is_marker_enum
,
1096 abs_output_section
=
1097 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
1099 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
1101 /* The value "3" is ad-hoc, somewhat related to the expected number of
1102 DEFINED expressions in a linker script. For most default linker
1103 scripts, there are none. Why a hash table then? Well, it's somewhat
1104 simpler to re-use working machinery than using a linked list in terms
1105 of code-complexity here in ld, besides the initialization which just
1106 looks like other code here. */
1107 if (!bfd_hash_table_init_n (&lang_definedness_table
,
1108 lang_definedness_newfunc
,
1109 sizeof (struct lang_definedness_hash_entry
),
1111 einfo (_("%P%F: can not create hash table: %E\n"));
1117 output_section_statement_table_free ();
1120 /*----------------------------------------------------------------------
1121 A region is an area of memory declared with the
1122 MEMORY { name:org=exp, len=exp ... }
1125 We maintain a list of all the regions here.
1127 If no regions are specified in the script, then the default is used
1128 which is created when looked up to be the entire data space.
1130 If create is true we are creating a region inside a MEMORY block.
1131 In this case it is probably an error to create a region that has
1132 already been created. If we are not inside a MEMORY block it is
1133 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1134 and so we issue a warning. */
1136 static lang_memory_region_type
*lang_memory_region_list
;
1137 static lang_memory_region_type
**lang_memory_region_list_tail
1138 = &lang_memory_region_list
;
1140 lang_memory_region_type
*
1141 lang_memory_region_lookup (const char *const name
, bfd_boolean create
)
1143 lang_memory_region_type
*p
;
1144 lang_memory_region_type
*new;
1146 /* NAME is NULL for LMA memspecs if no region was specified. */
1150 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
1151 if (strcmp (p
->name
, name
) == 0)
1154 einfo (_("%P:%S: warning: redeclaration of memory region '%s'\n"),
1159 if (!create
&& strcmp (name
, DEFAULT_MEMORY_REGION
))
1160 einfo (_("%P:%S: warning: memory region %s not declared\n"), name
);
1162 new = stat_alloc (sizeof (lang_memory_region_type
));
1164 new->name
= xstrdup (name
);
1167 new->length
= ~(bfd_size_type
) 0;
1169 new->last_os
= NULL
;
1172 new->had_full_message
= FALSE
;
1174 *lang_memory_region_list_tail
= new;
1175 lang_memory_region_list_tail
= &new->next
;
1180 static lang_memory_region_type
*
1181 lang_memory_default (asection
*section
)
1183 lang_memory_region_type
*p
;
1185 flagword sec_flags
= section
->flags
;
1187 /* Override SEC_DATA to mean a writable section. */
1188 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
1189 sec_flags
|= SEC_DATA
;
1191 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
1193 if ((p
->flags
& sec_flags
) != 0
1194 && (p
->not_flags
& sec_flags
) == 0)
1199 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
1202 lang_output_section_statement_type
*
1203 lang_output_section_find (const char *const name
)
1205 struct out_section_hash_entry
*entry
;
1208 entry
= ((struct out_section_hash_entry
*)
1209 bfd_hash_lookup (&output_section_statement_table
, name
,
1214 hash
= entry
->root
.hash
;
1217 if (entry
->s
.output_section_statement
.constraint
!= -1)
1218 return &entry
->s
.output_section_statement
;
1219 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1221 while (entry
!= NULL
1222 && entry
->root
.hash
== hash
1223 && strcmp (name
, entry
->s
.output_section_statement
.name
) == 0);
1228 static lang_output_section_statement_type
*
1229 lang_output_section_statement_lookup_1 (const char *const name
, int constraint
)
1231 struct out_section_hash_entry
*entry
;
1232 struct out_section_hash_entry
*last_ent
;
1235 entry
= ((struct out_section_hash_entry
*)
1236 bfd_hash_lookup (&output_section_statement_table
, name
,
1240 einfo (_("%P%F: failed creating section `%s': %E\n"), name
);
1244 if (entry
->s
.output_section_statement
.name
!= NULL
)
1246 /* We have a section of this name, but it might not have the correct
1248 hash
= entry
->root
.hash
;
1251 if (entry
->s
.output_section_statement
.constraint
!= -1
1253 || (constraint
== entry
->s
.output_section_statement
.constraint
1254 && constraint
!= SPECIAL
)))
1255 return &entry
->s
.output_section_statement
;
1257 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1259 while (entry
!= NULL
1260 && entry
->root
.hash
== hash
1261 && strcmp (name
, entry
->s
.output_section_statement
.name
) == 0);
1264 = ((struct out_section_hash_entry
*)
1265 output_section_statement_newfunc (NULL
,
1266 &output_section_statement_table
,
1270 einfo (_("%P%F: failed creating section `%s': %E\n"), name
);
1273 entry
->root
= last_ent
->root
;
1274 last_ent
->root
.next
= &entry
->root
;
1277 entry
->s
.output_section_statement
.name
= name
;
1278 entry
->s
.output_section_statement
.constraint
= constraint
;
1279 return &entry
->s
.output_section_statement
;
1282 lang_output_section_statement_type
*
1283 lang_output_section_statement_lookup (const char *const name
)
1285 return lang_output_section_statement_lookup_1 (name
, 0);
1288 /* A variant of lang_output_section_find used by place_orphan.
1289 Returns the output statement that should precede a new output
1290 statement for SEC. If an exact match is found on certain flags,
1293 lang_output_section_statement_type
*
1294 lang_output_section_find_by_flags (const asection
*sec
,
1295 lang_output_section_statement_type
**exact
,
1296 lang_match_sec_type_func match_type
)
1298 lang_output_section_statement_type
*first
, *look
, *found
;
1301 /* We know the first statement on this list is *ABS*. May as well
1303 first
= &lang_output_section_statement
.head
->output_section_statement
;
1304 first
= first
->next
;
1306 /* First try for an exact match. */
1308 for (look
= first
; look
; look
= look
->next
)
1310 flags
= look
->flags
;
1311 if (look
->bfd_section
!= NULL
)
1313 flags
= look
->bfd_section
->flags
;
1314 if (match_type
&& !match_type (output_bfd
, look
->bfd_section
,
1318 flags
^= sec
->flags
;
1319 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1320 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1330 if (sec
->flags
& SEC_CODE
)
1332 /* Try for a rw code section. */
1333 for (look
= first
; look
; look
= look
->next
)
1335 flags
= look
->flags
;
1336 if (look
->bfd_section
!= NULL
)
1338 flags
= look
->bfd_section
->flags
;
1339 if (match_type
&& !match_type (output_bfd
, look
->bfd_section
,
1343 flags
^= sec
->flags
;
1344 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1345 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1349 else if (sec
->flags
& (SEC_READONLY
| SEC_THREAD_LOCAL
))
1351 /* .rodata can go after .text, .sdata2 after .rodata. */
1352 for (look
= first
; look
; look
= look
->next
)
1354 flags
= look
->flags
;
1355 if (look
->bfd_section
!= NULL
)
1357 flags
= look
->bfd_section
->flags
;
1358 if (match_type
&& !match_type (output_bfd
, look
->bfd_section
,
1362 flags
^= sec
->flags
;
1363 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1365 && !(look
->flags
& (SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1369 else if (sec
->flags
& SEC_SMALL_DATA
)
1371 /* .sdata goes after .data, .sbss after .sdata. */
1372 for (look
= first
; look
; look
= look
->next
)
1374 flags
= look
->flags
;
1375 if (look
->bfd_section
!= NULL
)
1377 flags
= look
->bfd_section
->flags
;
1378 if (match_type
&& !match_type (output_bfd
, look
->bfd_section
,
1382 flags
^= sec
->flags
;
1383 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1384 | SEC_THREAD_LOCAL
))
1385 || ((look
->flags
& SEC_SMALL_DATA
)
1386 && !(sec
->flags
& SEC_HAS_CONTENTS
)))
1390 else if (sec
->flags
& SEC_HAS_CONTENTS
)
1392 /* .data goes after .rodata. */
1393 for (look
= first
; look
; look
= look
->next
)
1395 flags
= look
->flags
;
1396 if (look
->bfd_section
!= NULL
)
1398 flags
= look
->bfd_section
->flags
;
1399 if (match_type
&& !match_type (output_bfd
, look
->bfd_section
,
1403 flags
^= sec
->flags
;
1404 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1405 | SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1411 /* .bss goes last. */
1412 for (look
= first
; look
; look
= look
->next
)
1414 flags
= look
->flags
;
1415 if (look
->bfd_section
!= NULL
)
1417 flags
= look
->bfd_section
->flags
;
1418 if (match_type
&& !match_type (output_bfd
, look
->bfd_section
,
1422 flags
^= sec
->flags
;
1423 if (!(flags
& SEC_ALLOC
))
1428 if (found
|| !match_type
)
1431 return lang_output_section_find_by_flags (sec
, NULL
, NULL
);
1434 /* Find the last output section before given output statement.
1435 Used by place_orphan. */
1438 output_prev_sec_find (lang_output_section_statement_type
*os
)
1440 lang_output_section_statement_type
*lookup
;
1442 for (lookup
= os
->prev
; lookup
!= NULL
; lookup
= lookup
->prev
)
1444 if (lookup
->constraint
== -1)
1447 if (lookup
->bfd_section
!= NULL
&& lookup
->bfd_section
->owner
!= NULL
)
1448 return lookup
->bfd_section
;
1454 lang_output_section_statement_type
*
1455 lang_insert_orphan (asection
*s
,
1456 const char *secname
,
1457 lang_output_section_statement_type
*after
,
1458 struct orphan_save
*place
,
1459 etree_type
*address
,
1460 lang_statement_list_type
*add_child
)
1462 lang_statement_list_type
*old
;
1463 lang_statement_list_type add
;
1465 lang_output_section_statement_type
*os
;
1466 lang_output_section_statement_type
**os_tail
;
1468 /* Start building a list of statements for this section.
1469 First save the current statement pointer. */
1472 /* If we have found an appropriate place for the output section
1473 statements for this orphan, add them to our own private list,
1474 inserting them later into the global statement list. */
1478 lang_list_init (stat_ptr
);
1482 if (config
.build_constructors
)
1484 /* If the name of the section is representable in C, then create
1485 symbols to mark the start and the end of the section. */
1486 for (ps
= secname
; *ps
!= '\0'; ps
++)
1487 if (! ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
1492 etree_type
*e_align
;
1494 symname
= (char *) xmalloc (ps
- secname
+ sizeof "__start_" + 1);
1495 symname
[0] = bfd_get_symbol_leading_char (output_bfd
);
1496 sprintf (symname
+ (symname
[0] != 0), "__start_%s", secname
);
1497 e_align
= exp_unop (ALIGN_K
,
1498 exp_intop ((bfd_vma
) 1 << s
->alignment_power
));
1499 lang_add_assignment (exp_assop ('=', ".", e_align
));
1500 lang_add_assignment (exp_provide (symname
,
1501 exp_nameop (NAME
, "."),
1506 if (link_info
.relocatable
|| (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
1507 address
= exp_intop (0);
1509 os_tail
= ((lang_output_section_statement_type
**)
1510 lang_output_section_statement
.tail
);
1511 os
= lang_enter_output_section_statement (secname
, address
, 0, NULL
, NULL
,
1514 if (add_child
== NULL
)
1515 add_child
= &os
->children
;
1516 lang_add_section (add_child
, s
, os
);
1518 lang_leave_output_section_statement (0, "*default*", NULL
, NULL
);
1520 if (config
.build_constructors
&& *ps
== '\0')
1524 /* lang_leave_ouput_section_statement resets stat_ptr.
1525 Put stat_ptr back where we want it. */
1529 symname
= (char *) xmalloc (ps
- secname
+ sizeof "__stop_" + 1);
1530 symname
[0] = bfd_get_symbol_leading_char (output_bfd
);
1531 sprintf (symname
+ (symname
[0] != 0), "__stop_%s", secname
);
1532 lang_add_assignment (exp_provide (symname
,
1533 exp_nameop (NAME
, "."),
1537 /* Restore the global list pointer. */
1541 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
1543 asection
*snew
, *as
;
1545 snew
= os
->bfd_section
;
1547 /* Shuffle the bfd section list to make the output file look
1548 neater. This is really only cosmetic. */
1549 if (place
->section
== NULL
1550 && after
!= (&lang_output_section_statement
.head
1551 ->output_section_statement
))
1553 asection
*bfd_section
= after
->bfd_section
;
1555 /* If the output statement hasn't been used to place any input
1556 sections (and thus doesn't have an output bfd_section),
1557 look for the closest prior output statement having an
1559 if (bfd_section
== NULL
)
1560 bfd_section
= output_prev_sec_find (after
);
1562 if (bfd_section
!= NULL
&& bfd_section
!= snew
)
1563 place
->section
= &bfd_section
->next
;
1566 if (place
->section
== NULL
)
1567 place
->section
= &output_bfd
->sections
;
1569 as
= *place
->section
;
1573 /* Put the section at the end of the list. */
1575 /* Unlink the section. */
1576 bfd_section_list_remove (output_bfd
, snew
);
1578 /* Now tack it back on in the right place. */
1579 bfd_section_list_append (output_bfd
, snew
);
1581 else if (as
!= snew
&& as
->prev
!= snew
)
1583 /* Unlink the section. */
1584 bfd_section_list_remove (output_bfd
, snew
);
1586 /* Now tack it back on in the right place. */
1587 bfd_section_list_insert_before (output_bfd
, as
, snew
);
1590 /* Save the end of this list. Further ophans of this type will
1591 follow the one we've just added. */
1592 place
->section
= &snew
->next
;
1594 /* The following is non-cosmetic. We try to put the output
1595 statements in some sort of reasonable order here, because they
1596 determine the final load addresses of the orphan sections.
1597 In addition, placing output statements in the wrong order may
1598 require extra segments. For instance, given a typical
1599 situation of all read-only sections placed in one segment and
1600 following that a segment containing all the read-write
1601 sections, we wouldn't want to place an orphan read/write
1602 section before or amongst the read-only ones. */
1603 if (add
.head
!= NULL
)
1605 lang_output_section_statement_type
*newly_added_os
;
1607 if (place
->stmt
== NULL
)
1609 lang_statement_union_type
**where
;
1610 lang_statement_union_type
**assign
= NULL
;
1611 bfd_boolean ignore_first
;
1613 /* Look for a suitable place for the new statement list.
1614 The idea is to skip over anything that might be inside
1615 a SECTIONS {} statement in a script, before we find
1616 another output_section_statement. Assignments to "dot"
1617 before an output section statement are assumed to
1618 belong to it. An exception to this rule is made for
1619 the first assignment to dot, otherwise we might put an
1620 orphan before . = . + SIZEOF_HEADERS or similar
1621 assignments that set the initial address. */
1623 ignore_first
= after
== (&lang_output_section_statement
.head
1624 ->output_section_statement
);
1625 for (where
= &after
->header
.next
;
1627 where
= &(*where
)->header
.next
)
1629 switch ((*where
)->header
.type
)
1631 case lang_assignment_statement_enum
:
1634 lang_assignment_statement_type
*ass
;
1635 ass
= &(*where
)->assignment_statement
;
1636 if (ass
->exp
->type
.node_class
!= etree_assert
1637 && ass
->exp
->assign
.dst
[0] == '.'
1638 && ass
->exp
->assign
.dst
[1] == 0
1642 ignore_first
= FALSE
;
1644 case lang_wild_statement_enum
:
1645 case lang_input_section_enum
:
1646 case lang_object_symbols_statement_enum
:
1647 case lang_fill_statement_enum
:
1648 case lang_data_statement_enum
:
1649 case lang_reloc_statement_enum
:
1650 case lang_padding_statement_enum
:
1651 case lang_constructors_statement_enum
:
1654 case lang_output_section_statement_enum
:
1658 case lang_input_statement_enum
:
1659 case lang_address_statement_enum
:
1660 case lang_target_statement_enum
:
1661 case lang_output_statement_enum
:
1662 case lang_group_statement_enum
:
1671 place
->os_tail
= &after
->next
;
1675 /* Put it after the last orphan statement we added. */
1676 *add
.tail
= *place
->stmt
;
1677 *place
->stmt
= add
.head
;
1680 /* Fix the global list pointer if we happened to tack our
1681 new list at the tail. */
1682 if (*old
->tail
== add
.head
)
1683 old
->tail
= add
.tail
;
1685 /* Save the end of this list. */
1686 place
->stmt
= add
.tail
;
1688 /* Do the same for the list of output section statements. */
1689 newly_added_os
= *os_tail
;
1691 newly_added_os
->prev
= (lang_output_section_statement_type
*)
1692 ((char *) place
->os_tail
1693 - offsetof (lang_output_section_statement_type
, next
));
1694 newly_added_os
->next
= *place
->os_tail
;
1695 if (newly_added_os
->next
!= NULL
)
1696 newly_added_os
->next
->prev
= newly_added_os
;
1697 *place
->os_tail
= newly_added_os
;
1698 place
->os_tail
= &newly_added_os
->next
;
1700 /* Fixing the global list pointer here is a little different.
1701 We added to the list in lang_enter_output_section_statement,
1702 trimmed off the new output_section_statment above when
1703 assigning *os_tail = NULL, but possibly added it back in
1704 the same place when assigning *place->os_tail. */
1705 if (*os_tail
== NULL
)
1706 lang_output_section_statement
.tail
1707 = (lang_statement_union_type
**) os_tail
;
1714 lang_map_flags (flagword flag
)
1716 if (flag
& SEC_ALLOC
)
1719 if (flag
& SEC_CODE
)
1722 if (flag
& SEC_READONLY
)
1725 if (flag
& SEC_DATA
)
1728 if (flag
& SEC_LOAD
)
1735 lang_memory_region_type
*m
;
1736 bfd_boolean dis_header_printed
= FALSE
;
1739 LANG_FOR_EACH_INPUT_STATEMENT (file
)
1743 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
1744 || file
->just_syms_flag
)
1747 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
1748 if ((s
->output_section
== NULL
1749 || s
->output_section
->owner
!= output_bfd
)
1750 && (s
->flags
& (SEC_LINKER_CREATED
| SEC_KEEP
)) == 0)
1752 if (! dis_header_printed
)
1754 fprintf (config
.map_file
, _("\nDiscarded input sections\n\n"));
1755 dis_header_printed
= TRUE
;
1758 print_input_section (s
);
1762 minfo (_("\nMemory Configuration\n\n"));
1763 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
1764 _("Name"), _("Origin"), _("Length"), _("Attributes"));
1766 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
1771 fprintf (config
.map_file
, "%-16s ", m
->name
);
1773 sprintf_vma (buf
, m
->origin
);
1774 minfo ("0x%s ", buf
);
1782 minfo ("0x%V", m
->length
);
1783 if (m
->flags
|| m
->not_flags
)
1791 lang_map_flags (m
->flags
);
1797 lang_map_flags (m
->not_flags
);
1804 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
1806 if (! link_info
.reduce_memory_overheads
)
1808 obstack_begin (&map_obstack
, 1000);
1809 for (p
= link_info
.input_bfds
; p
!= (bfd
*) NULL
; p
= p
->link_next
)
1810 bfd_map_over_sections (p
, init_map_userdata
, 0);
1811 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
1813 lang_statement_iteration
++;
1814 print_statements ();
1818 init_map_userdata (abfd
, sec
, data
)
1819 bfd
*abfd ATTRIBUTE_UNUSED
;
1821 void *data ATTRIBUTE_UNUSED
;
1823 fat_section_userdata_type
*new_data
1824 = ((fat_section_userdata_type
*) (stat_alloc
1825 (sizeof (fat_section_userdata_type
))));
1827 ASSERT (get_userdata (sec
) == NULL
);
1828 get_userdata (sec
) = new_data
;
1829 new_data
->map_symbol_def_tail
= &new_data
->map_symbol_def_head
;
1833 sort_def_symbol (hash_entry
, info
)
1834 struct bfd_link_hash_entry
*hash_entry
;
1835 void *info ATTRIBUTE_UNUSED
;
1837 if (hash_entry
->type
== bfd_link_hash_defined
1838 || hash_entry
->type
== bfd_link_hash_defweak
)
1840 struct fat_user_section_struct
*ud
;
1841 struct map_symbol_def
*def
;
1843 ud
= get_userdata (hash_entry
->u
.def
.section
);
1846 /* ??? What do we have to do to initialize this beforehand? */
1847 /* The first time we get here is bfd_abs_section... */
1848 init_map_userdata (0, hash_entry
->u
.def
.section
, 0);
1849 ud
= get_userdata (hash_entry
->u
.def
.section
);
1851 else if (!ud
->map_symbol_def_tail
)
1852 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
1854 def
= obstack_alloc (&map_obstack
, sizeof *def
);
1855 def
->entry
= hash_entry
;
1856 *(ud
->map_symbol_def_tail
) = def
;
1857 ud
->map_symbol_def_tail
= &def
->next
;
1862 /* Initialize an output section. */
1865 init_os (lang_output_section_statement_type
*s
, asection
*isec
,
1868 if (s
->bfd_section
!= NULL
)
1871 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
1872 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
1874 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
1875 if (s
->bfd_section
== NULL
)
1876 s
->bfd_section
= bfd_make_section_with_flags (output_bfd
, s
->name
,
1878 if (s
->bfd_section
== NULL
)
1880 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
1881 output_bfd
->xvec
->name
, s
->name
);
1883 s
->bfd_section
->output_section
= s
->bfd_section
;
1884 s
->bfd_section
->output_offset
= 0;
1886 if (!link_info
.reduce_memory_overheads
)
1888 fat_section_userdata_type
*new
1889 = stat_alloc (sizeof (fat_section_userdata_type
));
1890 memset (new, 0, sizeof (fat_section_userdata_type
));
1891 get_userdata (s
->bfd_section
) = new;
1894 /* If there is a base address, make sure that any sections it might
1895 mention are initialized. */
1896 if (s
->addr_tree
!= NULL
)
1897 exp_init_os (s
->addr_tree
);
1899 if (s
->load_base
!= NULL
)
1900 exp_init_os (s
->load_base
);
1902 /* If supplied an alignment, set it. */
1903 if (s
->section_alignment
!= -1)
1904 s
->bfd_section
->alignment_power
= s
->section_alignment
;
1907 bfd_init_private_section_data (isec
->owner
, isec
,
1908 output_bfd
, s
->bfd_section
,
1912 /* Make sure that all output sections mentioned in an expression are
1916 exp_init_os (etree_type
*exp
)
1918 switch (exp
->type
.node_class
)
1922 exp_init_os (exp
->assign
.src
);
1926 exp_init_os (exp
->binary
.lhs
);
1927 exp_init_os (exp
->binary
.rhs
);
1931 exp_init_os (exp
->trinary
.cond
);
1932 exp_init_os (exp
->trinary
.lhs
);
1933 exp_init_os (exp
->trinary
.rhs
);
1937 exp_init_os (exp
->assert_s
.child
);
1941 exp_init_os (exp
->unary
.child
);
1945 switch (exp
->type
.node_code
)
1951 lang_output_section_statement_type
*os
;
1953 os
= lang_output_section_find (exp
->name
.name
);
1954 if (os
!= NULL
&& os
->bfd_section
== NULL
)
1955 init_os (os
, NULL
, 0);
1966 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
1968 lang_input_statement_type
*entry
= data
;
1970 /* If we are only reading symbols from this object, then we want to
1971 discard all sections. */
1972 if (entry
->just_syms_flag
)
1974 bfd_link_just_syms (abfd
, sec
, &link_info
);
1978 if (!(abfd
->flags
& DYNAMIC
))
1979 bfd_section_already_linked (abfd
, sec
, &link_info
);
1982 /* The wild routines.
1984 These expand statements like *(.text) and foo.o to a list of
1985 explicit actions, like foo.o(.text), bar.o(.text) and
1986 foo.o(.text, .data). */
1988 /* Add SECTION to the output section OUTPUT. Do this by creating a
1989 lang_input_section statement which is placed at PTR. FILE is the
1990 input file which holds SECTION. */
1993 lang_add_section (lang_statement_list_type
*ptr
,
1995 lang_output_section_statement_type
*output
)
1997 flagword flags
= section
->flags
;
1998 bfd_boolean discard
;
2000 /* Discard sections marked with SEC_EXCLUDE. */
2001 discard
= (flags
& SEC_EXCLUDE
) != 0;
2003 /* Discard input sections which are assigned to a section named
2004 DISCARD_SECTION_NAME. */
2005 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
2008 /* Discard debugging sections if we are stripping debugging
2010 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
2011 && (flags
& SEC_DEBUGGING
) != 0)
2016 if (section
->output_section
== NULL
)
2018 /* This prevents future calls from assigning this section. */
2019 section
->output_section
= bfd_abs_section_ptr
;
2024 if (section
->output_section
== NULL
)
2027 lang_input_section_type
*new;
2030 flags
= section
->flags
;
2032 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2033 to an output section, because we want to be able to include a
2034 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2035 section (I don't know why we want to do this, but we do).
2036 build_link_order in ldwrite.c handles this case by turning
2037 the embedded SEC_NEVER_LOAD section into a fill. */
2039 flags
&= ~ SEC_NEVER_LOAD
;
2041 switch (output
->sectype
)
2043 case normal_section
:
2044 case overlay_section
:
2046 case noalloc_section
:
2047 flags
&= ~SEC_ALLOC
;
2049 case noload_section
:
2051 flags
|= SEC_NEVER_LOAD
;
2055 if (output
->bfd_section
== NULL
)
2056 init_os (output
, section
, flags
);
2058 first
= ! output
->bfd_section
->linker_has_input
;
2059 output
->bfd_section
->linker_has_input
= 1;
2061 if (!link_info
.relocatable
2062 && !stripped_excluded_sections
)
2064 asection
*s
= output
->bfd_section
->map_tail
.s
;
2065 output
->bfd_section
->map_tail
.s
= section
;
2066 section
->map_head
.s
= NULL
;
2067 section
->map_tail
.s
= s
;
2069 s
->map_head
.s
= section
;
2071 output
->bfd_section
->map_head
.s
= section
;
2074 /* Add a section reference to the list. */
2075 new = new_stat (lang_input_section
, ptr
);
2077 new->section
= section
;
2078 section
->output_section
= output
->bfd_section
;
2080 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2081 already been processed. One reason to do this is that on pe
2082 format targets, .text$foo sections go into .text and it's odd
2083 to see .text with SEC_LINK_ONCE set. */
2085 if (! link_info
.relocatable
)
2086 flags
&= ~ (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
);
2088 /* If this is not the first input section, and the SEC_READONLY
2089 flag is not currently set, then don't set it just because the
2090 input section has it set. */
2092 if (! first
&& (output
->bfd_section
->flags
& SEC_READONLY
) == 0)
2093 flags
&= ~ SEC_READONLY
;
2095 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2097 && ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2098 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2099 || ((flags
& SEC_MERGE
)
2100 && output
->bfd_section
->entsize
!= section
->entsize
)))
2102 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2103 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2106 output
->bfd_section
->flags
|= flags
;
2108 if (flags
& SEC_MERGE
)
2109 output
->bfd_section
->entsize
= section
->entsize
;
2111 /* If SEC_READONLY is not set in the input section, then clear
2112 it from the output section. */
2113 if ((section
->flags
& SEC_READONLY
) == 0)
2114 output
->bfd_section
->flags
&= ~SEC_READONLY
;
2116 /* Copy over SEC_SMALL_DATA. */
2117 if (section
->flags
& SEC_SMALL_DATA
)
2118 output
->bfd_section
->flags
|= SEC_SMALL_DATA
;
2120 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2121 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2123 if (bfd_get_arch (section
->owner
) == bfd_arch_tic54x
2124 && (section
->flags
& SEC_TIC54X_BLOCK
) != 0)
2126 output
->bfd_section
->flags
|= SEC_TIC54X_BLOCK
;
2127 /* FIXME: This value should really be obtained from the bfd... */
2128 output
->block_value
= 128;
2133 /* Handle wildcard sorting. This returns the lang_input_section which
2134 should follow the one we are going to create for SECTION and FILE,
2135 based on the sorting requirements of WILD. It returns NULL if the
2136 new section should just go at the end of the current list. */
2138 static lang_statement_union_type
*
2139 wild_sort (lang_wild_statement_type
*wild
,
2140 struct wildcard_list
*sec
,
2141 lang_input_statement_type
*file
,
2144 const char *section_name
;
2145 lang_statement_union_type
*l
;
2147 if (!wild
->filenames_sorted
2148 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
2151 section_name
= bfd_get_section_name (file
->the_bfd
, section
);
2152 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
2154 lang_input_section_type
*ls
;
2156 if (l
->header
.type
!= lang_input_section_enum
)
2158 ls
= &l
->input_section
;
2160 /* Sorting by filename takes precedence over sorting by section
2163 if (wild
->filenames_sorted
)
2165 const char *fn
, *ln
;
2169 /* The PE support for the .idata section as generated by
2170 dlltool assumes that files will be sorted by the name of
2171 the archive and then the name of the file within the
2174 if (file
->the_bfd
!= NULL
2175 && bfd_my_archive (file
->the_bfd
) != NULL
)
2177 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
2182 fn
= file
->filename
;
2186 if (bfd_my_archive (ls
->section
->owner
) != NULL
)
2188 ln
= bfd_get_filename (bfd_my_archive (ls
->section
->owner
));
2193 ln
= ls
->section
->owner
->filename
;
2197 i
= strcmp (fn
, ln
);
2206 fn
= file
->filename
;
2208 ln
= ls
->section
->owner
->filename
;
2210 i
= strcmp (fn
, ln
);
2218 /* Here either the files are not sorted by name, or we are
2219 looking at the sections for this file. */
2221 if (sec
!= NULL
&& sec
->spec
.sorted
!= none
)
2222 if (compare_section (sec
->spec
.sorted
, section
, ls
->section
) < 0)
2229 /* Expand a wild statement for a particular FILE. SECTION may be
2230 NULL, in which case it is a wild card. */
2233 output_section_callback (lang_wild_statement_type
*ptr
,
2234 struct wildcard_list
*sec
,
2236 lang_input_statement_type
*file
,
2239 lang_statement_union_type
*before
;
2241 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2242 if (unique_section_p (section
))
2245 before
= wild_sort (ptr
, sec
, file
, section
);
2247 /* Here BEFORE points to the lang_input_section which
2248 should follow the one we are about to add. If BEFORE
2249 is NULL, then the section should just go at the end
2250 of the current list. */
2253 lang_add_section (&ptr
->children
, section
,
2254 (lang_output_section_statement_type
*) output
);
2257 lang_statement_list_type list
;
2258 lang_statement_union_type
**pp
;
2260 lang_list_init (&list
);
2261 lang_add_section (&list
, section
,
2262 (lang_output_section_statement_type
*) output
);
2264 /* If we are discarding the section, LIST.HEAD will
2266 if (list
.head
!= NULL
)
2268 ASSERT (list
.head
->header
.next
== NULL
);
2270 for (pp
= &ptr
->children
.head
;
2272 pp
= &(*pp
)->header
.next
)
2273 ASSERT (*pp
!= NULL
);
2275 list
.head
->header
.next
= *pp
;
2281 /* Check if all sections in a wild statement for a particular FILE
2285 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2286 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2288 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2291 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2292 if (unique_section_p (section
))
2295 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2296 ((lang_output_section_statement_type
*) data
)->all_input_readonly
= FALSE
;
2299 /* This is passed a file name which must have been seen already and
2300 added to the statement tree. We will see if it has been opened
2301 already and had its symbols read. If not then we'll read it. */
2303 static lang_input_statement_type
*
2304 lookup_name (const char *name
)
2306 lang_input_statement_type
*search
;
2308 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
2310 search
= (lang_input_statement_type
*) search
->next_real_file
)
2312 /* Use the local_sym_name as the name of the file that has
2313 already been loaded as filename might have been transformed
2314 via the search directory lookup mechanism. */
2315 const char *filename
= search
->local_sym_name
;
2317 if (filename
!= NULL
2318 && strcmp (filename
, name
) == 0)
2323 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2324 default_target
, FALSE
);
2326 /* If we have already added this file, or this file is not real
2327 don't add this file. */
2328 if (search
->loaded
|| !search
->real
)
2331 if (! load_symbols (search
, NULL
))
2337 /* Save LIST as a list of libraries whose symbols should not be exported. */
2342 struct excluded_lib
*next
;
2344 static struct excluded_lib
*excluded_libs
;
2347 add_excluded_libs (const char *list
)
2349 const char *p
= list
, *end
;
2353 struct excluded_lib
*entry
;
2354 end
= strpbrk (p
, ",:");
2356 end
= p
+ strlen (p
);
2357 entry
= xmalloc (sizeof (*entry
));
2358 entry
->next
= excluded_libs
;
2359 entry
->name
= xmalloc (end
- p
+ 1);
2360 memcpy (entry
->name
, p
, end
- p
);
2361 entry
->name
[end
- p
] = '\0';
2362 excluded_libs
= entry
;
2370 check_excluded_libs (bfd
*abfd
)
2372 struct excluded_lib
*lib
= excluded_libs
;
2376 int len
= strlen (lib
->name
);
2377 const char *filename
= lbasename (abfd
->filename
);
2379 if (strcmp (lib
->name
, "ALL") == 0)
2381 abfd
->no_export
= TRUE
;
2385 if (strncmp (lib
->name
, filename
, len
) == 0
2386 && (filename
[len
] == '\0'
2387 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
2388 && filename
[len
+ 2] == '\0')))
2390 abfd
->no_export
= TRUE
;
2398 /* Get the symbols for an input file. */
2401 load_symbols (lang_input_statement_type
*entry
,
2402 lang_statement_list_type
*place
)
2409 ldfile_open_file (entry
);
2411 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
2412 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
2415 lang_statement_list_type
*hold
;
2416 bfd_boolean bad_load
= TRUE
;
2417 bfd_boolean save_ldlang_sysrooted_script
;
2418 bfd_boolean save_as_needed
, save_add_needed
;
2420 err
= bfd_get_error ();
2422 /* See if the emulation has some special knowledge. */
2423 if (ldemul_unrecognized_file (entry
))
2426 if (err
== bfd_error_file_ambiguously_recognized
)
2430 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
2431 einfo (_("%B: matching formats:"), entry
->the_bfd
);
2432 for (p
= matching
; *p
!= NULL
; p
++)
2436 else if (err
!= bfd_error_file_not_recognized
2438 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
2442 bfd_close (entry
->the_bfd
);
2443 entry
->the_bfd
= NULL
;
2445 /* Try to interpret the file as a linker script. */
2446 ldfile_open_command_file (entry
->filename
);
2450 save_ldlang_sysrooted_script
= ldlang_sysrooted_script
;
2451 ldlang_sysrooted_script
= entry
->sysrooted
;
2452 save_as_needed
= as_needed
;
2453 as_needed
= entry
->as_needed
;
2454 save_add_needed
= add_needed
;
2455 add_needed
= entry
->add_needed
;
2457 ldfile_assumed_script
= TRUE
;
2458 parser_input
= input_script
;
2459 /* We want to use the same -Bdynamic/-Bstatic as the one for
2461 config
.dynamic_link
= entry
->dynamic
;
2463 ldfile_assumed_script
= FALSE
;
2465 ldlang_sysrooted_script
= save_ldlang_sysrooted_script
;
2466 as_needed
= save_as_needed
;
2467 add_needed
= save_add_needed
;
2473 if (ldemul_recognized_file (entry
))
2476 /* We don't call ldlang_add_file for an archive. Instead, the
2477 add_symbols entry point will call ldlang_add_file, via the
2478 add_archive_element callback, for each element of the archive
2480 switch (bfd_get_format (entry
->the_bfd
))
2486 ldlang_add_file (entry
);
2487 if (trace_files
|| trace_file_tries
)
2488 info_msg ("%I\n", entry
);
2492 check_excluded_libs (entry
->the_bfd
);
2494 if (entry
->whole_archive
)
2497 bfd_boolean loaded
= TRUE
;
2501 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
2506 if (! bfd_check_format (member
, bfd_object
))
2508 einfo (_("%F%B: member %B in archive is not an object\n"),
2509 entry
->the_bfd
, member
);
2513 if (! ((*link_info
.callbacks
->add_archive_element
)
2514 (&link_info
, member
, "--whole-archive")))
2517 if (! bfd_link_add_symbols (member
, &link_info
))
2519 einfo (_("%F%B: could not read symbols: %E\n"), member
);
2524 entry
->loaded
= loaded
;
2530 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
2531 entry
->loaded
= TRUE
;
2533 einfo (_("%F%B: could not read symbols: %E\n"), entry
->the_bfd
);
2535 return entry
->loaded
;
2538 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
2539 may be NULL, indicating that it is a wildcard. Separate
2540 lang_input_section statements are created for each part of the
2541 expansion; they are added after the wild statement S. OUTPUT is
2542 the output section. */
2545 wild (lang_wild_statement_type
*s
,
2546 const char *target ATTRIBUTE_UNUSED
,
2547 lang_output_section_statement_type
*output
)
2549 struct wildcard_list
*sec
;
2551 if (s
->handler_data
[0]
2552 && s
->handler_data
[0]->spec
.sorted
== by_name
2553 && !s
->filenames_sorted
)
2555 lang_section_bst_type
*tree
;
2557 walk_wild (s
, output_section_callback_fast
, output
);
2562 output_section_callback_tree_to_list (s
, tree
, output
);
2567 walk_wild (s
, output_section_callback
, output
);
2569 if (default_common_section
== NULL
)
2570 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
2571 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
2573 /* Remember the section that common is going to in case we
2574 later get something which doesn't know where to put it. */
2575 default_common_section
= output
;
2580 /* Return TRUE iff target is the sought target. */
2583 get_target (const bfd_target
*target
, void *data
)
2585 const char *sought
= data
;
2587 return strcmp (target
->name
, sought
) == 0;
2590 /* Like strcpy() but convert to lower case as well. */
2593 stricpy (char *dest
, char *src
)
2597 while ((c
= *src
++) != 0)
2598 *dest
++ = TOLOWER (c
);
2603 /* Remove the first occurrence of needle (if any) in haystack
2607 strcut (char *haystack
, char *needle
)
2609 haystack
= strstr (haystack
, needle
);
2615 for (src
= haystack
+ strlen (needle
); *src
;)
2616 *haystack
++ = *src
++;
2622 /* Compare two target format name strings.
2623 Return a value indicating how "similar" they are. */
2626 name_compare (char *first
, char *second
)
2632 copy1
= xmalloc (strlen (first
) + 1);
2633 copy2
= xmalloc (strlen (second
) + 1);
2635 /* Convert the names to lower case. */
2636 stricpy (copy1
, first
);
2637 stricpy (copy2
, second
);
2639 /* Remove size and endian strings from the name. */
2640 strcut (copy1
, "big");
2641 strcut (copy1
, "little");
2642 strcut (copy2
, "big");
2643 strcut (copy2
, "little");
2645 /* Return a value based on how many characters match,
2646 starting from the beginning. If both strings are
2647 the same then return 10 * their length. */
2648 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
2649 if (copy1
[result
] == 0)
2661 /* Set by closest_target_match() below. */
2662 static const bfd_target
*winner
;
2664 /* Scan all the valid bfd targets looking for one that has the endianness
2665 requirement that was specified on the command line, and is the nearest
2666 match to the original output target. */
2669 closest_target_match (const bfd_target
*target
, void *data
)
2671 const bfd_target
*original
= data
;
2673 if (command_line
.endian
== ENDIAN_BIG
2674 && target
->byteorder
!= BFD_ENDIAN_BIG
)
2677 if (command_line
.endian
== ENDIAN_LITTLE
2678 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
2681 /* Must be the same flavour. */
2682 if (target
->flavour
!= original
->flavour
)
2685 /* If we have not found a potential winner yet, then record this one. */
2692 /* Oh dear, we now have two potential candidates for a successful match.
2693 Compare their names and choose the better one. */
2694 if (name_compare (target
->name
, original
->name
)
2695 > name_compare (winner
->name
, original
->name
))
2698 /* Keep on searching until wqe have checked them all. */
2702 /* Return the BFD target format of the first input file. */
2705 get_first_input_target (void)
2707 char *target
= NULL
;
2709 LANG_FOR_EACH_INPUT_STATEMENT (s
)
2711 if (s
->header
.type
== lang_input_statement_enum
2714 ldfile_open_file (s
);
2716 if (s
->the_bfd
!= NULL
2717 && bfd_check_format (s
->the_bfd
, bfd_object
))
2719 target
= bfd_get_target (s
->the_bfd
);
2731 lang_get_output_target (void)
2735 /* Has the user told us which output format to use? */
2736 if (output_target
!= NULL
)
2737 return output_target
;
2739 /* No - has the current target been set to something other than
2741 if (current_target
!= default_target
)
2742 return current_target
;
2744 /* No - can we determine the format of the first input file? */
2745 target
= get_first_input_target ();
2749 /* Failed - use the default output target. */
2750 return default_target
;
2753 /* Open the output file. */
2756 open_output (const char *name
)
2760 output_target
= lang_get_output_target ();
2762 /* Has the user requested a particular endianness on the command
2764 if (command_line
.endian
!= ENDIAN_UNSET
)
2766 const bfd_target
*target
;
2767 enum bfd_endian desired_endian
;
2769 /* Get the chosen target. */
2770 target
= bfd_search_for_target (get_target
, (void *) output_target
);
2772 /* If the target is not supported, we cannot do anything. */
2775 if (command_line
.endian
== ENDIAN_BIG
)
2776 desired_endian
= BFD_ENDIAN_BIG
;
2778 desired_endian
= BFD_ENDIAN_LITTLE
;
2780 /* See if the target has the wrong endianness. This should
2781 not happen if the linker script has provided big and
2782 little endian alternatives, but some scrips don't do
2784 if (target
->byteorder
!= desired_endian
)
2786 /* If it does, then see if the target provides
2787 an alternative with the correct endianness. */
2788 if (target
->alternative_target
!= NULL
2789 && (target
->alternative_target
->byteorder
== desired_endian
))
2790 output_target
= target
->alternative_target
->name
;
2793 /* Try to find a target as similar as possible to
2794 the default target, but which has the desired
2795 endian characteristic. */
2796 bfd_search_for_target (closest_target_match
,
2799 /* Oh dear - we could not find any targets that
2800 satisfy our requirements. */
2802 einfo (_("%P: warning: could not find any targets"
2803 " that match endianness requirement\n"));
2805 output_target
= winner
->name
;
2811 output
= bfd_openw (name
, output_target
);
2815 if (bfd_get_error () == bfd_error_invalid_target
)
2816 einfo (_("%P%F: target %s not found\n"), output_target
);
2818 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
2821 delete_output_file_on_failure
= TRUE
;
2823 if (! bfd_set_format (output
, bfd_object
))
2824 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
2825 if (! bfd_set_arch_mach (output
,
2826 ldfile_output_architecture
,
2827 ldfile_output_machine
))
2828 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
2830 link_info
.hash
= bfd_link_hash_table_create (output
);
2831 if (link_info
.hash
== NULL
)
2832 einfo (_("%P%F: can not create hash table: %E\n"));
2834 bfd_set_gp_size (output
, g_switch_value
);
2839 ldlang_open_output (lang_statement_union_type
*statement
)
2841 switch (statement
->header
.type
)
2843 case lang_output_statement_enum
:
2844 ASSERT (output_bfd
== NULL
);
2845 output_bfd
= open_output (statement
->output_statement
.name
);
2846 ldemul_set_output_arch ();
2847 if (config
.magic_demand_paged
&& !link_info
.relocatable
)
2848 output_bfd
->flags
|= D_PAGED
;
2850 output_bfd
->flags
&= ~D_PAGED
;
2851 if (config
.text_read_only
)
2852 output_bfd
->flags
|= WP_TEXT
;
2854 output_bfd
->flags
&= ~WP_TEXT
;
2855 if (link_info
.traditional_format
)
2856 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
2858 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
2861 case lang_target_statement_enum
:
2862 current_target
= statement
->target_statement
.target
;
2869 /* Convert between addresses in bytes and sizes in octets.
2870 For currently supported targets, octets_per_byte is always a power
2871 of two, so we can use shifts. */
2872 #define TO_ADDR(X) ((X) >> opb_shift)
2873 #define TO_SIZE(X) ((X) << opb_shift)
2875 /* Support the above. */
2876 static unsigned int opb_shift
= 0;
2881 unsigned x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2882 ldfile_output_machine
);
2885 while ((x
& 1) == 0)
2893 /* Open all the input files. */
2896 open_input_bfds (lang_statement_union_type
*s
, bfd_boolean force
)
2898 for (; s
!= NULL
; s
= s
->header
.next
)
2900 switch (s
->header
.type
)
2902 case lang_constructors_statement_enum
:
2903 open_input_bfds (constructor_list
.head
, force
);
2905 case lang_output_section_statement_enum
:
2906 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
2908 case lang_wild_statement_enum
:
2909 /* Maybe we should load the file's symbols. */
2910 if (s
->wild_statement
.filename
2911 && ! wildcardp (s
->wild_statement
.filename
))
2912 lookup_name (s
->wild_statement
.filename
);
2913 open_input_bfds (s
->wild_statement
.children
.head
, force
);
2915 case lang_group_statement_enum
:
2917 struct bfd_link_hash_entry
*undefs
;
2919 /* We must continually search the entries in the group
2920 until no new symbols are added to the list of undefined
2925 undefs
= link_info
.hash
->undefs_tail
;
2926 open_input_bfds (s
->group_statement
.children
.head
, TRUE
);
2928 while (undefs
!= link_info
.hash
->undefs_tail
);
2931 case lang_target_statement_enum
:
2932 current_target
= s
->target_statement
.target
;
2934 case lang_input_statement_enum
:
2935 if (s
->input_statement
.real
)
2937 lang_statement_list_type add
;
2939 s
->input_statement
.target
= current_target
;
2941 /* If we are being called from within a group, and this
2942 is an archive which has already been searched, then
2943 force it to be researched unless the whole archive
2944 has been loaded already. */
2946 && !s
->input_statement
.whole_archive
2947 && s
->input_statement
.loaded
2948 && bfd_check_format (s
->input_statement
.the_bfd
,
2950 s
->input_statement
.loaded
= FALSE
;
2952 lang_list_init (&add
);
2954 if (! load_symbols (&s
->input_statement
, &add
))
2955 config
.make_executable
= FALSE
;
2957 if (add
.head
!= NULL
)
2959 *add
.tail
= s
->header
.next
;
2960 s
->header
.next
= add
.head
;
2970 /* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions. */
2973 lang_track_definedness (const char *name
)
2975 if (bfd_hash_lookup (&lang_definedness_table
, name
, TRUE
, FALSE
) == NULL
)
2976 einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name
);
2979 /* New-function for the definedness hash table. */
2981 static struct bfd_hash_entry
*
2982 lang_definedness_newfunc (struct bfd_hash_entry
*entry
,
2983 struct bfd_hash_table
*table ATTRIBUTE_UNUSED
,
2984 const char *name ATTRIBUTE_UNUSED
)
2986 struct lang_definedness_hash_entry
*ret
2987 = (struct lang_definedness_hash_entry
*) entry
;
2990 ret
= (struct lang_definedness_hash_entry
*)
2991 bfd_hash_allocate (table
, sizeof (struct lang_definedness_hash_entry
));
2994 einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name
);
2996 ret
->iteration
= -1;
3000 /* Return the iteration when the definition of NAME was last updated. A
3001 value of -1 means that the symbol is not defined in the linker script
3002 or the command line, but may be defined in the linker symbol table. */
3005 lang_symbol_definition_iteration (const char *name
)
3007 struct lang_definedness_hash_entry
*defentry
3008 = (struct lang_definedness_hash_entry
*)
3009 bfd_hash_lookup (&lang_definedness_table
, name
, FALSE
, FALSE
);
3011 /* We've already created this one on the presence of DEFINED in the
3012 script, so it can't be NULL unless something is borked elsewhere in
3014 if (defentry
== NULL
)
3017 return defentry
->iteration
;
3020 /* Update the definedness state of NAME. */
3023 lang_update_definedness (const char *name
, struct bfd_link_hash_entry
*h
)
3025 struct lang_definedness_hash_entry
*defentry
3026 = (struct lang_definedness_hash_entry
*)
3027 bfd_hash_lookup (&lang_definedness_table
, name
, FALSE
, FALSE
);
3029 /* We don't keep track of symbols not tested with DEFINED. */
3030 if (defentry
== NULL
)
3033 /* If the symbol was already defined, and not from an earlier statement
3034 iteration, don't update the definedness iteration, because that'd
3035 make the symbol seem defined in the linker script at this point, and
3036 it wasn't; it was defined in some object. If we do anyway, DEFINED
3037 would start to yield false before this point and the construct "sym =
3038 DEFINED (sym) ? sym : X;" would change sym to X despite being defined
3040 if (h
->type
!= bfd_link_hash_undefined
3041 && h
->type
!= bfd_link_hash_common
3042 && h
->type
!= bfd_link_hash_new
3043 && defentry
->iteration
== -1)
3046 defentry
->iteration
= lang_statement_iteration
;
3049 /* Add the supplied name to the symbol table as an undefined reference.
3050 This is a two step process as the symbol table doesn't even exist at
3051 the time the ld command line is processed. First we put the name
3052 on a list, then, once the output file has been opened, transfer the
3053 name to the symbol table. */
3055 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3057 #define ldlang_undef_chain_list_head entry_symbol.next
3060 ldlang_add_undef (const char *const name
)
3062 ldlang_undef_chain_list_type
*new =
3063 stat_alloc (sizeof (ldlang_undef_chain_list_type
));
3065 new->next
= ldlang_undef_chain_list_head
;
3066 ldlang_undef_chain_list_head
= new;
3068 new->name
= xstrdup (name
);
3070 if (output_bfd
!= NULL
)
3071 insert_undefined (new->name
);
3074 /* Insert NAME as undefined in the symbol table. */
3077 insert_undefined (const char *name
)
3079 struct bfd_link_hash_entry
*h
;
3081 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
3083 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3084 if (h
->type
== bfd_link_hash_new
)
3086 h
->type
= bfd_link_hash_undefined
;
3087 h
->u
.undef
.abfd
= NULL
;
3088 bfd_link_add_undef (link_info
.hash
, h
);
3092 /* Run through the list of undefineds created above and place them
3093 into the linker hash table as undefined symbols belonging to the
3097 lang_place_undefineds (void)
3099 ldlang_undef_chain_list_type
*ptr
;
3101 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3102 insert_undefined (ptr
->name
);
3105 /* Check for all readonly or some readwrite sections. */
3108 check_input_sections
3109 (lang_statement_union_type
*s
,
3110 lang_output_section_statement_type
*output_section_statement
)
3112 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
3114 switch (s
->header
.type
)
3116 case lang_wild_statement_enum
:
3117 walk_wild (&s
->wild_statement
, check_section_callback
,
3118 output_section_statement
);
3119 if (! output_section_statement
->all_input_readonly
)
3122 case lang_constructors_statement_enum
:
3123 check_input_sections (constructor_list
.head
,
3124 output_section_statement
);
3125 if (! output_section_statement
->all_input_readonly
)
3128 case lang_group_statement_enum
:
3129 check_input_sections (s
->group_statement
.children
.head
,
3130 output_section_statement
);
3131 if (! output_section_statement
->all_input_readonly
)
3140 /* Update wildcard statements if needed. */
3143 update_wild_statements (lang_statement_union_type
*s
)
3145 struct wildcard_list
*sec
;
3147 switch (sort_section
)
3157 for (; s
!= NULL
; s
= s
->header
.next
)
3159 switch (s
->header
.type
)
3164 case lang_wild_statement_enum
:
3165 sec
= s
->wild_statement
.section_list
;
3166 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
3169 switch (sec
->spec
.sorted
)
3172 sec
->spec
.sorted
= sort_section
;
3175 if (sort_section
== by_alignment
)
3176 sec
->spec
.sorted
= by_name_alignment
;
3179 if (sort_section
== by_name
)
3180 sec
->spec
.sorted
= by_alignment_name
;
3188 case lang_constructors_statement_enum
:
3189 update_wild_statements (constructor_list
.head
);
3192 case lang_output_section_statement_enum
:
3193 update_wild_statements
3194 (s
->output_section_statement
.children
.head
);
3197 case lang_group_statement_enum
:
3198 update_wild_statements (s
->group_statement
.children
.head
);
3206 /* Open input files and attach to output sections. */
3209 map_input_to_output_sections
3210 (lang_statement_union_type
*s
, const char *target
,
3211 lang_output_section_statement_type
*os
)
3215 for (; s
!= NULL
; s
= s
->header
.next
)
3217 switch (s
->header
.type
)
3219 case lang_wild_statement_enum
:
3220 wild (&s
->wild_statement
, target
, os
);
3222 case lang_constructors_statement_enum
:
3223 map_input_to_output_sections (constructor_list
.head
,
3227 case lang_output_section_statement_enum
:
3228 if (s
->output_section_statement
.constraint
)
3230 if (s
->output_section_statement
.constraint
!= ONLY_IF_RW
3231 && s
->output_section_statement
.constraint
!= ONLY_IF_RO
)
3233 s
->output_section_statement
.all_input_readonly
= TRUE
;
3234 check_input_sections (s
->output_section_statement
.children
.head
,
3235 &s
->output_section_statement
);
3236 if ((s
->output_section_statement
.all_input_readonly
3237 && s
->output_section_statement
.constraint
== ONLY_IF_RW
)
3238 || (!s
->output_section_statement
.all_input_readonly
3239 && s
->output_section_statement
.constraint
== ONLY_IF_RO
))
3241 s
->output_section_statement
.constraint
= -1;
3246 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
3248 &s
->output_section_statement
);
3250 case lang_output_statement_enum
:
3252 case lang_target_statement_enum
:
3253 target
= s
->target_statement
.target
;
3255 case lang_group_statement_enum
:
3256 map_input_to_output_sections (s
->group_statement
.children
.head
,
3260 case lang_data_statement_enum
:
3261 /* Make sure that any sections mentioned in the expression
3263 exp_init_os (s
->data_statement
.exp
);
3264 flags
= SEC_HAS_CONTENTS
;
3265 /* The output section gets contents, and then we inspect for
3266 any flags set in the input script which override any ALLOC. */
3267 if (!(os
->flags
& SEC_NEVER_LOAD
))
3268 flags
|= SEC_ALLOC
| SEC_LOAD
;
3269 if (os
->bfd_section
== NULL
)
3270 init_os (os
, NULL
, flags
);
3272 os
->bfd_section
->flags
|= flags
;
3274 case lang_input_section_enum
:
3276 case lang_fill_statement_enum
:
3277 case lang_object_symbols_statement_enum
:
3278 case lang_reloc_statement_enum
:
3279 case lang_padding_statement_enum
:
3280 case lang_input_statement_enum
:
3281 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3282 init_os (os
, NULL
, 0);
3284 case lang_assignment_statement_enum
:
3285 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3286 init_os (os
, NULL
, 0);
3288 /* Make sure that any sections mentioned in the assignment
3290 exp_init_os (s
->assignment_statement
.exp
);
3292 case lang_address_statement_enum
:
3293 /* Mark the specified section with the supplied address.
3295 If this section was actually a segment marker, then the
3296 directive is ignored if the linker script explicitly
3297 processed the segment marker. Originally, the linker
3298 treated segment directives (like -Ttext on the
3299 command-line) as section directives. We honor the
3300 section directive semantics for backwards compatibilty;
3301 linker scripts that do not specifically check for
3302 SEGMENT_START automatically get the old semantics. */
3303 if (!s
->address_statement
.segment
3304 || !s
->address_statement
.segment
->used
)
3306 lang_output_section_statement_type
*aos
3307 = (lang_output_section_statement_lookup
3308 (s
->address_statement
.section_name
));
3310 if (aos
->bfd_section
== NULL
)
3311 init_os (aos
, NULL
, 0);
3312 aos
->addr_tree
= s
->address_statement
.address
;
3319 /* An output section might have been removed after its statement was
3320 added. For example, ldemul_before_allocation can remove dynamic
3321 sections if they turn out to be not needed. Clean them up here. */
3324 strip_excluded_output_sections (void)
3326 lang_output_section_statement_type
*os
;
3328 /* Run lang_size_sections (if not already done). */
3329 if (expld
.phase
!= lang_mark_phase_enum
)
3331 expld
.phase
= lang_mark_phase_enum
;
3332 expld
.dataseg
.phase
= exp_dataseg_none
;
3333 one_lang_size_sections_pass (NULL
, FALSE
);
3334 lang_reset_memory_regions ();
3337 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
3341 asection
*output_section
;
3342 bfd_boolean exclude
;
3344 if (os
->constraint
== -1)
3347 output_section
= os
->bfd_section
;
3348 if (output_section
== NULL
)
3351 exclude
= (output_section
->rawsize
== 0
3352 && (output_section
->flags
& SEC_KEEP
) == 0
3353 && !bfd_section_removed_from_list (output_bfd
,
3356 /* Some sections have not yet been sized, notably .gnu.version,
3357 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
3358 input sections, so don't drop output sections that have such
3359 input sections unless they are also marked SEC_EXCLUDE. */
3360 if (exclude
&& output_section
->map_head
.s
!= NULL
)
3364 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
3365 if ((s
->flags
& SEC_LINKER_CREATED
) != 0
3366 && (s
->flags
& SEC_EXCLUDE
) == 0)
3373 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
3374 output_section
->map_head
.link_order
= NULL
;
3375 output_section
->map_tail
.link_order
= NULL
;
3379 /* We don't set bfd_section to NULL since bfd_section of the
3380 removed output section statement may still be used. */
3381 if (!os
->section_relative_symbol
3382 && !os
->update_dot_tree
)
3384 output_section
->flags
|= SEC_EXCLUDE
;
3385 bfd_section_list_remove (output_bfd
, output_section
);
3386 output_bfd
->section_count
--;
3390 /* Stop future calls to lang_add_section from messing with map_head
3391 and map_tail link_order fields. */
3392 stripped_excluded_sections
= TRUE
;
3396 print_output_section_statement
3397 (lang_output_section_statement_type
*output_section_statement
)
3399 asection
*section
= output_section_statement
->bfd_section
;
3402 if (output_section_statement
!= abs_output_section
)
3404 minfo ("\n%s", output_section_statement
->name
);
3406 if (section
!= NULL
)
3408 print_dot
= section
->vma
;
3410 len
= strlen (output_section_statement
->name
);
3411 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
3416 while (len
< SECTION_NAME_MAP_LENGTH
)
3422 minfo ("0x%V %W", section
->vma
, section
->size
);
3424 if (section
->vma
!= section
->lma
)
3425 minfo (_(" load address 0x%V"), section
->lma
);
3431 print_statement_list (output_section_statement
->children
.head
,
3432 output_section_statement
);
3435 /* Scan for the use of the destination in the right hand side
3436 of an expression. In such cases we will not compute the
3437 correct expression, since the value of DST that is used on
3438 the right hand side will be its final value, not its value
3439 just before this expression is evaluated. */
3442 scan_for_self_assignment (const char * dst
, etree_type
* rhs
)
3444 if (rhs
== NULL
|| dst
== NULL
)
3447 switch (rhs
->type
.node_class
)
3450 return scan_for_self_assignment (dst
, rhs
->binary
.lhs
)
3451 || scan_for_self_assignment (dst
, rhs
->binary
.rhs
);
3454 return scan_for_self_assignment (dst
, rhs
->trinary
.lhs
)
3455 || scan_for_self_assignment (dst
, rhs
->trinary
.rhs
);
3458 case etree_provided
:
3460 if (strcmp (dst
, rhs
->assign
.dst
) == 0)
3462 return scan_for_self_assignment (dst
, rhs
->assign
.src
);
3465 return scan_for_self_assignment (dst
, rhs
->unary
.child
);
3469 return strcmp (dst
, rhs
->value
.str
) == 0;
3474 return strcmp (dst
, rhs
->name
.name
) == 0;
3486 print_assignment (lang_assignment_statement_type
*assignment
,
3487 lang_output_section_statement_type
*output_section
)
3491 bfd_boolean computation_is_valid
= TRUE
;
3494 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
3497 if (assignment
->exp
->type
.node_class
== etree_assert
)
3500 tree
= assignment
->exp
->assert_s
.child
;
3501 computation_is_valid
= TRUE
;
3505 const char *dst
= assignment
->exp
->assign
.dst
;
3507 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
3508 tree
= assignment
->exp
->assign
.src
;
3509 computation_is_valid
= is_dot
|| (scan_for_self_assignment (dst
, tree
) == FALSE
);
3512 exp_fold_tree (tree
, output_section
->bfd_section
, &print_dot
);
3513 if (expld
.result
.valid_p
)
3517 if (computation_is_valid
)
3519 value
= expld
.result
.value
;
3521 if (expld
.result
.section
)
3522 value
+= expld
.result
.section
->vma
;
3524 minfo ("0x%V", value
);
3530 struct bfd_link_hash_entry
*h
;
3532 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
3533 FALSE
, FALSE
, TRUE
);
3536 value
= h
->u
.def
.value
;
3538 if (expld
.result
.section
)
3539 value
+= expld
.result
.section
->vma
;
3541 minfo ("[0x%V]", value
);
3544 minfo ("[unresolved]");
3556 exp_print_tree (assignment
->exp
);
3561 print_input_statement (lang_input_statement_type
*statm
)
3563 if (statm
->filename
!= NULL
)
3565 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
3569 /* Print all symbols defined in a particular section. This is called
3570 via bfd_link_hash_traverse, or by print_all_symbols. */
3573 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
3575 asection
*sec
= ptr
;
3577 if ((hash_entry
->type
== bfd_link_hash_defined
3578 || hash_entry
->type
== bfd_link_hash_defweak
)
3579 && sec
== hash_entry
->u
.def
.section
)
3583 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
3586 (hash_entry
->u
.def
.value
3587 + hash_entry
->u
.def
.section
->output_offset
3588 + hash_entry
->u
.def
.section
->output_section
->vma
));
3590 minfo (" %T\n", hash_entry
->root
.string
);
3597 print_all_symbols (asection
*sec
)
3599 struct fat_user_section_struct
*ud
= get_userdata (sec
);
3600 struct map_symbol_def
*def
;
3605 *ud
->map_symbol_def_tail
= 0;
3606 for (def
= ud
->map_symbol_def_head
; def
; def
= def
->next
)
3607 print_one_symbol (def
->entry
, sec
);
3610 /* Print information about an input section to the map file. */
3613 print_input_section (asection
*i
)
3615 bfd_size_type size
= i
->size
;
3622 minfo ("%s", i
->name
);
3624 len
= 1 + strlen (i
->name
);
3625 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
3630 while (len
< SECTION_NAME_MAP_LENGTH
)
3636 if (i
->output_section
!= NULL
&& i
->output_section
->owner
== output_bfd
)
3637 addr
= i
->output_section
->vma
+ i
->output_offset
;
3644 minfo ("0x%V %W %B\n", addr
, TO_ADDR (size
), i
->owner
);
3646 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
3648 len
= SECTION_NAME_MAP_LENGTH
+ 3;
3660 minfo (_("%W (size before relaxing)\n"), i
->rawsize
);
3663 if (i
->output_section
!= NULL
&& i
->output_section
->owner
== output_bfd
)
3665 if (link_info
.reduce_memory_overheads
)
3666 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, i
);
3668 print_all_symbols (i
);
3670 print_dot
= addr
+ TO_ADDR (size
);
3675 print_fill_statement (lang_fill_statement_type
*fill
)
3679 fputs (" FILL mask 0x", config
.map_file
);
3680 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
3681 fprintf (config
.map_file
, "%02x", *p
);
3682 fputs ("\n", config
.map_file
);
3686 print_data_statement (lang_data_statement_type
*data
)
3694 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
3697 addr
= data
->output_offset
;
3698 if (data
->output_section
!= NULL
)
3699 addr
+= data
->output_section
->vma
;
3727 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
3729 if (data
->exp
->type
.node_class
!= etree_value
)
3732 exp_print_tree (data
->exp
);
3737 print_dot
= addr
+ TO_ADDR (size
);
3740 /* Print an address statement. These are generated by options like
3744 print_address_statement (lang_address_statement_type
*address
)
3746 minfo (_("Address of section %s set to "), address
->section_name
);
3747 exp_print_tree (address
->address
);
3751 /* Print a reloc statement. */
3754 print_reloc_statement (lang_reloc_statement_type
*reloc
)
3761 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
3764 addr
= reloc
->output_offset
;
3765 if (reloc
->output_section
!= NULL
)
3766 addr
+= reloc
->output_section
->vma
;
3768 size
= bfd_get_reloc_size (reloc
->howto
);
3770 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
3772 if (reloc
->name
!= NULL
)
3773 minfo ("%s+", reloc
->name
);
3775 minfo ("%s+", reloc
->section
->name
);
3777 exp_print_tree (reloc
->addend_exp
);
3781 print_dot
= addr
+ TO_ADDR (size
);
3785 print_padding_statement (lang_padding_statement_type
*s
)
3793 len
= sizeof " *fill*" - 1;
3794 while (len
< SECTION_NAME_MAP_LENGTH
)
3800 addr
= s
->output_offset
;
3801 if (s
->output_section
!= NULL
)
3802 addr
+= s
->output_section
->vma
;
3803 minfo ("0x%V %W ", addr
, (bfd_vma
) s
->size
);
3805 if (s
->fill
->size
!= 0)
3809 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
3810 fprintf (config
.map_file
, "%02x", *p
);
3815 print_dot
= addr
+ TO_ADDR (s
->size
);
3819 print_wild_statement (lang_wild_statement_type
*w
,
3820 lang_output_section_statement_type
*os
)
3822 struct wildcard_list
*sec
;
3826 if (w
->filenames_sorted
)
3828 if (w
->filename
!= NULL
)
3829 minfo ("%s", w
->filename
);
3832 if (w
->filenames_sorted
)
3836 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
3838 if (sec
->spec
.sorted
)
3840 if (sec
->spec
.exclude_name_list
!= NULL
)
3843 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
3844 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
3845 minfo (" %s", tmp
->name
);
3848 if (sec
->spec
.name
!= NULL
)
3849 minfo ("%s", sec
->spec
.name
);
3852 if (sec
->spec
.sorted
)
3861 print_statement_list (w
->children
.head
, os
);
3864 /* Print a group statement. */
3867 print_group (lang_group_statement_type
*s
,
3868 lang_output_section_statement_type
*os
)
3870 fprintf (config
.map_file
, "START GROUP\n");
3871 print_statement_list (s
->children
.head
, os
);
3872 fprintf (config
.map_file
, "END GROUP\n");
3875 /* Print the list of statements in S.
3876 This can be called for any statement type. */
3879 print_statement_list (lang_statement_union_type
*s
,
3880 lang_output_section_statement_type
*os
)
3884 print_statement (s
, os
);
3889 /* Print the first statement in statement list S.
3890 This can be called for any statement type. */
3893 print_statement (lang_statement_union_type
*s
,
3894 lang_output_section_statement_type
*os
)
3896 switch (s
->header
.type
)
3899 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
3902 case lang_constructors_statement_enum
:
3903 if (constructor_list
.head
!= NULL
)
3905 if (constructors_sorted
)
3906 minfo (" SORT (CONSTRUCTORS)\n");
3908 minfo (" CONSTRUCTORS\n");
3909 print_statement_list (constructor_list
.head
, os
);
3912 case lang_wild_statement_enum
:
3913 print_wild_statement (&s
->wild_statement
, os
);
3915 case lang_address_statement_enum
:
3916 print_address_statement (&s
->address_statement
);
3918 case lang_object_symbols_statement_enum
:
3919 minfo (" CREATE_OBJECT_SYMBOLS\n");
3921 case lang_fill_statement_enum
:
3922 print_fill_statement (&s
->fill_statement
);
3924 case lang_data_statement_enum
:
3925 print_data_statement (&s
->data_statement
);
3927 case lang_reloc_statement_enum
:
3928 print_reloc_statement (&s
->reloc_statement
);
3930 case lang_input_section_enum
:
3931 print_input_section (s
->input_section
.section
);
3933 case lang_padding_statement_enum
:
3934 print_padding_statement (&s
->padding_statement
);
3936 case lang_output_section_statement_enum
:
3937 print_output_section_statement (&s
->output_section_statement
);
3939 case lang_assignment_statement_enum
:
3940 print_assignment (&s
->assignment_statement
, os
);
3942 case lang_target_statement_enum
:
3943 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
3945 case lang_output_statement_enum
:
3946 minfo ("OUTPUT(%s", s
->output_statement
.name
);
3947 if (output_target
!= NULL
)
3948 minfo (" %s", output_target
);
3951 case lang_input_statement_enum
:
3952 print_input_statement (&s
->input_statement
);
3954 case lang_group_statement_enum
:
3955 print_group (&s
->group_statement
, os
);
3961 print_statements (void)
3963 print_statement_list (statement_list
.head
, abs_output_section
);
3966 /* Print the first N statements in statement list S to STDERR.
3967 If N == 0, nothing is printed.
3968 If N < 0, the entire list is printed.
3969 Intended to be called from GDB. */
3972 dprint_statement (lang_statement_union_type
*s
, int n
)
3974 FILE *map_save
= config
.map_file
;
3976 config
.map_file
= stderr
;
3979 print_statement_list (s
, abs_output_section
);
3982 while (s
&& --n
>= 0)
3984 print_statement (s
, abs_output_section
);
3989 config
.map_file
= map_save
;
3993 insert_pad (lang_statement_union_type
**ptr
,
3995 unsigned int alignment_needed
,
3996 asection
*output_section
,
3999 static fill_type zero_fill
= { 1, { 0 } };
4000 lang_statement_union_type
*pad
= NULL
;
4002 if (ptr
!= &statement_list
.head
)
4003 pad
= ((lang_statement_union_type
*)
4004 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
4006 && pad
->header
.type
== lang_padding_statement_enum
4007 && pad
->padding_statement
.output_section
== output_section
)
4009 /* Use the existing pad statement. */
4011 else if ((pad
= *ptr
) != NULL
4012 && pad
->header
.type
== lang_padding_statement_enum
4013 && pad
->padding_statement
.output_section
== output_section
)
4015 /* Use the existing pad statement. */
4019 /* Make a new padding statement, linked into existing chain. */
4020 pad
= stat_alloc (sizeof (lang_padding_statement_type
));
4021 pad
->header
.next
= *ptr
;
4023 pad
->header
.type
= lang_padding_statement_enum
;
4024 pad
->padding_statement
.output_section
= output_section
;
4027 pad
->padding_statement
.fill
= fill
;
4029 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
4030 pad
->padding_statement
.size
= alignment_needed
;
4031 output_section
->size
+= alignment_needed
;
4034 /* Work out how much this section will move the dot point. */
4038 (lang_statement_union_type
**this_ptr
,
4039 lang_output_section_statement_type
*output_section_statement
,
4043 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
4044 asection
*i
= is
->section
;
4046 if (!((lang_input_statement_type
*) i
->owner
->usrdata
)->just_syms_flag
4047 && (i
->flags
& SEC_EXCLUDE
) == 0)
4049 unsigned int alignment_needed
;
4052 /* Align this section first to the input sections requirement,
4053 then to the output section's requirement. If this alignment
4054 is greater than any seen before, then record it too. Perform
4055 the alignment by inserting a magic 'padding' statement. */
4057 if (output_section_statement
->subsection_alignment
!= -1)
4058 i
->alignment_power
= output_section_statement
->subsection_alignment
;
4060 o
= output_section_statement
->bfd_section
;
4061 if (o
->alignment_power
< i
->alignment_power
)
4062 o
->alignment_power
= i
->alignment_power
;
4064 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
4066 if (alignment_needed
!= 0)
4068 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
4069 dot
+= alignment_needed
;
4072 /* Remember where in the output section this input section goes. */
4074 i
->output_offset
= dot
- o
->vma
;
4076 /* Mark how big the output section must be to contain this now. */
4077 dot
+= TO_ADDR (i
->size
);
4078 o
->size
= TO_SIZE (dot
- o
->vma
);
4082 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
4089 sort_sections_by_lma (const void *arg1
, const void *arg2
)
4091 const asection
*sec1
= *(const asection
**) arg1
;
4092 const asection
*sec2
= *(const asection
**) arg2
;
4094 if (bfd_section_lma (sec1
->owner
, sec1
)
4095 < bfd_section_lma (sec2
->owner
, sec2
))
4097 else if (bfd_section_lma (sec1
->owner
, sec1
)
4098 > bfd_section_lma (sec2
->owner
, sec2
))
4100 else if (sec1
->id
< sec2
->id
)
4102 else if (sec1
->id
> sec2
->id
)
4108 #define IGNORE_SECTION(s) \
4109 ((s->flags & SEC_NEVER_LOAD) != 0 \
4110 || (s->flags & SEC_ALLOC) == 0 \
4111 || ((s->flags & SEC_THREAD_LOCAL) != 0 \
4112 && (s->flags & SEC_LOAD) == 0))
4114 /* Check to see if any allocated sections overlap with other allocated
4115 sections. This can happen if a linker script specifies the output
4116 section addresses of the two sections. Also check whether any memory
4117 region has overflowed. */
4120 lang_check_section_addresses (void)
4123 asection
**sections
, **spp
;
4130 lang_memory_region_type
*m
;
4132 if (bfd_count_sections (output_bfd
) <= 1)
4135 amt
= bfd_count_sections (output_bfd
) * sizeof (asection
*);
4136 sections
= xmalloc (amt
);
4138 /* Scan all sections in the output list. */
4140 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
4142 /* Only consider loadable sections with real contents. */
4143 if (IGNORE_SECTION (s
) || s
->size
== 0)
4146 sections
[count
] = s
;
4153 qsort (sections
, (size_t) count
, sizeof (asection
*),
4154 sort_sections_by_lma
);
4158 s_start
= bfd_section_lma (output_bfd
, s
);
4159 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
4160 for (count
--; count
; count
--)
4162 /* We must check the sections' LMA addresses not their VMA
4163 addresses because overlay sections can have overlapping VMAs
4164 but they must have distinct LMAs. */
4169 s_start
= bfd_section_lma (output_bfd
, s
);
4170 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
4172 /* Look for an overlap. */
4173 if (s_end
>= os_start
&& s_start
<= os_end
)
4174 einfo (_("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
4175 s
->name
, s_start
, s_end
, os
->name
, os_start
, os_end
);
4180 /* If any memory region has overflowed, report by how much.
4181 We do not issue this diagnostic for regions that had sections
4182 explicitly placed outside their bounds; os_region_check's
4183 diagnostics are adequate for that case.
4185 FIXME: It is conceivable that m->current - (m->origin + m->length)
4186 might overflow a 32-bit integer. There is, alas, no way to print
4187 a bfd_vma quantity in decimal. */
4188 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
4189 if (m
->had_full_message
)
4190 einfo (_("%X%P: region %s overflowed by %ld bytes\n"),
4191 m
->name
, (long)(m
->current
- (m
->origin
+ m
->length
)));
4195 /* Make sure the new address is within the region. We explicitly permit the
4196 current address to be at the exact end of the region when the address is
4197 non-zero, in case the region is at the end of addressable memory and the
4198 calculation wraps around. */
4201 os_region_check (lang_output_section_statement_type
*os
,
4202 lang_memory_region_type
*region
,
4206 if ((region
->current
< region
->origin
4207 || (region
->current
- region
->origin
> region
->length
))
4208 && ((region
->current
!= region
->origin
+ region
->length
)
4213 einfo (_("%X%P: address 0x%v of %B section %s"
4214 " is not within region %s\n"),
4216 os
->bfd_section
->owner
,
4217 os
->bfd_section
->name
,
4220 else if (!region
->had_full_message
)
4222 region
->had_full_message
= TRUE
;
4224 einfo (_("%X%P: %B section %s will not fit in region %s\n"),
4225 os
->bfd_section
->owner
,
4226 os
->bfd_section
->name
,
4232 /* Set the sizes for all the output sections. */
4235 lang_size_sections_1
4236 (lang_statement_union_type
*s
,
4237 lang_output_section_statement_type
*output_section_statement
,
4238 lang_statement_union_type
**prev
,
4242 bfd_boolean check_regions
)
4244 /* Size up the sections from their constituent parts. */
4245 for (; s
!= NULL
; s
= s
->header
.next
)
4247 switch (s
->header
.type
)
4249 case lang_output_section_statement_enum
:
4251 bfd_vma newdot
, after
;
4252 lang_output_section_statement_type
*os
;
4253 lang_memory_region_type
*r
;
4255 os
= &s
->output_section_statement
;
4256 if (os
->addr_tree
!= NULL
)
4258 os
->processed_vma
= FALSE
;
4259 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
4261 if (expld
.result
.valid_p
)
4262 dot
= expld
.result
.value
+ expld
.result
.section
->vma
;
4263 else if (expld
.phase
!= lang_mark_phase_enum
)
4264 einfo (_("%F%S: non constant or forward reference"
4265 " address expression for section %s\n"),
4269 if (os
->bfd_section
== NULL
)
4270 /* This section was removed or never actually created. */
4273 /* If this is a COFF shared library section, use the size and
4274 address from the input section. FIXME: This is COFF
4275 specific; it would be cleaner if there were some other way
4276 to do this, but nothing simple comes to mind. */
4277 if ((bfd_get_flavour (output_bfd
) == bfd_target_ecoff_flavour
4278 || bfd_get_flavour (output_bfd
) == bfd_target_coff_flavour
)
4279 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
4283 if (os
->children
.head
== NULL
4284 || os
->children
.head
->header
.next
!= NULL
4285 || (os
->children
.head
->header
.type
4286 != lang_input_section_enum
))
4287 einfo (_("%P%X: Internal error on COFF shared library"
4288 " section %s\n"), os
->name
);
4290 input
= os
->children
.head
->input_section
.section
;
4291 bfd_set_section_vma (os
->bfd_section
->owner
,
4293 bfd_section_vma (input
->owner
, input
));
4294 os
->bfd_section
->size
= input
->size
;
4299 if (bfd_is_abs_section (os
->bfd_section
))
4301 /* No matter what happens, an abs section starts at zero. */
4302 ASSERT (os
->bfd_section
->vma
== 0);
4308 if (os
->addr_tree
== NULL
)
4310 /* No address specified for this section, get one
4311 from the region specification. */
4312 if (os
->region
== NULL
4313 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
4314 && os
->region
->name
[0] == '*'
4315 && strcmp (os
->region
->name
,
4316 DEFAULT_MEMORY_REGION
) == 0))
4318 os
->region
= lang_memory_default (os
->bfd_section
);
4321 /* If a loadable section is using the default memory
4322 region, and some non default memory regions were
4323 defined, issue an error message. */
4325 && !IGNORE_SECTION (os
->bfd_section
)
4326 && ! link_info
.relocatable
4328 && strcmp (os
->region
->name
,
4329 DEFAULT_MEMORY_REGION
) == 0
4330 && lang_memory_region_list
!= NULL
4331 && (strcmp (lang_memory_region_list
->name
,
4332 DEFAULT_MEMORY_REGION
) != 0
4333 || lang_memory_region_list
->next
!= NULL
)
4334 && expld
.phase
!= lang_mark_phase_enum
)
4336 /* By default this is an error rather than just a
4337 warning because if we allocate the section to the
4338 default memory region we can end up creating an
4339 excessively large binary, or even seg faulting when
4340 attempting to perform a negative seek. See
4341 sources.redhat.com/ml/binutils/2003-04/msg00423.html
4342 for an example of this. This behaviour can be
4343 overridden by the using the --no-check-sections
4345 if (command_line
.check_section_addresses
)
4346 einfo (_("%P%F: error: no memory region specified"
4347 " for loadable section `%s'\n"),
4348 bfd_get_section_name (output_bfd
,
4351 einfo (_("%P: warning: no memory region specified"
4352 " for loadable section `%s'\n"),
4353 bfd_get_section_name (output_bfd
,
4357 newdot
= os
->region
->current
;
4358 align
= os
->bfd_section
->alignment_power
;
4361 align
= os
->section_alignment
;
4363 /* Align to what the section needs. */
4366 bfd_vma savedot
= newdot
;
4367 newdot
= align_power (newdot
, align
);
4369 if (newdot
!= savedot
4370 && (config
.warn_section_align
4371 || os
->addr_tree
!= NULL
)
4372 && expld
.phase
!= lang_mark_phase_enum
)
4373 einfo (_("%P: warning: changing start of section"
4374 " %s by %lu bytes\n"),
4375 os
->name
, (unsigned long) (newdot
- savedot
));
4378 bfd_set_section_vma (0, os
->bfd_section
, newdot
);
4380 os
->bfd_section
->output_offset
= 0;
4383 lang_size_sections_1 (os
->children
.head
, os
, &os
->children
.head
,
4384 os
->fill
, newdot
, relax
, check_regions
);
4386 os
->processed_vma
= TRUE
;
4388 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
4389 /* Except for some special linker created sections,
4390 no output section should change from zero size
4391 after strip_excluded_output_sections. A non-zero
4392 size on an ignored section indicates that some
4393 input section was not sized early enough. */
4394 ASSERT (os
->bfd_section
->size
== 0);
4397 dot
= os
->bfd_section
->vma
;
4399 /* Put the section within the requested block size, or
4400 align at the block boundary. */
4402 + TO_ADDR (os
->bfd_section
->size
)
4403 + os
->block_value
- 1)
4404 & - (bfd_vma
) os
->block_value
);
4406 os
->bfd_section
->size
= TO_SIZE (after
- os
->bfd_section
->vma
);
4409 /* Set section lma. */
4412 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
4416 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
4417 os
->bfd_section
->lma
= lma
;
4419 else if (os
->region
!= NULL
4420 && os
->lma_region
!= NULL
4421 && os
->lma_region
!= os
->region
)
4423 bfd_vma lma
= os
->lma_region
->current
;
4425 if (os
->section_alignment
!= -1)
4426 lma
= align_power (lma
, os
->section_alignment
);
4427 os
->bfd_section
->lma
= lma
;
4429 else if (r
->last_os
!= NULL
4430 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
4435 last
= r
->last_os
->output_section_statement
.bfd_section
;
4437 /* A backwards move of dot should be accompanied by
4438 an explicit assignment to the section LMA (ie.
4439 os->load_base set) because backwards moves can
4440 create overlapping LMAs. */
4442 && os
->bfd_section
->size
!= 0
4443 && dot
+ os
->bfd_section
->size
<= last
->vma
)
4445 /* If dot moved backwards then leave lma equal to
4446 vma. This is the old default lma, which might
4447 just happen to work when the backwards move is
4448 sufficiently large. Nag if this changes anything,
4449 so people can fix their linker scripts. */
4451 if (last
->vma
!= last
->lma
)
4452 einfo (_("%P: warning: dot moved backwards before `%s'\n"),
4457 /* If this is an overlay, set the current lma to that
4458 at the end of the previous section. */
4459 if (os
->sectype
== overlay_section
)
4460 lma
= last
->lma
+ last
->size
;
4462 /* Otherwise, keep the same lma to vma relationship
4463 as the previous section. */
4465 lma
= dot
+ last
->lma
- last
->vma
;
4467 if (os
->section_alignment
!= -1)
4468 lma
= align_power (lma
, os
->section_alignment
);
4469 os
->bfd_section
->lma
= lma
;
4472 os
->processed_lma
= TRUE
;
4474 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
4477 /* Keep track of normal sections using the default
4478 lma region. We use this to set the lma for
4479 following sections. Overlays or other linker
4480 script assignment to lma might mean that the
4481 default lma == vma is incorrect.
4482 To avoid warnings about dot moving backwards when using
4483 -Ttext, don't start tracking sections until we find one
4484 of non-zero size or with lma set differently to vma. */
4485 if (((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
4486 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0)
4487 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0
4488 && (os
->bfd_section
->size
!= 0
4489 || (r
->last_os
== NULL
4490 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
4491 || (r
->last_os
!= NULL
4492 && dot
>= (r
->last_os
->output_section_statement
4493 .bfd_section
->vma
)))
4494 && os
->lma_region
== NULL
4495 && !link_info
.relocatable
)
4498 /* .tbss sections effectively have zero size. */
4499 if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
4500 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0
4501 || link_info
.relocatable
)
4502 dot
+= TO_ADDR (os
->bfd_section
->size
);
4504 if (os
->update_dot_tree
!= 0)
4505 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
4507 /* Update dot in the region ?
4508 We only do this if the section is going to be allocated,
4509 since unallocated sections do not contribute to the region's
4510 overall size in memory.
4512 If the SEC_NEVER_LOAD bit is not set, it will affect the
4513 addresses of sections after it. We have to update
4515 if (os
->region
!= NULL
4516 && ((os
->bfd_section
->flags
& SEC_NEVER_LOAD
) == 0
4517 || (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))))
4519 os
->region
->current
= dot
;
4522 /* Make sure the new address is within the region. */
4523 os_region_check (os
, os
->region
, os
->addr_tree
,
4524 os
->bfd_section
->vma
);
4526 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
)
4528 os
->lma_region
->current
4529 = os
->bfd_section
->lma
+ TO_ADDR (os
->bfd_section
->size
);
4532 os_region_check (os
, os
->lma_region
, NULL
,
4533 os
->bfd_section
->lma
);
4539 case lang_constructors_statement_enum
:
4540 dot
= lang_size_sections_1 (constructor_list
.head
,
4541 output_section_statement
,
4542 &s
->wild_statement
.children
.head
,
4543 fill
, dot
, relax
, check_regions
);
4546 case lang_data_statement_enum
:
4548 unsigned int size
= 0;
4550 s
->data_statement
.output_offset
=
4551 dot
- output_section_statement
->bfd_section
->vma
;
4552 s
->data_statement
.output_section
=
4553 output_section_statement
->bfd_section
;
4555 /* We might refer to provided symbols in the expression, and
4556 need to mark them as needed. */
4557 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
4559 switch (s
->data_statement
.type
)
4577 if (size
< TO_SIZE ((unsigned) 1))
4578 size
= TO_SIZE ((unsigned) 1);
4579 dot
+= TO_ADDR (size
);
4580 output_section_statement
->bfd_section
->size
+= size
;
4584 case lang_reloc_statement_enum
:
4588 s
->reloc_statement
.output_offset
=
4589 dot
- output_section_statement
->bfd_section
->vma
;
4590 s
->reloc_statement
.output_section
=
4591 output_section_statement
->bfd_section
;
4592 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
4593 dot
+= TO_ADDR (size
);
4594 output_section_statement
->bfd_section
->size
+= size
;
4598 case lang_wild_statement_enum
:
4599 dot
= lang_size_sections_1 (s
->wild_statement
.children
.head
,
4600 output_section_statement
,
4601 &s
->wild_statement
.children
.head
,
4602 fill
, dot
, relax
, check_regions
);
4605 case lang_object_symbols_statement_enum
:
4606 link_info
.create_object_symbols_section
=
4607 output_section_statement
->bfd_section
;
4610 case lang_output_statement_enum
:
4611 case lang_target_statement_enum
:
4614 case lang_input_section_enum
:
4618 i
= (*prev
)->input_section
.section
;
4623 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
4624 einfo (_("%P%F: can't relax section: %E\n"));
4628 dot
= size_input_section (prev
, output_section_statement
,
4629 output_section_statement
->fill
, dot
);
4633 case lang_input_statement_enum
:
4636 case lang_fill_statement_enum
:
4637 s
->fill_statement
.output_section
=
4638 output_section_statement
->bfd_section
;
4640 fill
= s
->fill_statement
.fill
;
4643 case lang_assignment_statement_enum
:
4645 bfd_vma newdot
= dot
;
4646 etree_type
*tree
= s
->assignment_statement
.exp
;
4648 expld
.dataseg
.relro
= exp_dataseg_relro_none
;
4650 exp_fold_tree (tree
,
4651 output_section_statement
->bfd_section
,
4654 if (expld
.dataseg
.relro
== exp_dataseg_relro_start
)
4656 if (!expld
.dataseg
.relro_start_stat
)
4657 expld
.dataseg
.relro_start_stat
= s
;
4660 ASSERT (expld
.dataseg
.relro_start_stat
== s
);
4663 else if (expld
.dataseg
.relro
== exp_dataseg_relro_end
)
4665 if (!expld
.dataseg
.relro_end_stat
)
4666 expld
.dataseg
.relro_end_stat
= s
;
4669 ASSERT (expld
.dataseg
.relro_end_stat
== s
);
4672 expld
.dataseg
.relro
= exp_dataseg_relro_none
;
4674 /* This symbol is relative to this section. */
4675 if ((tree
->type
.node_class
== etree_provided
4676 || tree
->type
.node_class
== etree_assign
)
4677 && (tree
->assign
.dst
[0] != '.'
4678 || tree
->assign
.dst
[1] != '\0'))
4679 output_section_statement
->section_relative_symbol
= 1;
4681 if (!output_section_statement
->ignored
)
4683 if (output_section_statement
== abs_output_section
)
4685 /* If we don't have an output section, then just adjust
4686 the default memory address. */
4687 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
4688 FALSE
)->current
= newdot
;
4690 else if (newdot
!= dot
)
4692 /* Insert a pad after this statement. We can't
4693 put the pad before when relaxing, in case the
4694 assignment references dot. */
4695 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
4696 output_section_statement
->bfd_section
, dot
);
4698 /* Don't neuter the pad below when relaxing. */
4701 /* If dot is advanced, this implies that the section
4702 should have space allocated to it, unless the
4703 user has explicitly stated that the section
4704 should never be loaded. */
4705 if (!(output_section_statement
->flags
4706 & (SEC_NEVER_LOAD
| SEC_ALLOC
)))
4707 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
4714 case lang_padding_statement_enum
:
4715 /* If this is the first time lang_size_sections is called,
4716 we won't have any padding statements. If this is the
4717 second or later passes when relaxing, we should allow
4718 padding to shrink. If padding is needed on this pass, it
4719 will be added back in. */
4720 s
->padding_statement
.size
= 0;
4722 /* Make sure output_offset is valid. If relaxation shrinks
4723 the section and this pad isn't needed, it's possible to
4724 have output_offset larger than the final size of the
4725 section. bfd_set_section_contents will complain even for
4726 a pad size of zero. */
4727 s
->padding_statement
.output_offset
4728 = dot
- output_section_statement
->bfd_section
->vma
;
4731 case lang_group_statement_enum
:
4732 dot
= lang_size_sections_1 (s
->group_statement
.children
.head
,
4733 output_section_statement
,
4734 &s
->group_statement
.children
.head
,
4735 fill
, dot
, relax
, check_regions
);
4742 /* We can only get here when relaxing is turned on. */
4743 case lang_address_statement_enum
:
4746 prev
= &s
->header
.next
;
4751 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
4752 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
4753 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
4754 segments. We are allowed an opportunity to override this decision. */
4757 ldlang_override_segment_assignment (struct bfd_link_info
* info ATTRIBUTE_UNUSED
,
4758 bfd
* abfd ATTRIBUTE_UNUSED
,
4759 asection
* current_section
,
4760 asection
* previous_section
,
4761 bfd_boolean new_segment
)
4763 lang_output_section_statement_type
* cur
;
4764 lang_output_section_statement_type
* prev
;
4766 /* The checks below are only necessary when the BFD library has decided
4767 that the two sections ought to be placed into the same segment. */
4771 /* Paranoia checks. */
4772 if (current_section
== NULL
|| previous_section
== NULL
)
4775 /* Find the memory regions associated with the two sections.
4776 We call lang_output_section_find() here rather than scanning the list
4777 of output sections looking for a matching section pointer because if
4778 we have a large number of sections then a hash lookup is faster. */
4779 cur
= lang_output_section_find (current_section
->name
);
4780 prev
= lang_output_section_find (previous_section
->name
);
4782 /* More paranoia. */
4783 if (cur
== NULL
|| prev
== NULL
)
4786 /* If the regions are different then force the sections to live in
4787 different segments. See the email thread starting at the following
4788 URL for the reasons why this is necessary:
4789 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
4790 return cur
->region
!= prev
->region
;
4794 one_lang_size_sections_pass (bfd_boolean
*relax
, bfd_boolean check_regions
)
4796 lang_statement_iteration
++;
4797 lang_size_sections_1 (statement_list
.head
, abs_output_section
,
4798 &statement_list
.head
, 0, 0, relax
, check_regions
);
4802 lang_size_sections (bfd_boolean
*relax
, bfd_boolean check_regions
)
4804 expld
.phase
= lang_allocating_phase_enum
;
4805 expld
.dataseg
.phase
= exp_dataseg_none
;
4807 one_lang_size_sections_pass (relax
, check_regions
);
4808 if (expld
.dataseg
.phase
== exp_dataseg_end_seen
4809 && link_info
.relro
&& expld
.dataseg
.relro_end
)
4811 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try
4812 to put expld.dataseg.relro on a (common) page boundary. */
4813 bfd_vma old_min_base
, relro_end
, maxpage
;
4815 expld
.dataseg
.phase
= exp_dataseg_relro_adjust
;
4816 old_min_base
= expld
.dataseg
.min_base
;
4817 maxpage
= expld
.dataseg
.maxpagesize
;
4818 expld
.dataseg
.base
+= (-expld
.dataseg
.relro_end
4819 & (expld
.dataseg
.pagesize
- 1));
4820 /* Compute the expected PT_GNU_RELRO segment end. */
4821 relro_end
= (expld
.dataseg
.relro_end
+ expld
.dataseg
.pagesize
- 1)
4822 & ~(expld
.dataseg
.pagesize
- 1);
4823 if (old_min_base
+ maxpage
< expld
.dataseg
.base
)
4825 expld
.dataseg
.base
-= maxpage
;
4826 relro_end
-= maxpage
;
4828 lang_reset_memory_regions ();
4829 one_lang_size_sections_pass (relax
, check_regions
);
4830 if (expld
.dataseg
.relro_end
> relro_end
)
4832 /* The alignment of sections between DATA_SEGMENT_ALIGN
4833 and DATA_SEGMENT_RELRO_END caused huge padding to be
4834 inserted at DATA_SEGMENT_RELRO_END. Try some other base. */
4836 unsigned int max_alignment_power
= 0;
4838 /* Find maximum alignment power of sections between
4839 DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END. */
4840 for (sec
= output_bfd
->sections
; sec
; sec
= sec
->next
)
4841 if (sec
->vma
>= expld
.dataseg
.base
4842 && sec
->vma
< expld
.dataseg
.relro_end
4843 && sec
->alignment_power
> max_alignment_power
)
4844 max_alignment_power
= sec
->alignment_power
;
4846 if (((bfd_vma
) 1 << max_alignment_power
) < expld
.dataseg
.pagesize
)
4848 if (expld
.dataseg
.base
- (1 << max_alignment_power
)
4850 expld
.dataseg
.base
+= expld
.dataseg
.pagesize
;
4851 expld
.dataseg
.base
-= (1 << max_alignment_power
);
4852 lang_reset_memory_regions ();
4853 one_lang_size_sections_pass (relax
, check_regions
);
4856 link_info
.relro_start
= expld
.dataseg
.base
;
4857 link_info
.relro_end
= expld
.dataseg
.relro_end
;
4859 else if (expld
.dataseg
.phase
== exp_dataseg_end_seen
)
4861 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
4862 a page could be saved in the data segment. */
4863 bfd_vma first
, last
;
4865 first
= -expld
.dataseg
.base
& (expld
.dataseg
.pagesize
- 1);
4866 last
= expld
.dataseg
.end
& (expld
.dataseg
.pagesize
- 1);
4868 && ((expld
.dataseg
.base
& ~(expld
.dataseg
.pagesize
- 1))
4869 != (expld
.dataseg
.end
& ~(expld
.dataseg
.pagesize
- 1)))
4870 && first
+ last
<= expld
.dataseg
.pagesize
)
4872 expld
.dataseg
.phase
= exp_dataseg_adjust
;
4873 lang_reset_memory_regions ();
4874 one_lang_size_sections_pass (relax
, check_regions
);
4878 expld
.phase
= lang_final_phase_enum
;
4881 /* Worker function for lang_do_assignments. Recursiveness goes here. */
4884 lang_do_assignments_1 (lang_statement_union_type
*s
,
4885 lang_output_section_statement_type
*current_os
,
4889 for (; s
!= NULL
; s
= s
->header
.next
)
4891 switch (s
->header
.type
)
4893 case lang_constructors_statement_enum
:
4894 dot
= lang_do_assignments_1 (constructor_list
.head
,
4895 current_os
, fill
, dot
);
4898 case lang_output_section_statement_enum
:
4900 lang_output_section_statement_type
*os
;
4902 os
= &(s
->output_section_statement
);
4903 if (os
->bfd_section
!= NULL
&& !os
->ignored
)
4905 dot
= os
->bfd_section
->vma
;
4907 lang_do_assignments_1 (os
->children
.head
, os
, os
->fill
, dot
);
4909 /* .tbss sections effectively have zero size. */
4910 if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
4911 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0
4912 || link_info
.relocatable
)
4913 dot
+= TO_ADDR (os
->bfd_section
->size
);
4918 case lang_wild_statement_enum
:
4920 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
4921 current_os
, fill
, dot
);
4924 case lang_object_symbols_statement_enum
:
4925 case lang_output_statement_enum
:
4926 case lang_target_statement_enum
:
4929 case lang_data_statement_enum
:
4930 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
4931 if (expld
.result
.valid_p
)
4932 s
->data_statement
.value
= (expld
.result
.value
4933 + expld
.result
.section
->vma
);
4935 einfo (_("%F%P: invalid data statement\n"));
4938 switch (s
->data_statement
.type
)
4956 if (size
< TO_SIZE ((unsigned) 1))
4957 size
= TO_SIZE ((unsigned) 1);
4958 dot
+= TO_ADDR (size
);
4962 case lang_reloc_statement_enum
:
4963 exp_fold_tree (s
->reloc_statement
.addend_exp
,
4964 bfd_abs_section_ptr
, &dot
);
4965 if (expld
.result
.valid_p
)
4966 s
->reloc_statement
.addend_value
= expld
.result
.value
;
4968 einfo (_("%F%P: invalid reloc statement\n"));
4969 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
4972 case lang_input_section_enum
:
4974 asection
*in
= s
->input_section
.section
;
4976 if ((in
->flags
& SEC_EXCLUDE
) == 0)
4977 dot
+= TO_ADDR (in
->size
);
4981 case lang_input_statement_enum
:
4984 case lang_fill_statement_enum
:
4985 fill
= s
->fill_statement
.fill
;
4988 case lang_assignment_statement_enum
:
4989 exp_fold_tree (s
->assignment_statement
.exp
,
4990 current_os
->bfd_section
,
4994 case lang_padding_statement_enum
:
4995 dot
+= TO_ADDR (s
->padding_statement
.size
);
4998 case lang_group_statement_enum
:
4999 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
5000 current_os
, fill
, dot
);
5007 case lang_address_statement_enum
:
5015 lang_do_assignments (void)
5017 lang_statement_iteration
++;
5018 lang_do_assignments_1 (statement_list
.head
, abs_output_section
, NULL
, 0);
5021 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
5022 operator .startof. (section_name), it produces an undefined symbol
5023 .startof.section_name. Similarly, when it sees
5024 .sizeof. (section_name), it produces an undefined symbol
5025 .sizeof.section_name. For all the output sections, we look for
5026 such symbols, and set them to the correct value. */
5029 lang_set_startof (void)
5033 if (link_info
.relocatable
)
5036 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5038 const char *secname
;
5040 struct bfd_link_hash_entry
*h
;
5042 secname
= bfd_get_section_name (output_bfd
, s
);
5043 buf
= xmalloc (10 + strlen (secname
));
5045 sprintf (buf
, ".startof.%s", secname
);
5046 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
5047 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
5049 h
->type
= bfd_link_hash_defined
;
5050 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, s
);
5051 h
->u
.def
.section
= bfd_abs_section_ptr
;
5054 sprintf (buf
, ".sizeof.%s", secname
);
5055 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
5056 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
5058 h
->type
= bfd_link_hash_defined
;
5059 h
->u
.def
.value
= TO_ADDR (s
->size
);
5060 h
->u
.def
.section
= bfd_abs_section_ptr
;
5070 struct bfd_link_hash_entry
*h
;
5073 if ((link_info
.relocatable
&& !link_info
.gc_sections
)
5074 || link_info
.shared
)
5075 warn
= entry_from_cmdline
;
5079 /* Force the user to specify a root when generating a relocatable with
5081 if (link_info
.gc_sections
&& link_info
.relocatable
5082 && (entry_symbol
.name
== NULL
5083 && ldlang_undef_chain_list_head
== NULL
))
5084 einfo (_("%P%F: gc-sections requires either an entry or "
5085 "an undefined symbol\n"));
5087 if (entry_symbol
.name
== NULL
)
5089 /* No entry has been specified. Look for the default entry, but
5090 don't warn if we don't find it. */
5091 entry_symbol
.name
= entry_symbol_default
;
5095 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
5096 FALSE
, FALSE
, TRUE
);
5098 && (h
->type
== bfd_link_hash_defined
5099 || h
->type
== bfd_link_hash_defweak
)
5100 && h
->u
.def
.section
->output_section
!= NULL
)
5104 val
= (h
->u
.def
.value
5105 + bfd_get_section_vma (output_bfd
,
5106 h
->u
.def
.section
->output_section
)
5107 + h
->u
.def
.section
->output_offset
);
5108 if (! bfd_set_start_address (output_bfd
, val
))
5109 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
.name
);
5116 /* We couldn't find the entry symbol. Try parsing it as a
5118 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
5121 if (! bfd_set_start_address (output_bfd
, val
))
5122 einfo (_("%P%F: can't set start address\n"));
5128 /* Can't find the entry symbol, and it's not a number. Use
5129 the first address in the text section. */
5130 ts
= bfd_get_section_by_name (output_bfd
, entry_section
);
5134 einfo (_("%P: warning: cannot find entry symbol %s;"
5135 " defaulting to %V\n"),
5137 bfd_get_section_vma (output_bfd
, ts
));
5138 if (! bfd_set_start_address (output_bfd
,
5139 bfd_get_section_vma (output_bfd
,
5141 einfo (_("%P%F: can't set start address\n"));
5146 einfo (_("%P: warning: cannot find entry symbol %s;"
5147 " not setting start address\n"),
5153 /* Don't bfd_hash_table_free (&lang_definedness_table);
5154 map file output may result in a call of lang_track_definedness. */
5157 /* This is a small function used when we want to ignore errors from
5161 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
5163 /* Don't do anything. */
5166 /* Check that the architecture of all the input files is compatible
5167 with the output file. Also call the backend to let it do any
5168 other checking that is needed. */
5173 lang_statement_union_type
*file
;
5175 const bfd_arch_info_type
*compatible
;
5177 for (file
= file_chain
.head
; file
!= NULL
; file
= file
->input_statement
.next
)
5179 input_bfd
= file
->input_statement
.the_bfd
;
5181 = bfd_arch_get_compatible (input_bfd
, output_bfd
,
5182 command_line
.accept_unknown_input_arch
);
5184 /* In general it is not possible to perform a relocatable
5185 link between differing object formats when the input
5186 file has relocations, because the relocations in the
5187 input format may not have equivalent representations in
5188 the output format (and besides BFD does not translate
5189 relocs for other link purposes than a final link). */
5190 if ((link_info
.relocatable
|| link_info
.emitrelocations
)
5191 && (compatible
== NULL
5192 || bfd_get_flavour (input_bfd
) != bfd_get_flavour (output_bfd
))
5193 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
5195 einfo (_("%P%F: Relocatable linking with relocations from"
5196 " format %s (%B) to format %s (%B) is not supported\n"),
5197 bfd_get_target (input_bfd
), input_bfd
,
5198 bfd_get_target (output_bfd
), output_bfd
);
5199 /* einfo with %F exits. */
5202 if (compatible
== NULL
)
5204 if (command_line
.warn_mismatch
)
5205 einfo (_("%P%X: %s architecture of input file `%B'"
5206 " is incompatible with %s output\n"),
5207 bfd_printable_name (input_bfd
), input_bfd
,
5208 bfd_printable_name (output_bfd
));
5210 else if (bfd_count_sections (input_bfd
))
5212 /* If the input bfd has no contents, it shouldn't set the
5213 private data of the output bfd. */
5215 bfd_error_handler_type pfn
= NULL
;
5217 /* If we aren't supposed to warn about mismatched input
5218 files, temporarily set the BFD error handler to a
5219 function which will do nothing. We still want to call
5220 bfd_merge_private_bfd_data, since it may set up
5221 information which is needed in the output file. */
5222 if (! command_line
.warn_mismatch
)
5223 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
5224 if (! bfd_merge_private_bfd_data (input_bfd
, output_bfd
))
5226 if (command_line
.warn_mismatch
)
5227 einfo (_("%P%X: failed to merge target specific data"
5228 " of file %B\n"), input_bfd
);
5230 if (! command_line
.warn_mismatch
)
5231 bfd_set_error_handler (pfn
);
5236 /* Look through all the global common symbols and attach them to the
5237 correct section. The -sort-common command line switch may be used
5238 to roughly sort the entries by size. */
5243 if (command_line
.inhibit_common_definition
)
5245 if (link_info
.relocatable
5246 && ! command_line
.force_common_definition
)
5249 if (! config
.sort_common
)
5250 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
5255 for (power
= 4; power
>= 0; power
--)
5256 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
5260 /* Place one common symbol in the correct section. */
5263 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
5265 unsigned int power_of_two
;
5269 if (h
->type
!= bfd_link_hash_common
)
5273 power_of_two
= h
->u
.c
.p
->alignment_power
;
5275 if (config
.sort_common
5276 && power_of_two
< (unsigned int) *(int *) info
)
5279 section
= h
->u
.c
.p
->section
;
5281 /* Increase the size of the section to align the common sym. */
5282 section
->size
+= ((bfd_vma
) 1 << (power_of_two
+ opb_shift
)) - 1;
5283 section
->size
&= (- (bfd_vma
) 1 << (power_of_two
+ opb_shift
));
5285 /* Adjust the alignment if necessary. */
5286 if (power_of_two
> section
->alignment_power
)
5287 section
->alignment_power
= power_of_two
;
5289 /* Change the symbol from common to defined. */
5290 h
->type
= bfd_link_hash_defined
;
5291 h
->u
.def
.section
= section
;
5292 h
->u
.def
.value
= section
->size
;
5294 /* Increase the size of the section. */
5295 section
->size
+= size
;
5297 /* Make sure the section is allocated in memory, and make sure that
5298 it is no longer a common section. */
5299 section
->flags
|= SEC_ALLOC
;
5300 section
->flags
&= ~SEC_IS_COMMON
;
5302 if (config
.map_file
!= NULL
)
5304 static bfd_boolean header_printed
;
5309 if (! header_printed
)
5311 minfo (_("\nAllocating common symbols\n"));
5312 minfo (_("Common symbol size file\n\n"));
5313 header_printed
= TRUE
;
5316 name
= bfd_demangle (output_bfd
, h
->root
.string
,
5317 DMGL_ANSI
| DMGL_PARAMS
);
5320 minfo ("%s", h
->root
.string
);
5321 len
= strlen (h
->root
.string
);
5326 len
= strlen (name
);
5342 if (size
<= 0xffffffff)
5343 sprintf (buf
, "%lx", (unsigned long) size
);
5345 sprintf_vma (buf
, size
);
5355 minfo ("%B\n", section
->owner
);
5361 /* Run through the input files and ensure that every input section has
5362 somewhere to go. If one is found without a destination then create
5363 an input request and place it into the statement tree. */
5366 lang_place_orphans (void)
5368 LANG_FOR_EACH_INPUT_STATEMENT (file
)
5372 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5374 if (s
->output_section
== NULL
)
5376 /* This section of the file is not attached, root
5377 around for a sensible place for it to go. */
5379 if (file
->just_syms_flag
)
5380 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
5381 else if ((s
->flags
& SEC_EXCLUDE
) != 0)
5382 s
->output_section
= bfd_abs_section_ptr
;
5383 else if (strcmp (s
->name
, "COMMON") == 0)
5385 /* This is a lonely common section which must have
5386 come from an archive. We attach to the section
5387 with the wildcard. */
5388 if (! link_info
.relocatable
5389 || command_line
.force_common_definition
)
5391 if (default_common_section
== NULL
)
5393 default_common_section
=
5394 lang_output_section_statement_lookup (".bss");
5397 lang_add_section (&default_common_section
->children
, s
,
5398 default_common_section
);
5401 else if (ldemul_place_orphan (s
))
5405 lang_output_section_statement_type
*os
;
5407 os
= lang_output_section_statement_lookup (s
->name
);
5408 lang_add_section (&os
->children
, s
, os
);
5416 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
5418 flagword
*ptr_flags
;
5420 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
5426 *ptr_flags
|= SEC_ALLOC
;
5430 *ptr_flags
|= SEC_READONLY
;
5434 *ptr_flags
|= SEC_DATA
;
5438 *ptr_flags
|= SEC_CODE
;
5443 *ptr_flags
|= SEC_LOAD
;
5447 einfo (_("%P%F: invalid syntax in flags\n"));
5454 /* Call a function on each input file. This function will be called
5455 on an archive, but not on the elements. */
5458 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
5460 lang_input_statement_type
*f
;
5462 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
5464 f
= (lang_input_statement_type
*) f
->next_real_file
)
5468 /* Call a function on each file. The function will be called on all
5469 the elements of an archive which are included in the link, but will
5470 not be called on the archive file itself. */
5473 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
5475 LANG_FOR_EACH_INPUT_STATEMENT (f
)
5482 ldlang_add_file (lang_input_statement_type
*entry
)
5484 lang_statement_append (&file_chain
,
5485 (lang_statement_union_type
*) entry
,
5488 /* The BFD linker needs to have a list of all input BFDs involved in
5490 ASSERT (entry
->the_bfd
->link_next
== NULL
);
5491 ASSERT (entry
->the_bfd
!= output_bfd
);
5493 *link_info
.input_bfds_tail
= entry
->the_bfd
;
5494 link_info
.input_bfds_tail
= &entry
->the_bfd
->link_next
;
5495 entry
->the_bfd
->usrdata
= entry
;
5496 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
5498 /* Look through the sections and check for any which should not be
5499 included in the link. We need to do this now, so that we can
5500 notice when the backend linker tries to report multiple
5501 definition errors for symbols which are in sections we aren't
5502 going to link. FIXME: It might be better to entirely ignore
5503 symbols which are defined in sections which are going to be
5504 discarded. This would require modifying the backend linker for
5505 each backend which might set the SEC_LINK_ONCE flag. If we do
5506 this, we should probably handle SEC_EXCLUDE in the same way. */
5508 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
5512 lang_add_output (const char *name
, int from_script
)
5514 /* Make -o on command line override OUTPUT in script. */
5515 if (!had_output_filename
|| !from_script
)
5517 output_filename
= name
;
5518 had_output_filename
= TRUE
;
5522 static lang_output_section_statement_type
*current_section
;
5533 for (l
= 0; l
< 32; l
++)
5535 if (i
>= (unsigned int) x
)
5543 lang_output_section_statement_type
*
5544 lang_enter_output_section_statement (const char *output_section_statement_name
,
5545 etree_type
*address_exp
,
5546 enum section_type sectype
,
5548 etree_type
*subalign
,
5552 lang_output_section_statement_type
*os
;
5554 os
= lang_output_section_statement_lookup_1 (output_section_statement_name
,
5556 current_section
= os
;
5558 /* Make next things chain into subchain of this. */
5560 if (os
->addr_tree
== NULL
)
5562 os
->addr_tree
= address_exp
;
5564 os
->sectype
= sectype
;
5565 if (sectype
!= noload_section
)
5566 os
->flags
= SEC_NO_FLAGS
;
5568 os
->flags
= SEC_NEVER_LOAD
;
5569 os
->block_value
= 1;
5570 stat_ptr
= &os
->children
;
5572 os
->subsection_alignment
=
5573 topower (exp_get_value_int (subalign
, -1, "subsection alignment"));
5574 os
->section_alignment
=
5575 topower (exp_get_value_int (align
, -1, "section alignment"));
5577 os
->load_base
= ebase
;
5584 lang_output_statement_type
*new;
5586 new = new_stat (lang_output_statement
, stat_ptr
);
5587 new->name
= output_filename
;
5590 /* Reset the current counters in the regions. */
5593 lang_reset_memory_regions (void)
5595 lang_memory_region_type
*p
= lang_memory_region_list
;
5597 lang_output_section_statement_type
*os
;
5599 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
5601 p
->current
= p
->origin
;
5605 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
5609 os
->processed_vma
= FALSE
;
5610 os
->processed_lma
= FALSE
;
5613 for (o
= output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
5615 /* Save the last size for possible use by bfd_relax_section. */
5616 o
->rawsize
= o
->size
;
5621 /* Worker for lang_gc_sections_1. */
5624 gc_section_callback (lang_wild_statement_type
*ptr
,
5625 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
5627 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
5628 void *data ATTRIBUTE_UNUSED
)
5630 /* If the wild pattern was marked KEEP, the member sections
5631 should be as well. */
5632 if (ptr
->keep_sections
)
5633 section
->flags
|= SEC_KEEP
;
5636 /* Iterate over sections marking them against GC. */
5639 lang_gc_sections_1 (lang_statement_union_type
*s
)
5641 for (; s
!= NULL
; s
= s
->header
.next
)
5643 switch (s
->header
.type
)
5645 case lang_wild_statement_enum
:
5646 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
5648 case lang_constructors_statement_enum
:
5649 lang_gc_sections_1 (constructor_list
.head
);
5651 case lang_output_section_statement_enum
:
5652 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
5654 case lang_group_statement_enum
:
5655 lang_gc_sections_1 (s
->group_statement
.children
.head
);
5664 lang_gc_sections (void)
5666 /* Keep all sections so marked in the link script. */
5668 lang_gc_sections_1 (statement_list
.head
);
5670 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
5671 the special case of debug info. (See bfd/stabs.c)
5672 Twiddle the flag here, to simplify later linker code. */
5673 if (link_info
.relocatable
)
5675 LANG_FOR_EACH_INPUT_STATEMENT (f
)
5678 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
5679 if ((sec
->flags
& SEC_DEBUGGING
) == 0)
5680 sec
->flags
&= ~SEC_EXCLUDE
;
5684 if (link_info
.gc_sections
)
5685 bfd_gc_sections (output_bfd
, &link_info
);
5688 /* Worker for lang_find_relro_sections_1. */
5691 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
5692 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
5694 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
5697 /* Discarded, excluded and ignored sections effectively have zero
5699 if (section
->output_section
!= NULL
5700 && section
->output_section
->owner
== output_bfd
5701 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
5702 && !IGNORE_SECTION (section
)
5703 && section
->size
!= 0)
5705 bfd_boolean
*has_relro_section
= (bfd_boolean
*) data
;
5706 *has_relro_section
= TRUE
;
5710 /* Iterate over sections for relro sections. */
5713 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
5714 bfd_boolean
*has_relro_section
)
5716 if (*has_relro_section
)
5719 for (; s
!= NULL
; s
= s
->header
.next
)
5721 if (s
== expld
.dataseg
.relro_end_stat
)
5724 switch (s
->header
.type
)
5726 case lang_wild_statement_enum
:
5727 walk_wild (&s
->wild_statement
,
5728 find_relro_section_callback
,
5731 case lang_constructors_statement_enum
:
5732 lang_find_relro_sections_1 (constructor_list
.head
,
5735 case lang_output_section_statement_enum
:
5736 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
5739 case lang_group_statement_enum
:
5740 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
5750 lang_find_relro_sections (void)
5752 bfd_boolean has_relro_section
= FALSE
;
5754 /* Check all sections in the link script. */
5756 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
5757 &has_relro_section
);
5759 if (!has_relro_section
)
5760 link_info
.relro
= FALSE
;
5763 /* Relax all sections until bfd_relax_section gives up. */
5766 relax_sections (void)
5768 /* Keep relaxing until bfd_relax_section gives up. */
5769 bfd_boolean relax_again
;
5771 link_info
.relax_trip
= -1;
5774 relax_again
= FALSE
;
5775 link_info
.relax_trip
++;
5777 /* Note: pe-dll.c does something like this also. If you find
5778 you need to change this code, you probably need to change
5779 pe-dll.c also. DJ */
5781 /* Do all the assignments with our current guesses as to
5783 lang_do_assignments ();
5785 /* We must do this after lang_do_assignments, because it uses
5787 lang_reset_memory_regions ();
5789 /* Perform another relax pass - this time we know where the
5790 globals are, so can make a better guess. */
5791 lang_size_sections (&relax_again
, FALSE
);
5793 while (relax_again
);
5799 /* Finalize dynamic list. */
5800 if (link_info
.dynamic_list
)
5801 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
5803 current_target
= default_target
;
5805 /* Open the output file. */
5806 lang_for_each_statement (ldlang_open_output
);
5809 ldemul_create_output_section_statements ();
5811 /* Add to the hash table all undefineds on the command line. */
5812 lang_place_undefineds ();
5814 if (!bfd_section_already_linked_table_init ())
5815 einfo (_("%P%F: Failed to create hash table\n"));
5817 /* Create a bfd for each input file. */
5818 current_target
= default_target
;
5819 open_input_bfds (statement_list
.head
, FALSE
);
5821 link_info
.gc_sym_list
= &entry_symbol
;
5822 if (entry_symbol
.name
== NULL
)
5823 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
5825 ldemul_after_open ();
5827 bfd_section_already_linked_table_free ();
5829 /* Make sure that we're not mixing architectures. We call this
5830 after all the input files have been opened, but before we do any
5831 other processing, so that any operations merge_private_bfd_data
5832 does on the output file will be known during the rest of the
5836 /* Handle .exports instead of a version script if we're told to do so. */
5837 if (command_line
.version_exports_section
)
5838 lang_do_version_exports_section ();
5840 /* Build all sets based on the information gathered from the input
5842 ldctor_build_sets ();
5844 /* Remove unreferenced sections if asked to. */
5845 lang_gc_sections ();
5847 /* Size up the common data. */
5850 /* Update wild statements. */
5851 update_wild_statements (statement_list
.head
);
5853 /* Run through the contours of the script and attach input sections
5854 to the correct output sections. */
5855 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
5857 /* Find any sections not attached explicitly and handle them. */
5858 lang_place_orphans ();
5860 if (! link_info
.relocatable
)
5864 /* Merge SEC_MERGE sections. This has to be done after GC of
5865 sections, so that GCed sections are not merged, but before
5866 assigning dynamic symbols, since removing whole input sections
5868 bfd_merge_sections (output_bfd
, &link_info
);
5870 /* Look for a text section and set the readonly attribute in it. */
5871 found
= bfd_get_section_by_name (output_bfd
, ".text");
5875 if (config
.text_read_only
)
5876 found
->flags
|= SEC_READONLY
;
5878 found
->flags
&= ~SEC_READONLY
;
5882 /* Do anything special before sizing sections. This is where ELF
5883 and other back-ends size dynamic sections. */
5884 ldemul_before_allocation ();
5886 /* We must record the program headers before we try to fix the
5887 section positions, since they will affect SIZEOF_HEADERS. */
5888 lang_record_phdrs ();
5890 /* Check relro sections. */
5891 if (link_info
.relro
&& ! link_info
.relocatable
)
5892 lang_find_relro_sections ();
5894 /* Size up the sections. */
5895 lang_size_sections (NULL
, !command_line
.relax
);
5897 /* Now run around and relax if we can. */
5898 if (command_line
.relax
)
5900 /* We may need more than one relaxation pass. */
5901 int i
= link_info
.relax_pass
;
5903 /* The backend can use it to determine the current pass. */
5904 link_info
.relax_pass
= 0;
5909 link_info
.relax_pass
++;
5912 /* Final extra sizing to report errors. */
5913 lang_do_assignments ();
5914 lang_reset_memory_regions ();
5915 lang_size_sections (NULL
, TRUE
);
5918 /* See if anything special should be done now we know how big
5920 ldemul_after_allocation ();
5922 /* Fix any .startof. or .sizeof. symbols. */
5923 lang_set_startof ();
5925 /* Do all the assignments, now that we know the final resting places
5926 of all the symbols. */
5928 lang_do_assignments ();
5932 /* Make sure that the section addresses make sense. */
5933 if (! link_info
.relocatable
5934 && command_line
.check_section_addresses
)
5935 lang_check_section_addresses ();
5940 /* EXPORTED TO YACC */
5943 lang_add_wild (struct wildcard_spec
*filespec
,
5944 struct wildcard_list
*section_list
,
5945 bfd_boolean keep_sections
)
5947 struct wildcard_list
*curr
, *next
;
5948 lang_wild_statement_type
*new;
5950 /* Reverse the list as the parser puts it back to front. */
5951 for (curr
= section_list
, section_list
= NULL
;
5953 section_list
= curr
, curr
= next
)
5955 if (curr
->spec
.name
!= NULL
&& strcmp (curr
->spec
.name
, "COMMON") == 0)
5956 placed_commons
= TRUE
;
5959 curr
->next
= section_list
;
5962 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
5964 if (strcmp (filespec
->name
, "*") == 0)
5965 filespec
->name
= NULL
;
5966 else if (! wildcardp (filespec
->name
))
5967 lang_has_input_file
= TRUE
;
5970 new = new_stat (lang_wild_statement
, stat_ptr
);
5971 new->filename
= NULL
;
5972 new->filenames_sorted
= FALSE
;
5973 if (filespec
!= NULL
)
5975 new->filename
= filespec
->name
;
5976 new->filenames_sorted
= filespec
->sorted
== by_name
;
5978 new->section_list
= section_list
;
5979 new->keep_sections
= keep_sections
;
5980 lang_list_init (&new->children
);
5981 analyze_walk_wild_section_handler (new);
5985 lang_section_start (const char *name
, etree_type
*address
,
5986 const segment_type
*segment
)
5988 lang_address_statement_type
*ad
;
5990 ad
= new_stat (lang_address_statement
, stat_ptr
);
5991 ad
->section_name
= name
;
5992 ad
->address
= address
;
5993 ad
->segment
= segment
;
5996 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
5997 because of a -e argument on the command line, or zero if this is
5998 called by ENTRY in a linker script. Command line arguments take
6002 lang_add_entry (const char *name
, bfd_boolean cmdline
)
6004 if (entry_symbol
.name
== NULL
6006 || ! entry_from_cmdline
)
6008 entry_symbol
.name
= name
;
6009 entry_from_cmdline
= cmdline
;
6013 /* Set the default start symbol to NAME. .em files should use this,
6014 not lang_add_entry, to override the use of "start" if neither the
6015 linker script nor the command line specifies an entry point. NAME
6016 must be permanently allocated. */
6018 lang_default_entry (const char *name
)
6020 entry_symbol_default
= name
;
6024 lang_add_target (const char *name
)
6026 lang_target_statement_type
*new;
6028 new = new_stat (lang_target_statement
, stat_ptr
);
6033 lang_add_map (const char *name
)
6040 map_option_f
= TRUE
;
6048 lang_add_fill (fill_type
*fill
)
6050 lang_fill_statement_type
*new;
6052 new = new_stat (lang_fill_statement
, stat_ptr
);
6057 lang_add_data (int type
, union etree_union
*exp
)
6059 lang_data_statement_type
*new;
6061 new = new_stat (lang_data_statement
, stat_ptr
);
6066 /* Create a new reloc statement. RELOC is the BFD relocation type to
6067 generate. HOWTO is the corresponding howto structure (we could
6068 look this up, but the caller has already done so). SECTION is the
6069 section to generate a reloc against, or NAME is the name of the
6070 symbol to generate a reloc against. Exactly one of SECTION and
6071 NAME must be NULL. ADDEND is an expression for the addend. */
6074 lang_add_reloc (bfd_reloc_code_real_type reloc
,
6075 reloc_howto_type
*howto
,
6078 union etree_union
*addend
)
6080 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
6084 p
->section
= section
;
6086 p
->addend_exp
= addend
;
6088 p
->addend_value
= 0;
6089 p
->output_section
= NULL
;
6090 p
->output_offset
= 0;
6093 lang_assignment_statement_type
*
6094 lang_add_assignment (etree_type
*exp
)
6096 lang_assignment_statement_type
*new;
6098 new = new_stat (lang_assignment_statement
, stat_ptr
);
6104 lang_add_attribute (enum statement_enum attribute
)
6106 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
6110 lang_startup (const char *name
)
6112 if (startup_file
!= NULL
)
6114 einfo (_("%P%F: multiple STARTUP files\n"));
6116 first_file
->filename
= name
;
6117 first_file
->local_sym_name
= name
;
6118 first_file
->real
= TRUE
;
6120 startup_file
= name
;
6124 lang_float (bfd_boolean maybe
)
6126 lang_float_flag
= maybe
;
6130 /* Work out the load- and run-time regions from a script statement, and
6131 store them in *LMA_REGION and *REGION respectively.
6133 MEMSPEC is the name of the run-time region, or the value of
6134 DEFAULT_MEMORY_REGION if the statement didn't specify one.
6135 LMA_MEMSPEC is the name of the load-time region, or null if the
6136 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
6137 had an explicit load address.
6139 It is an error to specify both a load region and a load address. */
6142 lang_get_regions (lang_memory_region_type
**region
,
6143 lang_memory_region_type
**lma_region
,
6144 const char *memspec
,
6145 const char *lma_memspec
,
6146 bfd_boolean have_lma
,
6147 bfd_boolean have_vma
)
6149 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
6151 /* If no runtime region or VMA has been specified, but the load region
6152 has been specified, then use the load region for the runtime region
6154 if (lma_memspec
!= NULL
6156 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
6157 *region
= *lma_region
;
6159 *region
= lang_memory_region_lookup (memspec
, FALSE
);
6161 if (have_lma
&& lma_memspec
!= 0)
6162 einfo (_("%X%P:%S: section has both a load address and a load region\n"));
6166 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
6167 lang_output_section_phdr_list
*phdrs
,
6168 const char *lma_memspec
)
6170 lang_get_regions (¤t_section
->region
,
6171 ¤t_section
->lma_region
,
6172 memspec
, lma_memspec
,
6173 current_section
->load_base
!= NULL
,
6174 current_section
->addr_tree
!= NULL
);
6175 current_section
->fill
= fill
;
6176 current_section
->phdrs
= phdrs
;
6177 stat_ptr
= &statement_list
;
6180 /* Create an absolute symbol with the given name with the value of the
6181 address of first byte of the section named.
6183 If the symbol already exists, then do nothing. */
6186 lang_abs_symbol_at_beginning_of (const char *secname
, const char *name
)
6188 struct bfd_link_hash_entry
*h
;
6190 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, TRUE
, TRUE
);
6192 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6194 if (h
->type
== bfd_link_hash_new
6195 || h
->type
== bfd_link_hash_undefined
)
6199 h
->type
= bfd_link_hash_defined
;
6201 sec
= bfd_get_section_by_name (output_bfd
, secname
);
6205 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
6207 h
->u
.def
.section
= bfd_abs_section_ptr
;
6211 /* Create an absolute symbol with the given name with the value of the
6212 address of the first byte after the end of the section named.
6214 If the symbol already exists, then do nothing. */
6217 lang_abs_symbol_at_end_of (const char *secname
, const char *name
)
6219 struct bfd_link_hash_entry
*h
;
6221 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, TRUE
, TRUE
);
6223 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6225 if (h
->type
== bfd_link_hash_new
6226 || h
->type
== bfd_link_hash_undefined
)
6230 h
->type
= bfd_link_hash_defined
;
6232 sec
= bfd_get_section_by_name (output_bfd
, secname
);
6236 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
6237 + TO_ADDR (sec
->size
));
6239 h
->u
.def
.section
= bfd_abs_section_ptr
;
6244 lang_statement_append (lang_statement_list_type
*list
,
6245 lang_statement_union_type
*element
,
6246 lang_statement_union_type
**field
)
6248 *(list
->tail
) = element
;
6252 /* Set the output format type. -oformat overrides scripts. */
6255 lang_add_output_format (const char *format
,
6260 if (output_target
== NULL
|| !from_script
)
6262 if (command_line
.endian
== ENDIAN_BIG
6265 else if (command_line
.endian
== ENDIAN_LITTLE
6269 output_target
= format
;
6273 /* Enter a group. This creates a new lang_group_statement, and sets
6274 stat_ptr to build new statements within the group. */
6277 lang_enter_group (void)
6279 lang_group_statement_type
*g
;
6281 g
= new_stat (lang_group_statement
, stat_ptr
);
6282 lang_list_init (&g
->children
);
6283 stat_ptr
= &g
->children
;
6286 /* Leave a group. This just resets stat_ptr to start writing to the
6287 regular list of statements again. Note that this will not work if
6288 groups can occur inside anything else which can adjust stat_ptr,
6289 but currently they can't. */
6292 lang_leave_group (void)
6294 stat_ptr
= &statement_list
;
6297 /* Add a new program header. This is called for each entry in a PHDRS
6298 command in a linker script. */
6301 lang_new_phdr (const char *name
,
6303 bfd_boolean filehdr
,
6308 struct lang_phdr
*n
, **pp
;
6310 n
= stat_alloc (sizeof (struct lang_phdr
));
6313 n
->type
= exp_get_value_int (type
, 0, "program header type");
6314 n
->filehdr
= filehdr
;
6319 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
6324 /* Record the program header information in the output BFD. FIXME: We
6325 should not be calling an ELF specific function here. */
6328 lang_record_phdrs (void)
6332 lang_output_section_phdr_list
*last
;
6333 struct lang_phdr
*l
;
6334 lang_output_section_statement_type
*os
;
6337 secs
= xmalloc (alc
* sizeof (asection
*));
6340 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
6347 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
6351 lang_output_section_phdr_list
*pl
;
6353 if (os
->constraint
== -1)
6361 if (os
->sectype
== noload_section
6362 || os
->bfd_section
== NULL
6363 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
6368 lang_output_section_statement_type
* tmp_os
;
6370 /* If we have not run across a section with a program
6371 header assigned to it yet, then scan forwards to find
6372 one. This prevents inconsistencies in the linker's
6373 behaviour when a script has specified just a single
6374 header and there are sections in that script which are
6375 not assigned to it, and which occur before the first
6376 use of that header. See here for more details:
6377 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
6378 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
6381 last
= tmp_os
->phdrs
;
6385 einfo (_("%F%P: no sections assigned to phdrs\n"));
6390 if (os
->bfd_section
== NULL
)
6393 for (; pl
!= NULL
; pl
= pl
->next
)
6395 if (strcmp (pl
->name
, l
->name
) == 0)
6400 secs
= xrealloc (secs
, alc
* sizeof (asection
*));
6402 secs
[c
] = os
->bfd_section
;
6409 if (l
->flags
== NULL
)
6412 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
6417 at
= exp_get_vma (l
->at
, 0, "phdr load address");
6419 if (! bfd_record_phdr (output_bfd
, l
->type
,
6420 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
6421 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
6422 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
6427 /* Make sure all the phdr assignments succeeded. */
6428 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
6432 lang_output_section_phdr_list
*pl
;
6434 if (os
->constraint
== -1
6435 || os
->bfd_section
== NULL
)
6438 for (pl
= os
->phdrs
;
6441 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
6442 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
6443 os
->name
, pl
->name
);
6447 /* Record a list of sections which may not be cross referenced. */
6450 lang_add_nocrossref (lang_nocrossref_type
*l
)
6452 struct lang_nocrossrefs
*n
;
6454 n
= xmalloc (sizeof *n
);
6455 n
->next
= nocrossref_list
;
6457 nocrossref_list
= n
;
6459 /* Set notice_all so that we get informed about all symbols. */
6460 link_info
.notice_all
= TRUE
;
6463 /* Overlay handling. We handle overlays with some static variables. */
6465 /* The overlay virtual address. */
6466 static etree_type
*overlay_vma
;
6467 /* And subsection alignment. */
6468 static etree_type
*overlay_subalign
;
6470 /* An expression for the maximum section size seen so far. */
6471 static etree_type
*overlay_max
;
6473 /* A list of all the sections in this overlay. */
6475 struct overlay_list
{
6476 struct overlay_list
*next
;
6477 lang_output_section_statement_type
*os
;
6480 static struct overlay_list
*overlay_list
;
6482 /* Start handling an overlay. */
6485 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
6487 /* The grammar should prevent nested overlays from occurring. */
6488 ASSERT (overlay_vma
== NULL
6489 && overlay_subalign
== NULL
6490 && overlay_max
== NULL
);
6492 overlay_vma
= vma_expr
;
6493 overlay_subalign
= subalign
;
6496 /* Start a section in an overlay. We handle this by calling
6497 lang_enter_output_section_statement with the correct VMA.
6498 lang_leave_overlay sets up the LMA and memory regions. */
6501 lang_enter_overlay_section (const char *name
)
6503 struct overlay_list
*n
;
6506 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
6507 0, overlay_subalign
, 0, 0);
6509 /* If this is the first section, then base the VMA of future
6510 sections on this one. This will work correctly even if `.' is
6511 used in the addresses. */
6512 if (overlay_list
== NULL
)
6513 overlay_vma
= exp_nameop (ADDR
, name
);
6515 /* Remember the section. */
6516 n
= xmalloc (sizeof *n
);
6517 n
->os
= current_section
;
6518 n
->next
= overlay_list
;
6521 size
= exp_nameop (SIZEOF
, name
);
6523 /* Arrange to work out the maximum section end address. */
6524 if (overlay_max
== NULL
)
6527 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
6530 /* Finish a section in an overlay. There isn't any special to do
6534 lang_leave_overlay_section (fill_type
*fill
,
6535 lang_output_section_phdr_list
*phdrs
)
6542 name
= current_section
->name
;
6544 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
6545 region and that no load-time region has been specified. It doesn't
6546 really matter what we say here, since lang_leave_overlay will
6548 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
6550 /* Define the magic symbols. */
6552 clean
= xmalloc (strlen (name
) + 1);
6554 for (s1
= name
; *s1
!= '\0'; s1
++)
6555 if (ISALNUM (*s1
) || *s1
== '_')
6559 buf
= xmalloc (strlen (clean
) + sizeof "__load_start_");
6560 sprintf (buf
, "__load_start_%s", clean
);
6561 lang_add_assignment (exp_provide (buf
,
6562 exp_nameop (LOADADDR
, name
),
6565 buf
= xmalloc (strlen (clean
) + sizeof "__load_stop_");
6566 sprintf (buf
, "__load_stop_%s", clean
);
6567 lang_add_assignment (exp_provide (buf
,
6569 exp_nameop (LOADADDR
, name
),
6570 exp_nameop (SIZEOF
, name
)),
6576 /* Finish an overlay. If there are any overlay wide settings, this
6577 looks through all the sections in the overlay and sets them. */
6580 lang_leave_overlay (etree_type
*lma_expr
,
6583 const char *memspec
,
6584 lang_output_section_phdr_list
*phdrs
,
6585 const char *lma_memspec
)
6587 lang_memory_region_type
*region
;
6588 lang_memory_region_type
*lma_region
;
6589 struct overlay_list
*l
;
6590 lang_nocrossref_type
*nocrossref
;
6592 lang_get_regions (®ion
, &lma_region
,
6593 memspec
, lma_memspec
,
6594 lma_expr
!= NULL
, FALSE
);
6598 /* After setting the size of the last section, set '.' to end of the
6600 if (overlay_list
!= NULL
)
6601 overlay_list
->os
->update_dot_tree
6602 = exp_assop ('=', ".", exp_binop ('+', overlay_vma
, overlay_max
));
6607 struct overlay_list
*next
;
6609 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
6612 l
->os
->region
= region
;
6613 l
->os
->lma_region
= lma_region
;
6615 /* The first section has the load address specified in the
6616 OVERLAY statement. The rest are worked out from that.
6617 The base address is not needed (and should be null) if
6618 an LMA region was specified. */
6621 l
->os
->load_base
= lma_expr
;
6622 l
->os
->sectype
= normal_section
;
6624 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
6625 l
->os
->phdrs
= phdrs
;
6629 lang_nocrossref_type
*nc
;
6631 nc
= xmalloc (sizeof *nc
);
6632 nc
->name
= l
->os
->name
;
6633 nc
->next
= nocrossref
;
6642 if (nocrossref
!= NULL
)
6643 lang_add_nocrossref (nocrossref
);
6646 overlay_list
= NULL
;
6650 /* Version handling. This is only useful for ELF. */
6652 /* This global variable holds the version tree that we build. */
6654 struct bfd_elf_version_tree
*lang_elf_version_info
;
6656 /* If PREV is NULL, return first version pattern matching particular symbol.
6657 If PREV is non-NULL, return first version pattern matching particular
6658 symbol after PREV (previously returned by lang_vers_match). */
6660 static struct bfd_elf_version_expr
*
6661 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
6662 struct bfd_elf_version_expr
*prev
,
6665 const char *cxx_sym
= sym
;
6666 const char *java_sym
= sym
;
6667 struct bfd_elf_version_expr
*expr
= NULL
;
6669 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
6671 cxx_sym
= cplus_demangle (sym
, DMGL_PARAMS
| DMGL_ANSI
);
6675 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
6677 java_sym
= cplus_demangle (sym
, DMGL_JAVA
);
6682 if (head
->htab
&& (prev
== NULL
|| prev
->symbol
))
6684 struct bfd_elf_version_expr e
;
6686 switch (prev
? prev
->mask
: 0)
6689 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
6692 expr
= htab_find (head
->htab
, &e
);
6693 while (expr
&& strcmp (expr
->symbol
, sym
) == 0)
6694 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
6700 case BFD_ELF_VERSION_C_TYPE
:
6701 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
6704 expr
= htab_find (head
->htab
, &e
);
6705 while (expr
&& strcmp (expr
->symbol
, cxx_sym
) == 0)
6706 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
6712 case BFD_ELF_VERSION_CXX_TYPE
:
6713 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
6715 e
.symbol
= java_sym
;
6716 expr
= htab_find (head
->htab
, &e
);
6717 while (expr
&& strcmp (expr
->symbol
, java_sym
) == 0)
6718 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
6729 /* Finally, try the wildcards. */
6730 if (prev
== NULL
|| prev
->symbol
)
6731 expr
= head
->remaining
;
6734 for (; expr
; expr
= expr
->next
)
6741 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
6744 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
6746 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
6750 if (fnmatch (expr
->pattern
, s
, 0) == 0)
6756 free ((char *) cxx_sym
);
6757 if (java_sym
!= sym
)
6758 free ((char *) java_sym
);
6762 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
6763 return a string pointing to the symbol name. */
6766 realsymbol (const char *pattern
)
6769 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
6770 char *s
, *symbol
= xmalloc (strlen (pattern
) + 1);
6772 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
6774 /* It is a glob pattern only if there is no preceding
6776 if (! backslash
&& (*p
== '?' || *p
== '*' || *p
== '['))
6784 /* Remove the preceding backslash. */
6791 backslash
= *p
== '\\';
6806 /* This is called for each variable name or match expression. NEW is
6807 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
6808 pattern to be matched against symbol names. */
6810 struct bfd_elf_version_expr
*
6811 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
6814 bfd_boolean literal_p
)
6816 struct bfd_elf_version_expr
*ret
;
6818 ret
= xmalloc (sizeof *ret
);
6820 ret
->pattern
= literal_p
? NULL
: new;
6823 ret
->symbol
= literal_p
? new : realsymbol (new);
6825 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
6826 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
6827 else if (strcasecmp (lang
, "C++") == 0)
6828 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
6829 else if (strcasecmp (lang
, "Java") == 0)
6830 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
6833 einfo (_("%X%P: unknown language `%s' in version information\n"),
6835 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
6838 return ldemul_new_vers_pattern (ret
);
6841 /* This is called for each set of variable names and match
6844 struct bfd_elf_version_tree
*
6845 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
6846 struct bfd_elf_version_expr
*locals
)
6848 struct bfd_elf_version_tree
*ret
;
6850 ret
= xcalloc (1, sizeof *ret
);
6851 ret
->globals
.list
= globals
;
6852 ret
->locals
.list
= locals
;
6853 ret
->match
= lang_vers_match
;
6854 ret
->name_indx
= (unsigned int) -1;
6858 /* This static variable keeps track of version indices. */
6860 static int version_index
;
6863 version_expr_head_hash (const void *p
)
6865 const struct bfd_elf_version_expr
*e
= p
;
6867 return htab_hash_string (e
->symbol
);
6871 version_expr_head_eq (const void *p1
, const void *p2
)
6873 const struct bfd_elf_version_expr
*e1
= p1
;
6874 const struct bfd_elf_version_expr
*e2
= p2
;
6876 return strcmp (e1
->symbol
, e2
->symbol
) == 0;
6880 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
6883 struct bfd_elf_version_expr
*e
, *next
;
6884 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
6886 for (e
= head
->list
; e
; e
= e
->next
)
6890 head
->mask
|= e
->mask
;
6895 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
6896 version_expr_head_eq
, NULL
);
6897 list_loc
= &head
->list
;
6898 remaining_loc
= &head
->remaining
;
6899 for (e
= head
->list
; e
; e
= next
)
6905 remaining_loc
= &e
->next
;
6909 void **loc
= htab_find_slot (head
->htab
, e
, INSERT
);
6913 struct bfd_elf_version_expr
*e1
, *last
;
6919 if (e1
->mask
== e
->mask
)
6927 while (e1
&& strcmp (e1
->symbol
, e
->symbol
) == 0);
6931 /* This is a duplicate. */
6932 /* FIXME: Memory leak. Sometimes pattern is not
6933 xmalloced alone, but in larger chunk of memory. */
6934 /* free (e->symbol); */
6939 e
->next
= last
->next
;
6947 list_loc
= &e
->next
;
6951 *remaining_loc
= NULL
;
6952 *list_loc
= head
->remaining
;
6955 head
->remaining
= head
->list
;
6958 /* This is called when we know the name and dependencies of the
6962 lang_register_vers_node (const char *name
,
6963 struct bfd_elf_version_tree
*version
,
6964 struct bfd_elf_version_deps
*deps
)
6966 struct bfd_elf_version_tree
*t
, **pp
;
6967 struct bfd_elf_version_expr
*e1
;
6972 if ((name
[0] == '\0' && lang_elf_version_info
!= NULL
)
6973 || (lang_elf_version_info
&& lang_elf_version_info
->name
[0] == '\0'))
6975 einfo (_("%X%P: anonymous version tag cannot be combined"
6976 " with other version tags\n"));
6981 /* Make sure this node has a unique name. */
6982 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
6983 if (strcmp (t
->name
, name
) == 0)
6984 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
6986 lang_finalize_version_expr_head (&version
->globals
);
6987 lang_finalize_version_expr_head (&version
->locals
);
6989 /* Check the global and local match names, and make sure there
6990 aren't any duplicates. */
6992 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
6994 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
6996 struct bfd_elf_version_expr
*e2
;
6998 if (t
->locals
.htab
&& e1
->symbol
)
7000 e2
= htab_find (t
->locals
.htab
, e1
);
7001 while (e2
&& strcmp (e1
->symbol
, e2
->symbol
) == 0)
7003 if (e1
->mask
== e2
->mask
)
7004 einfo (_("%X%P: duplicate expression `%s'"
7005 " in version information\n"), e1
->symbol
);
7009 else if (!e1
->symbol
)
7010 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
7011 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
7012 && e1
->mask
== e2
->mask
)
7013 einfo (_("%X%P: duplicate expression `%s'"
7014 " in version information\n"), e1
->pattern
);
7018 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
7020 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
7022 struct bfd_elf_version_expr
*e2
;
7024 if (t
->globals
.htab
&& e1
->symbol
)
7026 e2
= htab_find (t
->globals
.htab
, e1
);
7027 while (e2
&& strcmp (e1
->symbol
, e2
->symbol
) == 0)
7029 if (e1
->mask
== e2
->mask
)
7030 einfo (_("%X%P: duplicate expression `%s'"
7031 " in version information\n"),
7036 else if (!e1
->symbol
)
7037 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
7038 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
7039 && e1
->mask
== e2
->mask
)
7040 einfo (_("%X%P: duplicate expression `%s'"
7041 " in version information\n"), e1
->pattern
);
7045 version
->deps
= deps
;
7046 version
->name
= name
;
7047 if (name
[0] != '\0')
7050 version
->vernum
= version_index
;
7053 version
->vernum
= 0;
7055 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
7060 /* This is called when we see a version dependency. */
7062 struct bfd_elf_version_deps
*
7063 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
7065 struct bfd_elf_version_deps
*ret
;
7066 struct bfd_elf_version_tree
*t
;
7068 ret
= xmalloc (sizeof *ret
);
7071 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
7073 if (strcmp (t
->name
, name
) == 0)
7075 ret
->version_needed
= t
;
7080 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
7086 lang_do_version_exports_section (void)
7088 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
7090 LANG_FOR_EACH_INPUT_STATEMENT (is
)
7092 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
7100 contents
= xmalloc (len
);
7101 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
7102 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
7105 while (p
< contents
+ len
)
7107 greg
= lang_new_vers_pattern (greg
, p
, NULL
, FALSE
);
7108 p
= strchr (p
, '\0') + 1;
7111 /* Do not free the contents, as we used them creating the regex. */
7113 /* Do not include this section in the link. */
7114 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
7117 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, FALSE
);
7118 lang_register_vers_node (command_line
.version_exports_section
,
7119 lang_new_vers_node (greg
, lreg
), NULL
);
7123 lang_add_unique (const char *name
)
7125 struct unique_sections
*ent
;
7127 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
7128 if (strcmp (ent
->name
, name
) == 0)
7131 ent
= xmalloc (sizeof *ent
);
7132 ent
->name
= xstrdup (name
);
7133 ent
->next
= unique_section_list
;
7134 unique_section_list
= ent
;
7137 /* Append the list of dynamic symbols to the existing one. */
7140 lang_append_dynamic_list (struct bfd_elf_version_expr
*dynamic
)
7142 if (link_info
.dynamic_list
)
7144 struct bfd_elf_version_expr
*tail
;
7145 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
7147 tail
->next
= link_info
.dynamic_list
->head
.list
;
7148 link_info
.dynamic_list
->head
.list
= dynamic
;
7152 struct bfd_elf_dynamic_list
*d
;
7154 d
= xcalloc (1, sizeof *d
);
7155 d
->head
.list
= dynamic
;
7156 d
->match
= lang_vers_match
;
7157 link_info
.dynamic_list
= d
;
7161 /* Append the list of C++ typeinfo dynamic symbols to the existing
7165 lang_append_dynamic_list_cpp_typeinfo (void)
7167 const char * symbols
[] =
7169 "typeinfo name for*",
7172 struct bfd_elf_version_expr
*dynamic
= NULL
;
7175 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
7176 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
7179 lang_append_dynamic_list (dynamic
);
7182 /* Append the list of C++ operator new and delete dynamic symbols to the
7186 lang_append_dynamic_list_cpp_new (void)
7188 const char * symbols
[] =
7193 struct bfd_elf_version_expr
*dynamic
= NULL
;
7196 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
7197 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
7200 lang_append_dynamic_list (dynamic
);