1 /* Linker command language support.
2 Copyright (C) 1991-2019 Free Software Foundation, Inc.
4 This file is part of the GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
23 #include "libiberty.h"
24 #include "filenames.h"
25 #include "safe-ctype.h"
45 #endif /* ENABLE_PLUGINS */
48 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
51 /* Convert between addresses in bytes and sizes in octets.
52 For currently supported targets, octets_per_byte is always a power
53 of two, so we can use shifts. */
54 #define TO_ADDR(X) ((X) >> opb_shift)
55 #define TO_SIZE(X) ((X) << opb_shift)
57 /* Local variables. */
58 static struct obstack stat_obstack
;
59 static struct obstack map_obstack
;
61 #define obstack_chunk_alloc xmalloc
62 #define obstack_chunk_free free
63 static const char *entry_symbol_default
= "start";
64 static bfd_boolean map_head_is_link_order
= FALSE
;
65 static lang_output_section_statement_type
*default_common_section
;
66 static bfd_boolean map_option_f
;
67 static bfd_vma print_dot
;
68 static lang_input_statement_type
*first_file
;
69 static const char *current_target
;
70 /* Header for list of statements corresponding to any files involved in the
71 link, either specified from the command-line or added implicitely (eg.
72 archive member used to resolved undefined symbol, wildcard statement from
73 linker script, etc.). Next pointer is in next field of a
74 lang_statement_header_type (reached via header field in a
75 lang_statement_union). */
76 static lang_statement_list_type statement_list
;
77 static lang_statement_list_type
*stat_save
[10];
78 static lang_statement_list_type
**stat_save_ptr
= &stat_save
[0];
79 static struct unique_sections
*unique_section_list
;
80 static struct asneeded_minfo
*asneeded_list_head
;
81 static unsigned int opb_shift
= 0;
83 /* Forward declarations. */
84 static void exp_init_os (etree_type
*);
85 static lang_input_statement_type
*lookup_name (const char *);
86 static void insert_undefined (const char *);
87 static bfd_boolean
sort_def_symbol (struct bfd_link_hash_entry
*, void *);
88 static void print_statement (lang_statement_union_type
*,
89 lang_output_section_statement_type
*);
90 static void print_statement_list (lang_statement_union_type
*,
91 lang_output_section_statement_type
*);
92 static void print_statements (void);
93 static void print_input_section (asection
*, bfd_boolean
);
94 static bfd_boolean
lang_one_common (struct bfd_link_hash_entry
*, void *);
95 static void lang_record_phdrs (void);
96 static void lang_do_version_exports_section (void);
97 static void lang_finalize_version_expr_head
98 (struct bfd_elf_version_expr_head
*);
99 static void lang_do_memory_regions (void);
101 /* Exported variables. */
102 const char *output_target
;
103 lang_output_section_statement_type
*abs_output_section
;
104 lang_statement_list_type lang_os_list
;
105 lang_statement_list_type
*stat_ptr
= &statement_list
;
106 /* Header for list of statements corresponding to files used in the final
107 executable. This can be either object file specified on the command-line
108 or library member resolving an undefined reference. Next pointer is in next
109 field of a lang_input_statement_type (reached via input_statement field in a
110 lang_statement_union). */
111 lang_statement_list_type file_chain
= { NULL
, NULL
};
112 /* Header for list of statements corresponding to files specified on the
113 command-line for linking. It thus contains real object files and archive
114 but not archive members. Next pointer is in next_real_file field of a
115 lang_input_statement_type statement (reached via input_statement field in a
116 lang_statement_union). */
117 lang_statement_list_type input_file_chain
;
118 struct bfd_sym_chain entry_symbol
= { NULL
, NULL
};
119 const char *entry_section
= ".text";
120 struct lang_input_statement_flags input_flags
;
121 bfd_boolean entry_from_cmdline
;
122 bfd_boolean undef_from_cmdline
;
123 bfd_boolean lang_has_input_file
= FALSE
;
124 bfd_boolean had_output_filename
= FALSE
;
125 bfd_boolean lang_float_flag
= FALSE
;
126 bfd_boolean delete_output_file_on_failure
= FALSE
;
127 struct lang_phdr
*lang_phdr_list
;
128 struct lang_nocrossrefs
*nocrossref_list
;
129 struct asneeded_minfo
**asneeded_list_tail
;
131 /* Functions that traverse the linker script and might evaluate
132 DEFINED() need to increment this at the start of the traversal. */
133 int lang_statement_iteration
= 0;
135 /* Return TRUE if the PATTERN argument is a wildcard pattern.
136 Although backslashes are treated specially if a pattern contains
137 wildcards, we do not consider the mere presence of a backslash to
138 be enough to cause the pattern to be treated as a wildcard.
139 That lets us handle DOS filenames more naturally. */
140 #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
142 #define new_stat(x, y) \
143 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
145 #define outside_section_address(q) \
146 ((q)->output_offset + (q)->output_section->vma)
148 #define outside_symbol_address(q) \
149 ((q)->value + outside_section_address (q->section))
151 #define SECTION_NAME_MAP_LENGTH (16)
154 stat_alloc (size_t size
)
156 return obstack_alloc (&stat_obstack
, size
);
160 name_match (const char *pattern
, const char *name
)
162 if (wildcardp (pattern
))
163 return fnmatch (pattern
, name
, 0);
164 return strcmp (pattern
, name
);
167 /* If PATTERN is of the form archive:file, return a pointer to the
168 separator. If not, return NULL. */
171 archive_path (const char *pattern
)
175 if (link_info
.path_separator
== 0)
178 p
= strchr (pattern
, link_info
.path_separator
);
179 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
180 if (p
== NULL
|| link_info
.path_separator
!= ':')
183 /* Assume a match on the second char is part of drive specifier,
184 as in "c:\silly.dos". */
185 if (p
== pattern
+ 1 && ISALPHA (*pattern
))
186 p
= strchr (p
+ 1, link_info
.path_separator
);
191 /* Given that FILE_SPEC results in a non-NULL SEP result from archive_path,
192 return whether F matches FILE_SPEC. */
195 input_statement_is_archive_path (const char *file_spec
, char *sep
,
196 lang_input_statement_type
*f
)
198 bfd_boolean match
= FALSE
;
201 || name_match (sep
+ 1, f
->filename
) == 0)
202 && ((sep
!= file_spec
)
203 == (f
->the_bfd
!= NULL
&& f
->the_bfd
->my_archive
!= NULL
)))
207 if (sep
!= file_spec
)
209 const char *aname
= f
->the_bfd
->my_archive
->filename
;
211 match
= name_match (file_spec
, aname
) == 0;
212 *sep
= link_info
.path_separator
;
219 unique_section_p (const asection
*sec
,
220 const lang_output_section_statement_type
*os
)
222 struct unique_sections
*unam
;
225 if (!link_info
.resolve_section_groups
226 && sec
->owner
!= NULL
227 && bfd_is_group_section (sec
->owner
, sec
))
229 && strcmp (os
->name
, DISCARD_SECTION_NAME
) == 0);
232 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
233 if (name_match (unam
->name
, secnam
) == 0)
239 /* Generic traversal routines for finding matching sections. */
241 /* Return true if FILE matches a pattern in EXCLUDE_LIST, otherwise return
245 walk_wild_file_in_exclude_list (struct name_list
*exclude_list
,
246 lang_input_statement_type
*file
)
248 struct name_list
*list_tmp
;
250 for (list_tmp
= exclude_list
;
252 list_tmp
= list_tmp
->next
)
254 char *p
= archive_path (list_tmp
->name
);
258 if (input_statement_is_archive_path (list_tmp
->name
, p
, file
))
262 else if (name_match (list_tmp
->name
, file
->filename
) == 0)
265 /* FIXME: Perhaps remove the following at some stage? Matching
266 unadorned archives like this was never documented and has
267 been superceded by the archive:path syntax. */
268 else if (file
->the_bfd
!= NULL
269 && file
->the_bfd
->my_archive
!= NULL
270 && name_match (list_tmp
->name
,
271 file
->the_bfd
->my_archive
->filename
) == 0)
278 /* Try processing a section against a wildcard. This just calls
279 the callback unless the filename exclusion list is present
280 and excludes the file. It's hardly ever present so this
281 function is very fast. */
284 walk_wild_consider_section (lang_wild_statement_type
*ptr
,
285 lang_input_statement_type
*file
,
287 struct wildcard_list
*sec
,
291 /* Don't process sections from files which were excluded. */
292 if (walk_wild_file_in_exclude_list (sec
->spec
.exclude_name_list
, file
))
295 (*callback
) (ptr
, sec
, s
, ptr
->section_flag_list
, file
, data
);
298 /* Lowest common denominator routine that can handle everything correctly,
302 walk_wild_section_general (lang_wild_statement_type
*ptr
,
303 lang_input_statement_type
*file
,
308 struct wildcard_list
*sec
;
310 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
312 sec
= ptr
->section_list
;
314 (*callback
) (ptr
, sec
, s
, ptr
->section_flag_list
, file
, data
);
318 bfd_boolean skip
= FALSE
;
320 if (sec
->spec
.name
!= NULL
)
322 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
324 skip
= name_match (sec
->spec
.name
, sname
) != 0;
328 walk_wild_consider_section (ptr
, file
, s
, sec
, callback
, data
);
335 /* Routines to find a single section given its name. If there's more
336 than one section with that name, we report that. */
340 asection
*found_section
;
341 bfd_boolean multiple_sections_found
;
342 } section_iterator_callback_data
;
345 section_iterator_callback (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*s
, void *data
)
347 section_iterator_callback_data
*d
= (section_iterator_callback_data
*) data
;
349 if (d
->found_section
!= NULL
)
351 d
->multiple_sections_found
= TRUE
;
355 d
->found_section
= s
;
360 find_section (lang_input_statement_type
*file
,
361 struct wildcard_list
*sec
,
362 bfd_boolean
*multiple_sections_found
)
364 section_iterator_callback_data cb_data
= { NULL
, FALSE
};
366 bfd_get_section_by_name_if (file
->the_bfd
, sec
->spec
.name
,
367 section_iterator_callback
, &cb_data
);
368 *multiple_sections_found
= cb_data
.multiple_sections_found
;
369 return cb_data
.found_section
;
372 /* Code for handling simple wildcards without going through fnmatch,
373 which can be expensive because of charset translations etc. */
375 /* A simple wild is a literal string followed by a single '*',
376 where the literal part is at least 4 characters long. */
379 is_simple_wild (const char *name
)
381 size_t len
= strcspn (name
, "*?[");
382 return len
>= 4 && name
[len
] == '*' && name
[len
+ 1] == '\0';
386 match_simple_wild (const char *pattern
, const char *name
)
388 /* The first four characters of the pattern are guaranteed valid
389 non-wildcard characters. So we can go faster. */
390 if (pattern
[0] != name
[0] || pattern
[1] != name
[1]
391 || pattern
[2] != name
[2] || pattern
[3] != name
[3])
396 while (*pattern
!= '*')
397 if (*name
++ != *pattern
++)
403 /* Return the numerical value of the init_priority attribute from
404 section name NAME. */
407 get_init_priority (const char *name
)
410 unsigned long init_priority
;
412 /* GCC uses the following section names for the init_priority
413 attribute with numerical values 101 and 65535 inclusive. A
414 lower value means a higher priority.
416 1: .init_array.NNNN/.fini_array.NNNN: Where NNNN is the
417 decimal numerical value of the init_priority attribute.
418 The order of execution in .init_array is forward and
419 .fini_array is backward.
420 2: .ctors.NNNN/.dtors.NNNN: Where NNNN is 65535 minus the
421 decimal numerical value of the init_priority attribute.
422 The order of execution in .ctors is backward and .dtors
425 if (strncmp (name
, ".init_array.", 12) == 0
426 || strncmp (name
, ".fini_array.", 12) == 0)
428 init_priority
= strtoul (name
+ 12, &end
, 10);
429 return *end
? 0 : init_priority
;
431 else if (strncmp (name
, ".ctors.", 7) == 0
432 || strncmp (name
, ".dtors.", 7) == 0)
434 init_priority
= strtoul (name
+ 7, &end
, 10);
435 return *end
? 0 : 65535 - init_priority
;
441 /* Compare sections ASEC and BSEC according to SORT. */
444 compare_section (sort_type sort
, asection
*asec
, asection
*bsec
)
447 unsigned long ainit_priority
, binit_priority
;
454 case by_init_priority
:
456 = get_init_priority (bfd_get_section_name (asec
->owner
, asec
));
458 = get_init_priority (bfd_get_section_name (bsec
->owner
, bsec
));
459 if (ainit_priority
== 0 || binit_priority
== 0)
461 ret
= ainit_priority
- binit_priority
;
467 case by_alignment_name
:
468 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
469 - bfd_section_alignment (asec
->owner
, asec
));
476 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
477 bfd_get_section_name (bsec
->owner
, bsec
));
480 case by_name_alignment
:
481 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
482 bfd_get_section_name (bsec
->owner
, bsec
));
488 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
489 - bfd_section_alignment (asec
->owner
, asec
));
496 /* Build a Binary Search Tree to sort sections, unlike insertion sort
497 used in wild_sort(). BST is considerably faster if the number of
498 of sections are large. */
500 static lang_section_bst_type
**
501 wild_sort_fast (lang_wild_statement_type
*wild
,
502 struct wildcard_list
*sec
,
503 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
506 lang_section_bst_type
**tree
;
509 if (!wild
->filenames_sorted
510 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
512 /* Append at the right end of tree. */
514 tree
= &((*tree
)->right
);
520 /* Find the correct node to append this section. */
521 if (compare_section (sec
->spec
.sorted
, section
, (*tree
)->section
) < 0)
522 tree
= &((*tree
)->left
);
524 tree
= &((*tree
)->right
);
530 /* Use wild_sort_fast to build a BST to sort sections. */
533 output_section_callback_fast (lang_wild_statement_type
*ptr
,
534 struct wildcard_list
*sec
,
536 struct flag_info
*sflag_list ATTRIBUTE_UNUSED
,
537 lang_input_statement_type
*file
,
540 lang_section_bst_type
*node
;
541 lang_section_bst_type
**tree
;
542 lang_output_section_statement_type
*os
;
544 os
= (lang_output_section_statement_type
*) output
;
546 if (unique_section_p (section
, os
))
549 node
= (lang_section_bst_type
*) xmalloc (sizeof (lang_section_bst_type
));
552 node
->section
= section
;
554 tree
= wild_sort_fast (ptr
, sec
, file
, section
);
559 /* Convert a sorted sections' BST back to list form. */
562 output_section_callback_tree_to_list (lang_wild_statement_type
*ptr
,
563 lang_section_bst_type
*tree
,
567 output_section_callback_tree_to_list (ptr
, tree
->left
, output
);
569 lang_add_section (&ptr
->children
, tree
->section
, NULL
,
570 (lang_output_section_statement_type
*) output
);
573 output_section_callback_tree_to_list (ptr
, tree
->right
, output
);
578 /* Specialized, optimized routines for handling different kinds of
582 walk_wild_section_specs1_wild0 (lang_wild_statement_type
*ptr
,
583 lang_input_statement_type
*file
,
587 /* We can just do a hash lookup for the section with the right name.
588 But if that lookup discovers more than one section with the name
589 (should be rare), we fall back to the general algorithm because
590 we would otherwise have to sort the sections to make sure they
591 get processed in the bfd's order. */
592 bfd_boolean multiple_sections_found
;
593 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
594 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
596 if (multiple_sections_found
)
597 walk_wild_section_general (ptr
, file
, callback
, data
);
599 walk_wild_consider_section (ptr
, file
, s0
, sec0
, callback
, data
);
603 walk_wild_section_specs1_wild1 (lang_wild_statement_type
*ptr
,
604 lang_input_statement_type
*file
,
609 struct wildcard_list
*wildsec0
= ptr
->handler_data
[0];
611 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
613 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
614 bfd_boolean skip
= !match_simple_wild (wildsec0
->spec
.name
, sname
);
617 walk_wild_consider_section (ptr
, file
, s
, wildsec0
, callback
, data
);
622 walk_wild_section_specs2_wild1 (lang_wild_statement_type
*ptr
,
623 lang_input_statement_type
*file
,
628 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
629 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
630 bfd_boolean multiple_sections_found
;
631 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
633 if (multiple_sections_found
)
635 walk_wild_section_general (ptr
, file
, callback
, data
);
639 /* Note that if the section was not found, s0 is NULL and
640 we'll simply never succeed the s == s0 test below. */
641 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
643 /* Recall that in this code path, a section cannot satisfy more
644 than one spec, so if s == s0 then it cannot match
647 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
650 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
651 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
654 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
,
661 walk_wild_section_specs3_wild2 (lang_wild_statement_type
*ptr
,
662 lang_input_statement_type
*file
,
667 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
668 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
669 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
670 bfd_boolean multiple_sections_found
;
671 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
673 if (multiple_sections_found
)
675 walk_wild_section_general (ptr
, file
, callback
, data
);
679 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
682 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
685 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
686 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
689 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
, data
);
692 skip
= !match_simple_wild (wildsec2
->spec
.name
, sname
);
694 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
702 walk_wild_section_specs4_wild2 (lang_wild_statement_type
*ptr
,
703 lang_input_statement_type
*file
,
708 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
709 struct wildcard_list
*sec1
= ptr
->handler_data
[1];
710 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
711 struct wildcard_list
*wildsec3
= ptr
->handler_data
[3];
712 bfd_boolean multiple_sections_found
;
713 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
), *s1
;
715 if (multiple_sections_found
)
717 walk_wild_section_general (ptr
, file
, callback
, data
);
721 s1
= find_section (file
, sec1
, &multiple_sections_found
);
722 if (multiple_sections_found
)
724 walk_wild_section_general (ptr
, file
, callback
, data
);
728 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
731 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
734 walk_wild_consider_section (ptr
, file
, s
, sec1
, callback
, data
);
737 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
738 bfd_boolean skip
= !match_simple_wild (wildsec2
->spec
.name
,
742 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
746 skip
= !match_simple_wild (wildsec3
->spec
.name
, sname
);
748 walk_wild_consider_section (ptr
, file
, s
, wildsec3
,
756 walk_wild_section (lang_wild_statement_type
*ptr
,
757 lang_input_statement_type
*file
,
761 if (file
->flags
.just_syms
)
764 (*ptr
->walk_wild_section_handler
) (ptr
, file
, callback
, data
);
767 /* Returns TRUE when name1 is a wildcard spec that might match
768 something name2 can match. We're conservative: we return FALSE
769 only if the prefixes of name1 and name2 are different up to the
770 first wildcard character. */
773 wild_spec_can_overlap (const char *name1
, const char *name2
)
775 size_t prefix1_len
= strcspn (name1
, "?*[");
776 size_t prefix2_len
= strcspn (name2
, "?*[");
777 size_t min_prefix_len
;
779 /* Note that if there is no wildcard character, then we treat the
780 terminating 0 as part of the prefix. Thus ".text" won't match
781 ".text." or ".text.*", for example. */
782 if (name1
[prefix1_len
] == '\0')
784 if (name2
[prefix2_len
] == '\0')
787 min_prefix_len
= prefix1_len
< prefix2_len
? prefix1_len
: prefix2_len
;
789 return memcmp (name1
, name2
, min_prefix_len
) == 0;
792 /* Select specialized code to handle various kinds of wildcard
796 analyze_walk_wild_section_handler (lang_wild_statement_type
*ptr
)
799 int wild_name_count
= 0;
800 struct wildcard_list
*sec
;
804 ptr
->walk_wild_section_handler
= walk_wild_section_general
;
805 ptr
->handler_data
[0] = NULL
;
806 ptr
->handler_data
[1] = NULL
;
807 ptr
->handler_data
[2] = NULL
;
808 ptr
->handler_data
[3] = NULL
;
811 /* Count how many wildcard_specs there are, and how many of those
812 actually use wildcards in the name. Also, bail out if any of the
813 wildcard names are NULL. (Can this actually happen?
814 walk_wild_section used to test for it.) And bail out if any
815 of the wildcards are more complex than a simple string
816 ending in a single '*'. */
817 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
820 if (sec
->spec
.name
== NULL
)
822 if (wildcardp (sec
->spec
.name
))
825 if (!is_simple_wild (sec
->spec
.name
))
830 /* The zero-spec case would be easy to optimize but it doesn't
831 happen in practice. Likewise, more than 4 specs doesn't
832 happen in practice. */
833 if (sec_count
== 0 || sec_count
> 4)
836 /* Check that no two specs can match the same section. */
837 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
839 struct wildcard_list
*sec2
;
840 for (sec2
= sec
->next
; sec2
!= NULL
; sec2
= sec2
->next
)
842 if (wild_spec_can_overlap (sec
->spec
.name
, sec2
->spec
.name
))
847 signature
= (sec_count
<< 8) + wild_name_count
;
851 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild0
;
854 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild1
;
857 ptr
->walk_wild_section_handler
= walk_wild_section_specs2_wild1
;
860 ptr
->walk_wild_section_handler
= walk_wild_section_specs3_wild2
;
863 ptr
->walk_wild_section_handler
= walk_wild_section_specs4_wild2
;
869 /* Now fill the data array with pointers to the specs, first the
870 specs with non-wildcard names, then the specs with wildcard
871 names. It's OK to process the specs in different order from the
872 given order, because we've already determined that no section
873 will match more than one spec. */
875 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
876 if (!wildcardp (sec
->spec
.name
))
877 ptr
->handler_data
[data_counter
++] = sec
;
878 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
879 if (wildcardp (sec
->spec
.name
))
880 ptr
->handler_data
[data_counter
++] = sec
;
883 /* Handle a wild statement for a single file F. */
886 walk_wild_file (lang_wild_statement_type
*s
,
887 lang_input_statement_type
*f
,
891 if (walk_wild_file_in_exclude_list (s
->exclude_name_list
, f
))
894 if (f
->the_bfd
== NULL
895 || !bfd_check_format (f
->the_bfd
, bfd_archive
))
896 walk_wild_section (s
, f
, callback
, data
);
901 /* This is an archive file. We must map each member of the
902 archive separately. */
903 member
= bfd_openr_next_archived_file (f
->the_bfd
, NULL
);
904 while (member
!= NULL
)
906 /* When lookup_name is called, it will call the add_symbols
907 entry point for the archive. For each element of the
908 archive which is included, BFD will call ldlang_add_file,
909 which will set the usrdata field of the member to the
910 lang_input_statement. */
911 if (member
->usrdata
!= NULL
)
913 walk_wild_section (s
,
914 (lang_input_statement_type
*) member
->usrdata
,
918 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
924 walk_wild (lang_wild_statement_type
*s
, callback_t callback
, void *data
)
926 const char *file_spec
= s
->filename
;
929 if (file_spec
== NULL
)
931 /* Perform the iteration over all files in the list. */
932 LANG_FOR_EACH_INPUT_STATEMENT (f
)
934 walk_wild_file (s
, f
, callback
, data
);
937 else if ((p
= archive_path (file_spec
)) != NULL
)
939 LANG_FOR_EACH_INPUT_STATEMENT (f
)
941 if (input_statement_is_archive_path (file_spec
, p
, f
))
942 walk_wild_file (s
, f
, callback
, data
);
945 else if (wildcardp (file_spec
))
947 LANG_FOR_EACH_INPUT_STATEMENT (f
)
949 if (fnmatch (file_spec
, f
->filename
, 0) == 0)
950 walk_wild_file (s
, f
, callback
, data
);
955 lang_input_statement_type
*f
;
957 /* Perform the iteration over a single file. */
958 f
= lookup_name (file_spec
);
960 walk_wild_file (s
, f
, callback
, data
);
964 /* lang_for_each_statement walks the parse tree and calls the provided
965 function for each node, except those inside output section statements
966 with constraint set to -1. */
969 lang_for_each_statement_worker (void (*func
) (lang_statement_union_type
*),
970 lang_statement_union_type
*s
)
972 for (; s
!= NULL
; s
= s
->header
.next
)
976 switch (s
->header
.type
)
978 case lang_constructors_statement_enum
:
979 lang_for_each_statement_worker (func
, constructor_list
.head
);
981 case lang_output_section_statement_enum
:
982 if (s
->output_section_statement
.constraint
!= -1)
983 lang_for_each_statement_worker
984 (func
, s
->output_section_statement
.children
.head
);
986 case lang_wild_statement_enum
:
987 lang_for_each_statement_worker (func
,
988 s
->wild_statement
.children
.head
);
990 case lang_group_statement_enum
:
991 lang_for_each_statement_worker (func
,
992 s
->group_statement
.children
.head
);
994 case lang_data_statement_enum
:
995 case lang_reloc_statement_enum
:
996 case lang_object_symbols_statement_enum
:
997 case lang_output_statement_enum
:
998 case lang_target_statement_enum
:
999 case lang_input_section_enum
:
1000 case lang_input_statement_enum
:
1001 case lang_assignment_statement_enum
:
1002 case lang_padding_statement_enum
:
1003 case lang_address_statement_enum
:
1004 case lang_fill_statement_enum
:
1005 case lang_insert_statement_enum
:
1015 lang_for_each_statement (void (*func
) (lang_statement_union_type
*))
1017 lang_for_each_statement_worker (func
, statement_list
.head
);
1020 /*----------------------------------------------------------------------*/
1023 lang_list_init (lang_statement_list_type
*list
)
1026 list
->tail
= &list
->head
;
1030 push_stat_ptr (lang_statement_list_type
*new_ptr
)
1032 if (stat_save_ptr
>= stat_save
+ sizeof (stat_save
) / sizeof (stat_save
[0]))
1034 *stat_save_ptr
++ = stat_ptr
;
1041 if (stat_save_ptr
<= stat_save
)
1043 stat_ptr
= *--stat_save_ptr
;
1046 /* Build a new statement node for the parse tree. */
1048 static lang_statement_union_type
*
1049 new_statement (enum statement_enum type
,
1051 lang_statement_list_type
*list
)
1053 lang_statement_union_type
*new_stmt
;
1055 new_stmt
= (lang_statement_union_type
*) stat_alloc (size
);
1056 new_stmt
->header
.type
= type
;
1057 new_stmt
->header
.next
= NULL
;
1058 lang_statement_append (list
, new_stmt
, &new_stmt
->header
.next
);
1062 /* Build a new input file node for the language. There are several
1063 ways in which we treat an input file, eg, we only look at symbols,
1064 or prefix it with a -l etc.
1066 We can be supplied with requests for input files more than once;
1067 they may, for example be split over several lines like foo.o(.text)
1068 foo.o(.data) etc, so when asked for a file we check that we haven't
1069 got it already so we don't duplicate the bfd. */
1071 static lang_input_statement_type
*
1072 new_afile (const char *name
,
1073 lang_input_file_enum_type file_type
,
1075 bfd_boolean add_to_list
)
1077 lang_input_statement_type
*p
;
1079 lang_has_input_file
= TRUE
;
1082 p
= (lang_input_statement_type
*) new_stat (lang_input_statement
, stat_ptr
);
1085 p
= (lang_input_statement_type
*)
1086 stat_alloc (sizeof (lang_input_statement_type
));
1087 p
->header
.type
= lang_input_statement_enum
;
1088 p
->header
.next
= NULL
;
1091 memset (&p
->the_bfd
, 0,
1092 sizeof (*p
) - offsetof (lang_input_statement_type
, the_bfd
));
1094 p
->flags
.dynamic
= input_flags
.dynamic
;
1095 p
->flags
.add_DT_NEEDED_for_dynamic
= input_flags
.add_DT_NEEDED_for_dynamic
;
1096 p
->flags
.add_DT_NEEDED_for_regular
= input_flags
.add_DT_NEEDED_for_regular
;
1097 p
->flags
.whole_archive
= input_flags
.whole_archive
;
1098 p
->flags
.sysrooted
= input_flags
.sysrooted
;
1102 case lang_input_file_is_symbols_only_enum
:
1104 p
->local_sym_name
= name
;
1105 p
->flags
.real
= TRUE
;
1106 p
->flags
.just_syms
= TRUE
;
1108 case lang_input_file_is_fake_enum
:
1110 p
->local_sym_name
= name
;
1112 case lang_input_file_is_l_enum
:
1113 if (name
[0] == ':' && name
[1] != '\0')
1115 p
->filename
= name
+ 1;
1116 p
->flags
.full_name_provided
= TRUE
;
1120 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
1121 p
->flags
.maybe_archive
= TRUE
;
1122 p
->flags
.real
= TRUE
;
1123 p
->flags
.search_dirs
= TRUE
;
1125 case lang_input_file_is_marker_enum
:
1127 p
->local_sym_name
= name
;
1128 p
->flags
.search_dirs
= TRUE
;
1130 case lang_input_file_is_search_file_enum
:
1132 p
->local_sym_name
= name
;
1133 p
->flags
.real
= TRUE
;
1134 p
->flags
.search_dirs
= TRUE
;
1136 case lang_input_file_is_file_enum
:
1138 p
->local_sym_name
= name
;
1139 p
->flags
.real
= TRUE
;
1145 lang_statement_append (&input_file_chain
,
1146 (lang_statement_union_type
*) p
,
1147 &p
->next_real_file
);
1151 lang_input_statement_type
*
1152 lang_add_input_file (const char *name
,
1153 lang_input_file_enum_type file_type
,
1157 && (*name
== '=' || CONST_STRNEQ (name
, "$SYSROOT")))
1159 lang_input_statement_type
*ret
;
1160 char *sysrooted_name
1161 = concat (ld_sysroot
,
1162 name
+ (*name
== '=' ? 1 : strlen ("$SYSROOT")),
1163 (const char *) NULL
);
1165 /* We've now forcibly prepended the sysroot, making the input
1166 file independent of the context. Therefore, temporarily
1167 force a non-sysrooted context for this statement, so it won't
1168 get the sysroot prepended again when opened. (N.B. if it's a
1169 script, any child nodes with input files starting with "/"
1170 will be handled as "sysrooted" as they'll be found to be
1171 within the sysroot subdirectory.) */
1172 unsigned int outer_sysrooted
= input_flags
.sysrooted
;
1173 input_flags
.sysrooted
= 0;
1174 ret
= new_afile (sysrooted_name
, file_type
, target
, TRUE
);
1175 input_flags
.sysrooted
= outer_sysrooted
;
1179 return new_afile (name
, file_type
, target
, TRUE
);
1182 struct out_section_hash_entry
1184 struct bfd_hash_entry root
;
1185 lang_statement_union_type s
;
1188 /* The hash table. */
1190 static struct bfd_hash_table output_section_statement_table
;
1192 /* Support routines for the hash table used by lang_output_section_find,
1193 initialize the table, fill in an entry and remove the table. */
1195 static struct bfd_hash_entry
*
1196 output_section_statement_newfunc (struct bfd_hash_entry
*entry
,
1197 struct bfd_hash_table
*table
,
1200 lang_output_section_statement_type
**nextp
;
1201 struct out_section_hash_entry
*ret
;
1205 entry
= (struct bfd_hash_entry
*) bfd_hash_allocate (table
,
1211 entry
= bfd_hash_newfunc (entry
, table
, string
);
1215 ret
= (struct out_section_hash_entry
*) entry
;
1216 memset (&ret
->s
, 0, sizeof (ret
->s
));
1217 ret
->s
.header
.type
= lang_output_section_statement_enum
;
1218 ret
->s
.output_section_statement
.subsection_alignment
= NULL
;
1219 ret
->s
.output_section_statement
.section_alignment
= NULL
;
1220 ret
->s
.output_section_statement
.block_value
= 1;
1221 lang_list_init (&ret
->s
.output_section_statement
.children
);
1222 lang_statement_append (stat_ptr
, &ret
->s
, &ret
->s
.header
.next
);
1224 /* For every output section statement added to the list, except the
1225 first one, lang_os_list.tail points to the "next"
1226 field of the last element of the list. */
1227 if (lang_os_list
.head
!= NULL
)
1228 ret
->s
.output_section_statement
.prev
1229 = ((lang_output_section_statement_type
*)
1230 ((char *) lang_os_list
.tail
1231 - offsetof (lang_output_section_statement_type
, next
)));
1233 /* GCC's strict aliasing rules prevent us from just casting the
1234 address, so we store the pointer in a variable and cast that
1236 nextp
= &ret
->s
.output_section_statement
.next
;
1237 lang_statement_append (&lang_os_list
,
1239 (lang_statement_union_type
**) nextp
);
1244 output_section_statement_table_init (void)
1246 if (!bfd_hash_table_init_n (&output_section_statement_table
,
1247 output_section_statement_newfunc
,
1248 sizeof (struct out_section_hash_entry
),
1250 einfo (_("%F%P: can not create hash table: %E\n"));
1254 output_section_statement_table_free (void)
1256 bfd_hash_table_free (&output_section_statement_table
);
1259 /* Build enough state so that the parser can build its tree. */
1264 obstack_begin (&stat_obstack
, 1000);
1266 stat_ptr
= &statement_list
;
1268 output_section_statement_table_init ();
1270 lang_list_init (stat_ptr
);
1272 lang_list_init (&input_file_chain
);
1273 lang_list_init (&lang_os_list
);
1274 lang_list_init (&file_chain
);
1275 first_file
= lang_add_input_file (NULL
, lang_input_file_is_marker_enum
,
1277 abs_output_section
=
1278 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
, 0, TRUE
);
1280 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
1282 asneeded_list_head
= NULL
;
1283 asneeded_list_tail
= &asneeded_list_head
;
1289 output_section_statement_table_free ();
1292 /*----------------------------------------------------------------------
1293 A region is an area of memory declared with the
1294 MEMORY { name:org=exp, len=exp ... }
1297 We maintain a list of all the regions here.
1299 If no regions are specified in the script, then the default is used
1300 which is created when looked up to be the entire data space.
1302 If create is true we are creating a region inside a MEMORY block.
1303 In this case it is probably an error to create a region that has
1304 already been created. If we are not inside a MEMORY block it is
1305 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1306 and so we issue a warning.
1308 Each region has at least one name. The first name is either
1309 DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add
1310 alias names to an existing region within a script with
1311 REGION_ALIAS (alias, region_name). Each name corresponds to at most one
1314 static lang_memory_region_type
*lang_memory_region_list
;
1315 static lang_memory_region_type
**lang_memory_region_list_tail
1316 = &lang_memory_region_list
;
1318 lang_memory_region_type
*
1319 lang_memory_region_lookup (const char *const name
, bfd_boolean create
)
1321 lang_memory_region_name
*n
;
1322 lang_memory_region_type
*r
;
1323 lang_memory_region_type
*new_region
;
1325 /* NAME is NULL for LMA memspecs if no region was specified. */
1329 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1330 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1331 if (strcmp (n
->name
, name
) == 0)
1334 einfo (_("%P:%pS: warning: redeclaration of memory region `%s'\n"),
1339 if (!create
&& strcmp (name
, DEFAULT_MEMORY_REGION
))
1340 einfo (_("%P:%pS: warning: memory region `%s' not declared\n"),
1343 new_region
= (lang_memory_region_type
*)
1344 stat_alloc (sizeof (lang_memory_region_type
));
1346 new_region
->name_list
.name
= xstrdup (name
);
1347 new_region
->name_list
.next
= NULL
;
1348 new_region
->next
= NULL
;
1349 new_region
->origin_exp
= NULL
;
1350 new_region
->origin
= 0;
1351 new_region
->length_exp
= NULL
;
1352 new_region
->length
= ~(bfd_size_type
) 0;
1353 new_region
->current
= 0;
1354 new_region
->last_os
= NULL
;
1355 new_region
->flags
= 0;
1356 new_region
->not_flags
= 0;
1357 new_region
->had_full_message
= FALSE
;
1359 *lang_memory_region_list_tail
= new_region
;
1360 lang_memory_region_list_tail
= &new_region
->next
;
1366 lang_memory_region_alias (const char *alias
, const char *region_name
)
1368 lang_memory_region_name
*n
;
1369 lang_memory_region_type
*r
;
1370 lang_memory_region_type
*region
;
1372 /* The default region must be unique. This ensures that it is not necessary
1373 to iterate through the name list if someone wants the check if a region is
1374 the default memory region. */
1375 if (strcmp (region_name
, DEFAULT_MEMORY_REGION
) == 0
1376 || strcmp (alias
, DEFAULT_MEMORY_REGION
) == 0)
1377 einfo (_("%F%P:%pS: error: alias for default memory region\n"), NULL
);
1379 /* Look for the target region and check if the alias is not already
1382 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1383 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1385 if (region
== NULL
&& strcmp (n
->name
, region_name
) == 0)
1387 if (strcmp (n
->name
, alias
) == 0)
1388 einfo (_("%F%P:%pS: error: redefinition of memory region "
1393 /* Check if the target region exists. */
1395 einfo (_("%F%P:%pS: error: memory region `%s' "
1396 "for alias `%s' does not exist\n"),
1397 NULL
, region_name
, alias
);
1399 /* Add alias to region name list. */
1400 n
= (lang_memory_region_name
*) stat_alloc (sizeof (lang_memory_region_name
));
1401 n
->name
= xstrdup (alias
);
1402 n
->next
= region
->name_list
.next
;
1403 region
->name_list
.next
= n
;
1406 static lang_memory_region_type
*
1407 lang_memory_default (asection
*section
)
1409 lang_memory_region_type
*p
;
1411 flagword sec_flags
= section
->flags
;
1413 /* Override SEC_DATA to mean a writable section. */
1414 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
1415 sec_flags
|= SEC_DATA
;
1417 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
1419 if ((p
->flags
& sec_flags
) != 0
1420 && (p
->not_flags
& sec_flags
) == 0)
1425 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
1428 /* Get the output section statement directly from the userdata. */
1430 lang_output_section_statement_type
*
1431 lang_output_section_get (const asection
*output_section
)
1433 return get_userdata (output_section
);
1436 /* Find or create an output_section_statement with the given NAME.
1437 If CONSTRAINT is non-zero match one with that constraint, otherwise
1438 match any non-negative constraint. If CREATE, always make a
1439 new output_section_statement for SPECIAL CONSTRAINT. */
1441 lang_output_section_statement_type
*
1442 lang_output_section_statement_lookup (const char *name
,
1446 struct out_section_hash_entry
*entry
;
1448 entry
= ((struct out_section_hash_entry
*)
1449 bfd_hash_lookup (&output_section_statement_table
, name
,
1454 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1458 if (entry
->s
.output_section_statement
.name
!= NULL
)
1460 /* We have a section of this name, but it might not have the correct
1462 struct out_section_hash_entry
*last_ent
;
1464 name
= entry
->s
.output_section_statement
.name
;
1465 if (create
&& constraint
== SPECIAL
)
1466 /* Not traversing to the end reverses the order of the second
1467 and subsequent SPECIAL sections in the hash table chain,
1468 but that shouldn't matter. */
1473 if (constraint
== entry
->s
.output_section_statement
.constraint
1475 && entry
->s
.output_section_statement
.constraint
>= 0))
1476 return &entry
->s
.output_section_statement
;
1478 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1480 while (entry
!= NULL
1481 && name
== entry
->s
.output_section_statement
.name
);
1487 = ((struct out_section_hash_entry
*)
1488 output_section_statement_newfunc (NULL
,
1489 &output_section_statement_table
,
1493 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1496 entry
->root
= last_ent
->root
;
1497 last_ent
->root
.next
= &entry
->root
;
1500 entry
->s
.output_section_statement
.name
= name
;
1501 entry
->s
.output_section_statement
.constraint
= constraint
;
1502 return &entry
->s
.output_section_statement
;
1505 /* Find the next output_section_statement with the same name as OS.
1506 If CONSTRAINT is non-zero, find one with that constraint otherwise
1507 match any non-negative constraint. */
1509 lang_output_section_statement_type
*
1510 next_matching_output_section_statement (lang_output_section_statement_type
*os
,
1513 /* All output_section_statements are actually part of a
1514 struct out_section_hash_entry. */
1515 struct out_section_hash_entry
*entry
= (struct out_section_hash_entry
*)
1517 - offsetof (struct out_section_hash_entry
, s
.output_section_statement
));
1518 const char *name
= os
->name
;
1520 ASSERT (name
== entry
->root
.string
);
1523 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1525 || name
!= entry
->s
.output_section_statement
.name
)
1528 while (constraint
!= entry
->s
.output_section_statement
.constraint
1530 || entry
->s
.output_section_statement
.constraint
< 0));
1532 return &entry
->s
.output_section_statement
;
1535 /* A variant of lang_output_section_find used by place_orphan.
1536 Returns the output statement that should precede a new output
1537 statement for SEC. If an exact match is found on certain flags,
1540 lang_output_section_statement_type
*
1541 lang_output_section_find_by_flags (const asection
*sec
,
1543 lang_output_section_statement_type
**exact
,
1544 lang_match_sec_type_func match_type
)
1546 lang_output_section_statement_type
*first
, *look
, *found
;
1547 flagword look_flags
, differ
;
1549 /* We know the first statement on this list is *ABS*. May as well
1551 first
= &lang_os_list
.head
->output_section_statement
;
1552 first
= first
->next
;
1554 /* First try for an exact match. */
1556 for (look
= first
; look
; look
= look
->next
)
1558 look_flags
= look
->flags
;
1559 if (look
->bfd_section
!= NULL
)
1561 look_flags
= look
->bfd_section
->flags
;
1562 if (match_type
&& !match_type (link_info
.output_bfd
,
1567 differ
= look_flags
^ sec_flags
;
1568 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1569 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1579 if ((sec_flags
& SEC_CODE
) != 0
1580 && (sec_flags
& SEC_ALLOC
) != 0)
1582 /* Try for a rw code section. */
1583 for (look
= first
; look
; look
= look
->next
)
1585 look_flags
= look
->flags
;
1586 if (look
->bfd_section
!= NULL
)
1588 look_flags
= look
->bfd_section
->flags
;
1589 if (match_type
&& !match_type (link_info
.output_bfd
,
1594 differ
= look_flags
^ sec_flags
;
1595 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1596 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1600 else if ((sec_flags
& SEC_READONLY
) != 0
1601 && (sec_flags
& SEC_ALLOC
) != 0)
1603 /* .rodata can go after .text, .sdata2 after .rodata. */
1604 for (look
= first
; look
; look
= look
->next
)
1606 look_flags
= look
->flags
;
1607 if (look
->bfd_section
!= NULL
)
1609 look_flags
= look
->bfd_section
->flags
;
1610 if (match_type
&& !match_type (link_info
.output_bfd
,
1615 differ
= look_flags
^ sec_flags
;
1616 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1617 | SEC_READONLY
| SEC_SMALL_DATA
))
1618 || (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1620 && !(look_flags
& SEC_SMALL_DATA
)))
1624 else if ((sec_flags
& SEC_THREAD_LOCAL
) != 0
1625 && (sec_flags
& SEC_ALLOC
) != 0)
1627 /* .tdata can go after .data, .tbss after .tdata. Treat .tbss
1628 as if it were a loaded section, and don't use match_type. */
1629 bfd_boolean seen_thread_local
= FALSE
;
1632 for (look
= first
; look
; look
= look
->next
)
1634 look_flags
= look
->flags
;
1635 if (look
->bfd_section
!= NULL
)
1636 look_flags
= look
->bfd_section
->flags
;
1638 differ
= look_flags
^ (sec_flags
| SEC_LOAD
| SEC_HAS_CONTENTS
);
1639 if (!(differ
& (SEC_THREAD_LOCAL
| SEC_ALLOC
)))
1641 /* .tdata and .tbss must be adjacent and in that order. */
1642 if (!(look_flags
& SEC_LOAD
)
1643 && (sec_flags
& SEC_LOAD
))
1644 /* ..so if we're at a .tbss section and we're placing
1645 a .tdata section stop looking and return the
1646 previous section. */
1649 seen_thread_local
= TRUE
;
1651 else if (seen_thread_local
)
1653 else if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
)))
1657 else if ((sec_flags
& SEC_SMALL_DATA
) != 0
1658 && (sec_flags
& SEC_ALLOC
) != 0)
1660 /* .sdata goes after .data, .sbss after .sdata. */
1661 for (look
= first
; look
; look
= look
->next
)
1663 look_flags
= look
->flags
;
1664 if (look
->bfd_section
!= NULL
)
1666 look_flags
= look
->bfd_section
->flags
;
1667 if (match_type
&& !match_type (link_info
.output_bfd
,
1672 differ
= look_flags
^ sec_flags
;
1673 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1674 | SEC_THREAD_LOCAL
))
1675 || ((look_flags
& SEC_SMALL_DATA
)
1676 && !(sec_flags
& SEC_HAS_CONTENTS
)))
1680 else if ((sec_flags
& SEC_HAS_CONTENTS
) != 0
1681 && (sec_flags
& SEC_ALLOC
) != 0)
1683 /* .data goes after .rodata. */
1684 for (look
= first
; look
; look
= look
->next
)
1686 look_flags
= look
->flags
;
1687 if (look
->bfd_section
!= NULL
)
1689 look_flags
= look
->bfd_section
->flags
;
1690 if (match_type
&& !match_type (link_info
.output_bfd
,
1695 differ
= look_flags
^ sec_flags
;
1696 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1697 | SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1701 else if ((sec_flags
& SEC_ALLOC
) != 0)
1703 /* .bss goes after any other alloc section. */
1704 for (look
= first
; look
; look
= look
->next
)
1706 look_flags
= look
->flags
;
1707 if (look
->bfd_section
!= NULL
)
1709 look_flags
= look
->bfd_section
->flags
;
1710 if (match_type
&& !match_type (link_info
.output_bfd
,
1715 differ
= look_flags
^ sec_flags
;
1716 if (!(differ
& SEC_ALLOC
))
1722 /* non-alloc go last. */
1723 for (look
= first
; look
; look
= look
->next
)
1725 look_flags
= look
->flags
;
1726 if (look
->bfd_section
!= NULL
)
1727 look_flags
= look
->bfd_section
->flags
;
1728 differ
= look_flags
^ sec_flags
;
1729 if (!(differ
& SEC_DEBUGGING
))
1735 if (found
|| !match_type
)
1738 return lang_output_section_find_by_flags (sec
, sec_flags
, NULL
, NULL
);
1741 /* Find the last output section before given output statement.
1742 Used by place_orphan. */
1745 output_prev_sec_find (lang_output_section_statement_type
*os
)
1747 lang_output_section_statement_type
*lookup
;
1749 for (lookup
= os
->prev
; lookup
!= NULL
; lookup
= lookup
->prev
)
1751 if (lookup
->constraint
< 0)
1754 if (lookup
->bfd_section
!= NULL
&& lookup
->bfd_section
->owner
!= NULL
)
1755 return lookup
->bfd_section
;
1761 /* Look for a suitable place for a new output section statement. The
1762 idea is to skip over anything that might be inside a SECTIONS {}
1763 statement in a script, before we find another output section
1764 statement. Assignments to "dot" before an output section statement
1765 are assumed to belong to it, except in two cases; The first
1766 assignment to dot, and assignments before non-alloc sections.
1767 Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
1768 similar assignments that set the initial address, or we might
1769 insert non-alloc note sections among assignments setting end of
1772 static lang_statement_union_type
**
1773 insert_os_after (lang_output_section_statement_type
*after
)
1775 lang_statement_union_type
**where
;
1776 lang_statement_union_type
**assign
= NULL
;
1777 bfd_boolean ignore_first
;
1779 ignore_first
= after
== &lang_os_list
.head
->output_section_statement
;
1781 for (where
= &after
->header
.next
;
1783 where
= &(*where
)->header
.next
)
1785 switch ((*where
)->header
.type
)
1787 case lang_assignment_statement_enum
:
1790 lang_assignment_statement_type
*ass
;
1792 ass
= &(*where
)->assignment_statement
;
1793 if (ass
->exp
->type
.node_class
!= etree_assert
1794 && ass
->exp
->assign
.dst
[0] == '.'
1795 && ass
->exp
->assign
.dst
[1] == 0)
1799 ignore_first
= FALSE
;
1803 case lang_wild_statement_enum
:
1804 case lang_input_section_enum
:
1805 case lang_object_symbols_statement_enum
:
1806 case lang_fill_statement_enum
:
1807 case lang_data_statement_enum
:
1808 case lang_reloc_statement_enum
:
1809 case lang_padding_statement_enum
:
1810 case lang_constructors_statement_enum
:
1812 ignore_first
= FALSE
;
1814 case lang_output_section_statement_enum
:
1817 asection
*s
= (*where
)->output_section_statement
.bfd_section
;
1820 || s
->map_head
.s
== NULL
1821 || (s
->flags
& SEC_ALLOC
) != 0)
1825 case lang_input_statement_enum
:
1826 case lang_address_statement_enum
:
1827 case lang_target_statement_enum
:
1828 case lang_output_statement_enum
:
1829 case lang_group_statement_enum
:
1830 case lang_insert_statement_enum
:
1839 lang_output_section_statement_type
*
1840 lang_insert_orphan (asection
*s
,
1841 const char *secname
,
1843 lang_output_section_statement_type
*after
,
1844 struct orphan_save
*place
,
1845 etree_type
*address
,
1846 lang_statement_list_type
*add_child
)
1848 lang_statement_list_type add
;
1849 lang_output_section_statement_type
*os
;
1850 lang_output_section_statement_type
**os_tail
;
1852 /* If we have found an appropriate place for the output section
1853 statements for this orphan, add them to our own private list,
1854 inserting them later into the global statement list. */
1857 lang_list_init (&add
);
1858 push_stat_ptr (&add
);
1861 if (bfd_link_relocatable (&link_info
)
1862 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
1863 address
= exp_intop (0);
1865 os_tail
= (lang_output_section_statement_type
**) lang_os_list
.tail
;
1866 os
= lang_enter_output_section_statement (secname
, address
, normal_section
,
1867 NULL
, NULL
, NULL
, constraint
, 0);
1869 if (add_child
== NULL
)
1870 add_child
= &os
->children
;
1871 lang_add_section (add_child
, s
, NULL
, os
);
1873 if (after
&& (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) != 0)
1875 const char *region
= (after
->region
1876 ? after
->region
->name_list
.name
1877 : DEFAULT_MEMORY_REGION
);
1878 const char *lma_region
= (after
->lma_region
1879 ? after
->lma_region
->name_list
.name
1881 lang_leave_output_section_statement (NULL
, region
, after
->phdrs
,
1885 lang_leave_output_section_statement (NULL
, DEFAULT_MEMORY_REGION
, NULL
,
1888 /* Restore the global list pointer. */
1892 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
1894 asection
*snew
, *as
;
1895 bfd_boolean place_after
= place
->stmt
== NULL
;
1896 bfd_boolean insert_after
= TRUE
;
1898 snew
= os
->bfd_section
;
1900 /* Shuffle the bfd section list to make the output file look
1901 neater. This is really only cosmetic. */
1902 if (place
->section
== NULL
1903 && after
!= &lang_os_list
.head
->output_section_statement
)
1905 asection
*bfd_section
= after
->bfd_section
;
1907 /* If the output statement hasn't been used to place any input
1908 sections (and thus doesn't have an output bfd_section),
1909 look for the closest prior output statement having an
1911 if (bfd_section
== NULL
)
1912 bfd_section
= output_prev_sec_find (after
);
1914 if (bfd_section
!= NULL
&& bfd_section
!= snew
)
1915 place
->section
= &bfd_section
->next
;
1918 if (place
->section
== NULL
)
1919 place
->section
= &link_info
.output_bfd
->sections
;
1921 as
= *place
->section
;
1925 /* Put the section at the end of the list. */
1927 /* Unlink the section. */
1928 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1930 /* Now tack it back on in the right place. */
1931 bfd_section_list_append (link_info
.output_bfd
, snew
);
1933 else if ((bfd_get_flavour (link_info
.output_bfd
)
1934 == bfd_target_elf_flavour
)
1935 && (bfd_get_flavour (s
->owner
)
1936 == bfd_target_elf_flavour
)
1937 && ((elf_section_type (s
) == SHT_NOTE
1938 && (s
->flags
& SEC_LOAD
) != 0)
1939 || (elf_section_type (as
) == SHT_NOTE
1940 && (as
->flags
& SEC_LOAD
) != 0)))
1942 /* Make sure that output note sections are grouped and sorted
1943 by alignments when inserting a note section or insert a
1944 section after a note section, */
1946 /* A specific section after which the output note section
1947 should be placed. */
1948 asection
*after_sec
;
1949 /* True if we need to insert the orphan section after a
1950 specific section to maintain output note section order. */
1951 bfd_boolean after_sec_note
= FALSE
;
1953 static asection
*first_orphan_note
= NULL
;
1955 /* Group and sort output note section by alignments in
1958 if (elf_section_type (s
) == SHT_NOTE
1959 && (s
->flags
& SEC_LOAD
) != 0)
1961 /* Search from the beginning for the last output note
1962 section with equal or larger alignments. NB: Don't
1963 place orphan note section after non-note sections. */
1965 first_orphan_note
= NULL
;
1966 for (sec
= link_info
.output_bfd
->sections
;
1968 && !bfd_is_abs_section (sec
));
1971 && elf_section_type (sec
) == SHT_NOTE
1972 && (sec
->flags
& SEC_LOAD
) != 0)
1974 if (!first_orphan_note
)
1975 first_orphan_note
= sec
;
1976 if (sec
->alignment_power
>= s
->alignment_power
)
1979 else if (first_orphan_note
)
1981 /* Stop if there is non-note section after the first
1982 orphan note section. */
1986 /* If this will be the first orphan note section, it can
1987 be placed at the default location. */
1988 after_sec_note
= first_orphan_note
!= NULL
;
1989 if (after_sec
== NULL
&& after_sec_note
)
1991 /* If all output note sections have smaller
1992 alignments, place the section before all
1993 output orphan note sections. */
1994 after_sec
= first_orphan_note
;
1995 insert_after
= FALSE
;
1998 else if (first_orphan_note
)
2000 /* Don't place non-note sections in the middle of orphan
2002 after_sec_note
= TRUE
;
2004 for (sec
= as
->next
;
2006 && !bfd_is_abs_section (sec
));
2008 if (elf_section_type (sec
) == SHT_NOTE
2009 && (sec
->flags
& SEC_LOAD
) != 0)
2017 /* Search forward to insert OS after AFTER_SEC output
2019 lang_output_section_statement_type
*stmt
, *next
;
2020 bfd_boolean found
= FALSE
;
2021 for (stmt
= after
; stmt
!= NULL
; stmt
= next
)
2026 if (stmt
->bfd_section
== after_sec
)
2036 /* If INSERT_AFTER is FALSE, place OS before
2037 AFTER_SEC output statement. */
2038 if (next
&& next
->bfd_section
== after_sec
)
2048 /* Search backward to insert OS after AFTER_SEC output
2051 for (stmt
= after
; stmt
!= NULL
; stmt
= stmt
->prev
)
2055 if (stmt
->bfd_section
== after_sec
)
2064 /* If INSERT_AFTER is FALSE, place OS before
2065 AFTER_SEC output statement. */
2066 if (stmt
->next
->bfd_section
== after_sec
)
2076 if (after_sec
== NULL
2077 || (insert_after
&& after_sec
->next
!= snew
)
2078 || (!insert_after
&& after_sec
->prev
!= snew
))
2080 /* Unlink the section. */
2081 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2083 /* Place SNEW after AFTER_SEC. If AFTER_SEC is NULL,
2088 bfd_section_list_insert_after (link_info
.output_bfd
,
2091 bfd_section_list_insert_before (link_info
.output_bfd
,
2095 bfd_section_list_prepend (link_info
.output_bfd
, snew
);
2098 else if (as
!= snew
&& as
->prev
!= snew
)
2100 /* Unlink the section. */
2101 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2103 /* Now tack it back on in the right place. */
2104 bfd_section_list_insert_before (link_info
.output_bfd
,
2108 else if (as
!= snew
&& as
->prev
!= snew
)
2110 /* Unlink the section. */
2111 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2113 /* Now tack it back on in the right place. */
2114 bfd_section_list_insert_before (link_info
.output_bfd
, as
, snew
);
2117 /* Save the end of this list. Further ophans of this type will
2118 follow the one we've just added. */
2119 place
->section
= &snew
->next
;
2121 /* The following is non-cosmetic. We try to put the output
2122 statements in some sort of reasonable order here, because they
2123 determine the final load addresses of the orphan sections.
2124 In addition, placing output statements in the wrong order may
2125 require extra segments. For instance, given a typical
2126 situation of all read-only sections placed in one segment and
2127 following that a segment containing all the read-write
2128 sections, we wouldn't want to place an orphan read/write
2129 section before or amongst the read-only ones. */
2130 if (add
.head
!= NULL
)
2132 lang_output_section_statement_type
*newly_added_os
;
2134 /* Place OS after AFTER if AFTER_NOTE is TRUE. */
2137 lang_statement_union_type
**where
= insert_os_after (after
);
2142 place
->os_tail
= &after
->next
;
2146 /* Put it after the last orphan statement we added. */
2147 *add
.tail
= *place
->stmt
;
2148 *place
->stmt
= add
.head
;
2151 /* Fix the global list pointer if we happened to tack our
2152 new list at the tail. */
2153 if (*stat_ptr
->tail
== add
.head
)
2154 stat_ptr
->tail
= add
.tail
;
2156 /* Save the end of this list. */
2157 place
->stmt
= add
.tail
;
2159 /* Do the same for the list of output section statements. */
2160 newly_added_os
= *os_tail
;
2162 newly_added_os
->prev
= (lang_output_section_statement_type
*)
2163 ((char *) place
->os_tail
2164 - offsetof (lang_output_section_statement_type
, next
));
2165 newly_added_os
->next
= *place
->os_tail
;
2166 if (newly_added_os
->next
!= NULL
)
2167 newly_added_os
->next
->prev
= newly_added_os
;
2168 *place
->os_tail
= newly_added_os
;
2169 place
->os_tail
= &newly_added_os
->next
;
2171 /* Fixing the global list pointer here is a little different.
2172 We added to the list in lang_enter_output_section_statement,
2173 trimmed off the new output_section_statment above when
2174 assigning *os_tail = NULL, but possibly added it back in
2175 the same place when assigning *place->os_tail. */
2176 if (*os_tail
== NULL
)
2177 lang_os_list
.tail
= (lang_statement_union_type
**) os_tail
;
2184 lang_print_asneeded (void)
2186 struct asneeded_minfo
*m
;
2188 if (asneeded_list_head
== NULL
)
2191 minfo (_("\nAs-needed library included to satisfy reference by file (symbol)\n\n"));
2193 for (m
= asneeded_list_head
; m
!= NULL
; m
= m
->next
)
2197 minfo ("%s", m
->soname
);
2198 len
= strlen (m
->soname
);
2212 minfo ("%pB ", m
->ref
);
2213 minfo ("(%pT)\n", m
->name
);
2218 lang_map_flags (flagword flag
)
2220 if (flag
& SEC_ALLOC
)
2223 if (flag
& SEC_CODE
)
2226 if (flag
& SEC_READONLY
)
2229 if (flag
& SEC_DATA
)
2232 if (flag
& SEC_LOAD
)
2239 lang_memory_region_type
*m
;
2240 bfd_boolean dis_header_printed
= FALSE
;
2242 LANG_FOR_EACH_INPUT_STATEMENT (file
)
2246 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
2247 || file
->flags
.just_syms
)
2250 if (config
.print_map_discarded
)
2251 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2252 if ((s
->output_section
== NULL
2253 || s
->output_section
->owner
!= link_info
.output_bfd
)
2254 && (s
->flags
& (SEC_LINKER_CREATED
| SEC_KEEP
)) == 0)
2256 if (! dis_header_printed
)
2258 fprintf (config
.map_file
, _("\nDiscarded input sections\n\n"));
2259 dis_header_printed
= TRUE
;
2262 print_input_section (s
, TRUE
);
2266 minfo (_("\nMemory Configuration\n\n"));
2267 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
2268 _("Name"), _("Origin"), _("Length"), _("Attributes"));
2270 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
2275 fprintf (config
.map_file
, "%-16s ", m
->name_list
.name
);
2277 sprintf_vma (buf
, m
->origin
);
2278 minfo ("0x%s ", buf
);
2286 minfo ("0x%V", m
->length
);
2287 if (m
->flags
|| m
->not_flags
)
2295 lang_map_flags (m
->flags
);
2301 lang_map_flags (m
->not_flags
);
2308 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
2310 if (!link_info
.reduce_memory_overheads
)
2312 obstack_begin (&map_obstack
, 1000);
2313 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
2315 expld
.phase
= lang_fixed_phase_enum
;
2316 lang_statement_iteration
++;
2317 print_statements ();
2319 ldemul_extra_map_file_text (link_info
.output_bfd
, &link_info
,
2324 sort_def_symbol (struct bfd_link_hash_entry
*hash_entry
,
2325 void *info ATTRIBUTE_UNUSED
)
2327 if ((hash_entry
->type
== bfd_link_hash_defined
2328 || hash_entry
->type
== bfd_link_hash_defweak
)
2329 && hash_entry
->u
.def
.section
->owner
!= link_info
.output_bfd
2330 && hash_entry
->u
.def
.section
->owner
!= NULL
)
2332 input_section_userdata_type
*ud
;
2333 struct map_symbol_def
*def
;
2335 ud
= ((input_section_userdata_type
*)
2336 get_userdata (hash_entry
->u
.def
.section
));
2339 ud
= (input_section_userdata_type
*) stat_alloc (sizeof (*ud
));
2340 get_userdata (hash_entry
->u
.def
.section
) = ud
;
2341 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2342 ud
->map_symbol_def_count
= 0;
2344 else if (!ud
->map_symbol_def_tail
)
2345 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2347 def
= (struct map_symbol_def
*) obstack_alloc (&map_obstack
, sizeof *def
);
2348 def
->entry
= hash_entry
;
2349 *(ud
->map_symbol_def_tail
) = def
;
2350 ud
->map_symbol_def_tail
= &def
->next
;
2351 ud
->map_symbol_def_count
++;
2356 /* Initialize an output section. */
2359 init_os (lang_output_section_statement_type
*s
, flagword flags
)
2361 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
2362 einfo (_("%F%P: illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
2364 if (s
->constraint
!= SPECIAL
)
2365 s
->bfd_section
= bfd_get_section_by_name (link_info
.output_bfd
, s
->name
);
2366 if (s
->bfd_section
== NULL
)
2367 s
->bfd_section
= bfd_make_section_anyway_with_flags (link_info
.output_bfd
,
2369 if (s
->bfd_section
== NULL
)
2371 einfo (_("%F%P: output format %s cannot represent section"
2372 " called %s: %E\n"),
2373 link_info
.output_bfd
->xvec
->name
, s
->name
);
2375 s
->bfd_section
->output_section
= s
->bfd_section
;
2376 s
->bfd_section
->output_offset
= 0;
2378 /* Set the userdata of the output section to the output section
2379 statement to avoid lookup. */
2380 get_userdata (s
->bfd_section
) = s
;
2382 /* If there is a base address, make sure that any sections it might
2383 mention are initialized. */
2384 if (s
->addr_tree
!= NULL
)
2385 exp_init_os (s
->addr_tree
);
2387 if (s
->load_base
!= NULL
)
2388 exp_init_os (s
->load_base
);
2390 /* If supplied an alignment, set it. */
2391 if (s
->section_alignment
!= NULL
)
2392 s
->bfd_section
->alignment_power
= exp_get_power (s
->section_alignment
,
2393 "section alignment");
2396 /* Make sure that all output sections mentioned in an expression are
2400 exp_init_os (etree_type
*exp
)
2402 switch (exp
->type
.node_class
)
2406 case etree_provided
:
2407 exp_init_os (exp
->assign
.src
);
2411 exp_init_os (exp
->binary
.lhs
);
2412 exp_init_os (exp
->binary
.rhs
);
2416 exp_init_os (exp
->trinary
.cond
);
2417 exp_init_os (exp
->trinary
.lhs
);
2418 exp_init_os (exp
->trinary
.rhs
);
2422 exp_init_os (exp
->assert_s
.child
);
2426 exp_init_os (exp
->unary
.child
);
2430 switch (exp
->type
.node_code
)
2436 lang_output_section_statement_type
*os
;
2438 os
= lang_output_section_find (exp
->name
.name
);
2439 if (os
!= NULL
&& os
->bfd_section
== NULL
)
2451 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
2453 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
2455 /* If we are only reading symbols from this object, then we want to
2456 discard all sections. */
2457 if (entry
->flags
.just_syms
)
2459 bfd_link_just_syms (abfd
, sec
, &link_info
);
2463 /* Deal with SHF_EXCLUDE ELF sections. */
2464 if (!bfd_link_relocatable (&link_info
)
2465 && (abfd
->flags
& BFD_PLUGIN
) == 0
2466 && (sec
->flags
& (SEC_GROUP
| SEC_KEEP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
2467 sec
->output_section
= bfd_abs_section_ptr
;
2469 if (!(abfd
->flags
& DYNAMIC
))
2470 bfd_section_already_linked (abfd
, sec
, &link_info
);
2474 /* Returns true if SECTION is one we know will be discarded based on its
2475 section flags, otherwise returns false. */
2478 lang_discard_section_p (asection
*section
)
2480 bfd_boolean discard
;
2481 flagword flags
= section
->flags
;
2483 /* Discard sections marked with SEC_EXCLUDE. */
2484 discard
= (flags
& SEC_EXCLUDE
) != 0;
2486 /* Discard the group descriptor sections when we're finally placing the
2487 sections from within the group. */
2488 if ((flags
& SEC_GROUP
) != 0
2489 && link_info
.resolve_section_groups
)
2492 /* Discard debugging sections if we are stripping debugging
2494 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
2495 && (flags
& SEC_DEBUGGING
) != 0)
2501 /* The wild routines.
2503 These expand statements like *(.text) and foo.o to a list of
2504 explicit actions, like foo.o(.text), bar.o(.text) and
2505 foo.o(.text, .data). */
2507 /* Add SECTION to the output section OUTPUT. Do this by creating a
2508 lang_input_section statement which is placed at PTR. */
2511 lang_add_section (lang_statement_list_type
*ptr
,
2513 struct flag_info
*sflag_info
,
2514 lang_output_section_statement_type
*output
)
2516 flagword flags
= section
->flags
;
2518 bfd_boolean discard
;
2519 lang_input_section_type
*new_section
;
2520 bfd
*abfd
= link_info
.output_bfd
;
2522 /* Is this section one we know should be discarded? */
2523 discard
= lang_discard_section_p (section
);
2525 /* Discard input sections which are assigned to a section named
2526 DISCARD_SECTION_NAME. */
2527 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
2532 if (section
->output_section
== NULL
)
2534 /* This prevents future calls from assigning this section. */
2535 section
->output_section
= bfd_abs_section_ptr
;
2544 keep
= bfd_lookup_section_flags (&link_info
, sflag_info
, section
);
2549 if (section
->output_section
!= NULL
)
2552 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2553 to an output section, because we want to be able to include a
2554 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2555 section (I don't know why we want to do this, but we do).
2556 build_link_order in ldwrite.c handles this case by turning
2557 the embedded SEC_NEVER_LOAD section into a fill. */
2558 flags
&= ~ SEC_NEVER_LOAD
;
2560 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2561 already been processed. One reason to do this is that on pe
2562 format targets, .text$foo sections go into .text and it's odd
2563 to see .text with SEC_LINK_ONCE set. */
2564 if ((flags
& (SEC_LINK_ONCE
| SEC_GROUP
)) == (SEC_LINK_ONCE
| SEC_GROUP
))
2566 if (link_info
.resolve_section_groups
)
2567 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2569 flags
&= ~(SEC_LINK_DUPLICATES
| SEC_RELOC
);
2571 else if (!bfd_link_relocatable (&link_info
))
2572 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2574 switch (output
->sectype
)
2576 case normal_section
:
2577 case overlay_section
:
2578 case first_overlay_section
:
2580 case noalloc_section
:
2581 flags
&= ~SEC_ALLOC
;
2583 case noload_section
:
2585 flags
|= SEC_NEVER_LOAD
;
2586 /* Unfortunately GNU ld has managed to evolve two different
2587 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2588 alloc, no contents section. All others get a noload, noalloc
2590 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
2591 flags
&= ~SEC_HAS_CONTENTS
;
2593 flags
&= ~SEC_ALLOC
;
2597 if (output
->bfd_section
== NULL
)
2598 init_os (output
, flags
);
2600 /* If SEC_READONLY is not set in the input section, then clear
2601 it from the output section. */
2602 output
->bfd_section
->flags
&= flags
| ~SEC_READONLY
;
2604 if (output
->bfd_section
->linker_has_input
)
2606 /* Only set SEC_READONLY flag on the first input section. */
2607 flags
&= ~ SEC_READONLY
;
2609 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2610 if ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2611 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2612 || ((flags
& SEC_MERGE
) != 0
2613 && output
->bfd_section
->entsize
!= section
->entsize
))
2615 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2616 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2619 output
->bfd_section
->flags
|= flags
;
2621 if (!output
->bfd_section
->linker_has_input
)
2623 output
->bfd_section
->linker_has_input
= 1;
2624 /* This must happen after flags have been updated. The output
2625 section may have been created before we saw its first input
2626 section, eg. for a data statement. */
2627 bfd_init_private_section_data (section
->owner
, section
,
2628 link_info
.output_bfd
,
2629 output
->bfd_section
,
2631 if ((flags
& SEC_MERGE
) != 0)
2632 output
->bfd_section
->entsize
= section
->entsize
;
2635 if ((flags
& SEC_TIC54X_BLOCK
) != 0
2636 && bfd_get_arch (section
->owner
) == bfd_arch_tic54x
)
2638 /* FIXME: This value should really be obtained from the bfd... */
2639 output
->block_value
= 128;
2642 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2643 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2645 section
->output_section
= output
->bfd_section
;
2647 if (!map_head_is_link_order
)
2649 asection
*s
= output
->bfd_section
->map_tail
.s
;
2650 output
->bfd_section
->map_tail
.s
= section
;
2651 section
->map_head
.s
= NULL
;
2652 section
->map_tail
.s
= s
;
2654 s
->map_head
.s
= section
;
2656 output
->bfd_section
->map_head
.s
= section
;
2659 /* Add a section reference to the list. */
2660 new_section
= new_stat (lang_input_section
, ptr
);
2661 new_section
->section
= section
;
2664 /* Handle wildcard sorting. This returns the lang_input_section which
2665 should follow the one we are going to create for SECTION and FILE,
2666 based on the sorting requirements of WILD. It returns NULL if the
2667 new section should just go at the end of the current list. */
2669 static lang_statement_union_type
*
2670 wild_sort (lang_wild_statement_type
*wild
,
2671 struct wildcard_list
*sec
,
2672 lang_input_statement_type
*file
,
2675 lang_statement_union_type
*l
;
2677 if (!wild
->filenames_sorted
2678 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
2681 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
2683 lang_input_section_type
*ls
;
2685 if (l
->header
.type
!= lang_input_section_enum
)
2687 ls
= &l
->input_section
;
2689 /* Sorting by filename takes precedence over sorting by section
2692 if (wild
->filenames_sorted
)
2694 const char *fn
, *ln
;
2698 /* The PE support for the .idata section as generated by
2699 dlltool assumes that files will be sorted by the name of
2700 the archive and then the name of the file within the
2703 if (file
->the_bfd
!= NULL
2704 && file
->the_bfd
->my_archive
!= NULL
)
2706 fn
= bfd_get_filename (file
->the_bfd
->my_archive
);
2711 fn
= file
->filename
;
2715 if (ls
->section
->owner
->my_archive
!= NULL
)
2717 ln
= bfd_get_filename (ls
->section
->owner
->my_archive
);
2722 ln
= ls
->section
->owner
->filename
;
2726 i
= filename_cmp (fn
, ln
);
2735 fn
= file
->filename
;
2737 ln
= ls
->section
->owner
->filename
;
2739 i
= filename_cmp (fn
, ln
);
2747 /* Here either the files are not sorted by name, or we are
2748 looking at the sections for this file. */
2751 && sec
->spec
.sorted
!= none
2752 && sec
->spec
.sorted
!= by_none
)
2753 if (compare_section (sec
->spec
.sorted
, section
, ls
->section
) < 0)
2760 /* Expand a wild statement for a particular FILE. SECTION may be
2761 NULL, in which case it is a wild card. */
2764 output_section_callback (lang_wild_statement_type
*ptr
,
2765 struct wildcard_list
*sec
,
2767 struct flag_info
*sflag_info
,
2768 lang_input_statement_type
*file
,
2771 lang_statement_union_type
*before
;
2772 lang_output_section_statement_type
*os
;
2774 os
= (lang_output_section_statement_type
*) output
;
2776 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2777 if (unique_section_p (section
, os
))
2780 before
= wild_sort (ptr
, sec
, file
, section
);
2782 /* Here BEFORE points to the lang_input_section which
2783 should follow the one we are about to add. If BEFORE
2784 is NULL, then the section should just go at the end
2785 of the current list. */
2788 lang_add_section (&ptr
->children
, section
, sflag_info
, os
);
2791 lang_statement_list_type list
;
2792 lang_statement_union_type
**pp
;
2794 lang_list_init (&list
);
2795 lang_add_section (&list
, section
, sflag_info
, os
);
2797 /* If we are discarding the section, LIST.HEAD will
2799 if (list
.head
!= NULL
)
2801 ASSERT (list
.head
->header
.next
== NULL
);
2803 for (pp
= &ptr
->children
.head
;
2805 pp
= &(*pp
)->header
.next
)
2806 ASSERT (*pp
!= NULL
);
2808 list
.head
->header
.next
= *pp
;
2814 /* Check if all sections in a wild statement for a particular FILE
2818 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2819 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2821 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
2822 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2825 lang_output_section_statement_type
*os
;
2827 os
= (lang_output_section_statement_type
*) output
;
2829 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2830 if (unique_section_p (section
, os
))
2833 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2834 os
->all_input_readonly
= FALSE
;
2837 /* This is passed a file name which must have been seen already and
2838 added to the statement tree. We will see if it has been opened
2839 already and had its symbols read. If not then we'll read it. */
2841 static lang_input_statement_type
*
2842 lookup_name (const char *name
)
2844 lang_input_statement_type
*search
;
2846 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
2848 search
= (lang_input_statement_type
*) search
->next_real_file
)
2850 /* Use the local_sym_name as the name of the file that has
2851 already been loaded as filename might have been transformed
2852 via the search directory lookup mechanism. */
2853 const char *filename
= search
->local_sym_name
;
2855 if (filename
!= NULL
2856 && filename_cmp (filename
, name
) == 0)
2861 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2862 default_target
, FALSE
);
2864 /* If we have already added this file, or this file is not real
2865 don't add this file. */
2866 if (search
->flags
.loaded
|| !search
->flags
.real
)
2869 if (!load_symbols (search
, NULL
))
2875 /* Save LIST as a list of libraries whose symbols should not be exported. */
2880 struct excluded_lib
*next
;
2882 static struct excluded_lib
*excluded_libs
;
2885 add_excluded_libs (const char *list
)
2887 const char *p
= list
, *end
;
2891 struct excluded_lib
*entry
;
2892 end
= strpbrk (p
, ",:");
2894 end
= p
+ strlen (p
);
2895 entry
= (struct excluded_lib
*) xmalloc (sizeof (*entry
));
2896 entry
->next
= excluded_libs
;
2897 entry
->name
= (char *) xmalloc (end
- p
+ 1);
2898 memcpy (entry
->name
, p
, end
- p
);
2899 entry
->name
[end
- p
] = '\0';
2900 excluded_libs
= entry
;
2908 check_excluded_libs (bfd
*abfd
)
2910 struct excluded_lib
*lib
= excluded_libs
;
2914 int len
= strlen (lib
->name
);
2915 const char *filename
= lbasename (abfd
->filename
);
2917 if (strcmp (lib
->name
, "ALL") == 0)
2919 abfd
->no_export
= TRUE
;
2923 if (filename_ncmp (lib
->name
, filename
, len
) == 0
2924 && (filename
[len
] == '\0'
2925 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
2926 && filename
[len
+ 2] == '\0')))
2928 abfd
->no_export
= TRUE
;
2936 /* Get the symbols for an input file. */
2939 load_symbols (lang_input_statement_type
*entry
,
2940 lang_statement_list_type
*place
)
2944 if (entry
->flags
.loaded
)
2947 ldfile_open_file (entry
);
2949 /* Do not process further if the file was missing. */
2950 if (entry
->flags
.missing_file
)
2953 if (trace_files
|| verbose
)
2954 info_msg ("%pI\n", entry
);
2956 if (!bfd_check_format (entry
->the_bfd
, bfd_archive
)
2957 && !bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
2960 struct lang_input_statement_flags save_flags
;
2963 err
= bfd_get_error ();
2965 /* See if the emulation has some special knowledge. */
2966 if (ldemul_unrecognized_file (entry
))
2969 if (err
== bfd_error_file_ambiguously_recognized
)
2973 einfo (_("%P: %pB: file not recognized: %E;"
2974 " matching formats:"), entry
->the_bfd
);
2975 for (p
= matching
; *p
!= NULL
; p
++)
2979 else if (err
!= bfd_error_file_not_recognized
2981 einfo (_("%F%P: %pB: file not recognized: %E\n"), entry
->the_bfd
);
2983 bfd_close (entry
->the_bfd
);
2984 entry
->the_bfd
= NULL
;
2986 /* Try to interpret the file as a linker script. */
2987 save_flags
= input_flags
;
2988 ldfile_open_command_file (entry
->filename
);
2990 push_stat_ptr (place
);
2991 input_flags
.add_DT_NEEDED_for_regular
2992 = entry
->flags
.add_DT_NEEDED_for_regular
;
2993 input_flags
.add_DT_NEEDED_for_dynamic
2994 = entry
->flags
.add_DT_NEEDED_for_dynamic
;
2995 input_flags
.whole_archive
= entry
->flags
.whole_archive
;
2996 input_flags
.dynamic
= entry
->flags
.dynamic
;
2998 ldfile_assumed_script
= TRUE
;
2999 parser_input
= input_script
;
3001 ldfile_assumed_script
= FALSE
;
3003 /* missing_file is sticky. sysrooted will already have been
3004 restored when seeing EOF in yyparse, but no harm to restore
3006 save_flags
.missing_file
|= input_flags
.missing_file
;
3007 input_flags
= save_flags
;
3011 entry
->flags
.loaded
= TRUE
;
3016 if (ldemul_recognized_file (entry
))
3019 /* We don't call ldlang_add_file for an archive. Instead, the
3020 add_symbols entry point will call ldlang_add_file, via the
3021 add_archive_element callback, for each element of the archive
3023 switch (bfd_get_format (entry
->the_bfd
))
3029 if (!entry
->flags
.reload
)
3030 ldlang_add_file (entry
);
3034 check_excluded_libs (entry
->the_bfd
);
3036 entry
->the_bfd
->usrdata
= entry
;
3037 if (entry
->flags
.whole_archive
)
3040 bfd_boolean loaded
= TRUE
;
3045 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
3050 if (!bfd_check_format (member
, bfd_object
))
3052 einfo (_("%F%P: %pB: member %pB in archive is not an object\n"),
3053 entry
->the_bfd
, member
);
3058 if (!(*link_info
.callbacks
3059 ->add_archive_element
) (&link_info
, member
,
3060 "--whole-archive", &subsbfd
))
3063 /* Potentially, the add_archive_element hook may have set a
3064 substitute BFD for us. */
3065 if (!bfd_link_add_symbols (subsbfd
, &link_info
))
3067 einfo (_("%F%P: %pB: error adding symbols: %E\n"), member
);
3072 entry
->flags
.loaded
= loaded
;
3078 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
3079 entry
->flags
.loaded
= TRUE
;
3081 einfo (_("%F%P: %pB: error adding symbols: %E\n"), entry
->the_bfd
);
3083 return entry
->flags
.loaded
;
3086 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
3087 may be NULL, indicating that it is a wildcard. Separate
3088 lang_input_section statements are created for each part of the
3089 expansion; they are added after the wild statement S. OUTPUT is
3090 the output section. */
3093 wild (lang_wild_statement_type
*s
,
3094 const char *target ATTRIBUTE_UNUSED
,
3095 lang_output_section_statement_type
*output
)
3097 struct wildcard_list
*sec
;
3099 if (s
->handler_data
[0]
3100 && s
->handler_data
[0]->spec
.sorted
== by_name
3101 && !s
->filenames_sorted
)
3103 lang_section_bst_type
*tree
;
3105 walk_wild (s
, output_section_callback_fast
, output
);
3110 output_section_callback_tree_to_list (s
, tree
, output
);
3115 walk_wild (s
, output_section_callback
, output
);
3117 if (default_common_section
== NULL
)
3118 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
3119 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
3121 /* Remember the section that common is going to in case we
3122 later get something which doesn't know where to put it. */
3123 default_common_section
= output
;
3128 /* Return TRUE iff target is the sought target. */
3131 get_target (const bfd_target
*target
, void *data
)
3133 const char *sought
= (const char *) data
;
3135 return strcmp (target
->name
, sought
) == 0;
3138 /* Like strcpy() but convert to lower case as well. */
3141 stricpy (char *dest
, char *src
)
3145 while ((c
= *src
++) != 0)
3146 *dest
++ = TOLOWER (c
);
3151 /* Remove the first occurrence of needle (if any) in haystack
3155 strcut (char *haystack
, char *needle
)
3157 haystack
= strstr (haystack
, needle
);
3163 for (src
= haystack
+ strlen (needle
); *src
;)
3164 *haystack
++ = *src
++;
3170 /* Compare two target format name strings.
3171 Return a value indicating how "similar" they are. */
3174 name_compare (char *first
, char *second
)
3180 copy1
= (char *) xmalloc (strlen (first
) + 1);
3181 copy2
= (char *) xmalloc (strlen (second
) + 1);
3183 /* Convert the names to lower case. */
3184 stricpy (copy1
, first
);
3185 stricpy (copy2
, second
);
3187 /* Remove size and endian strings from the name. */
3188 strcut (copy1
, "big");
3189 strcut (copy1
, "little");
3190 strcut (copy2
, "big");
3191 strcut (copy2
, "little");
3193 /* Return a value based on how many characters match,
3194 starting from the beginning. If both strings are
3195 the same then return 10 * their length. */
3196 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
3197 if (copy1
[result
] == 0)
3209 /* Set by closest_target_match() below. */
3210 static const bfd_target
*winner
;
3212 /* Scan all the valid bfd targets looking for one that has the endianness
3213 requirement that was specified on the command line, and is the nearest
3214 match to the original output target. */
3217 closest_target_match (const bfd_target
*target
, void *data
)
3219 const bfd_target
*original
= (const bfd_target
*) data
;
3221 if (command_line
.endian
== ENDIAN_BIG
3222 && target
->byteorder
!= BFD_ENDIAN_BIG
)
3225 if (command_line
.endian
== ENDIAN_LITTLE
3226 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
3229 /* Must be the same flavour. */
3230 if (target
->flavour
!= original
->flavour
)
3233 /* Ignore generic big and little endian elf vectors. */
3234 if (strcmp (target
->name
, "elf32-big") == 0
3235 || strcmp (target
->name
, "elf64-big") == 0
3236 || strcmp (target
->name
, "elf32-little") == 0
3237 || strcmp (target
->name
, "elf64-little") == 0)
3240 /* If we have not found a potential winner yet, then record this one. */
3247 /* Oh dear, we now have two potential candidates for a successful match.
3248 Compare their names and choose the better one. */
3249 if (name_compare (target
->name
, original
->name
)
3250 > name_compare (winner
->name
, original
->name
))
3253 /* Keep on searching until wqe have checked them all. */
3257 /* Return the BFD target format of the first input file. */
3260 get_first_input_target (void)
3262 char *target
= NULL
;
3264 LANG_FOR_EACH_INPUT_STATEMENT (s
)
3266 if (s
->header
.type
== lang_input_statement_enum
3269 ldfile_open_file (s
);
3271 if (s
->the_bfd
!= NULL
3272 && bfd_check_format (s
->the_bfd
, bfd_object
))
3274 target
= bfd_get_target (s
->the_bfd
);
3286 lang_get_output_target (void)
3290 /* Has the user told us which output format to use? */
3291 if (output_target
!= NULL
)
3292 return output_target
;
3294 /* No - has the current target been set to something other than
3296 if (current_target
!= default_target
&& current_target
!= NULL
)
3297 return current_target
;
3299 /* No - can we determine the format of the first input file? */
3300 target
= get_first_input_target ();
3304 /* Failed - use the default output target. */
3305 return default_target
;
3308 /* Open the output file. */
3311 open_output (const char *name
)
3313 output_target
= lang_get_output_target ();
3315 /* Has the user requested a particular endianness on the command
3317 if (command_line
.endian
!= ENDIAN_UNSET
)
3319 /* Get the chosen target. */
3320 const bfd_target
*target
3321 = bfd_iterate_over_targets (get_target
, (void *) output_target
);
3323 /* If the target is not supported, we cannot do anything. */
3326 enum bfd_endian desired_endian
;
3328 if (command_line
.endian
== ENDIAN_BIG
)
3329 desired_endian
= BFD_ENDIAN_BIG
;
3331 desired_endian
= BFD_ENDIAN_LITTLE
;
3333 /* See if the target has the wrong endianness. This should
3334 not happen if the linker script has provided big and
3335 little endian alternatives, but some scrips don't do
3337 if (target
->byteorder
!= desired_endian
)
3339 /* If it does, then see if the target provides
3340 an alternative with the correct endianness. */
3341 if (target
->alternative_target
!= NULL
3342 && (target
->alternative_target
->byteorder
== desired_endian
))
3343 output_target
= target
->alternative_target
->name
;
3346 /* Try to find a target as similar as possible to
3347 the default target, but which has the desired
3348 endian characteristic. */
3349 bfd_iterate_over_targets (closest_target_match
,
3352 /* Oh dear - we could not find any targets that
3353 satisfy our requirements. */
3355 einfo (_("%P: warning: could not find any targets"
3356 " that match endianness requirement\n"));
3358 output_target
= winner
->name
;
3364 link_info
.output_bfd
= bfd_openw (name
, output_target
);
3366 if (link_info
.output_bfd
== NULL
)
3368 if (bfd_get_error () == bfd_error_invalid_target
)
3369 einfo (_("%F%P: target %s not found\n"), output_target
);
3371 einfo (_("%F%P: cannot open output file %s: %E\n"), name
);
3374 delete_output_file_on_failure
= TRUE
;
3376 if (!bfd_set_format (link_info
.output_bfd
, bfd_object
))
3377 einfo (_("%F%P: %s: can not make object file: %E\n"), name
);
3378 if (!bfd_set_arch_mach (link_info
.output_bfd
,
3379 ldfile_output_architecture
,
3380 ldfile_output_machine
))
3381 einfo (_("%F%P: %s: can not set architecture: %E\n"), name
);
3383 link_info
.hash
= bfd_link_hash_table_create (link_info
.output_bfd
);
3384 if (link_info
.hash
== NULL
)
3385 einfo (_("%F%P: can not create hash table: %E\n"));
3387 bfd_set_gp_size (link_info
.output_bfd
, g_switch_value
);
3391 ldlang_open_output (lang_statement_union_type
*statement
)
3393 switch (statement
->header
.type
)
3395 case lang_output_statement_enum
:
3396 ASSERT (link_info
.output_bfd
== NULL
);
3397 open_output (statement
->output_statement
.name
);
3398 ldemul_set_output_arch ();
3399 if (config
.magic_demand_paged
3400 && !bfd_link_relocatable (&link_info
))
3401 link_info
.output_bfd
->flags
|= D_PAGED
;
3403 link_info
.output_bfd
->flags
&= ~D_PAGED
;
3404 if (config
.text_read_only
)
3405 link_info
.output_bfd
->flags
|= WP_TEXT
;
3407 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
3408 if (link_info
.traditional_format
)
3409 link_info
.output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
3411 link_info
.output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
3414 case lang_target_statement_enum
:
3415 current_target
= statement
->target_statement
.target
;
3425 unsigned x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3426 ldfile_output_machine
);
3429 while ((x
& 1) == 0)
3437 /* Open all the input files. */
3441 OPEN_BFD_NORMAL
= 0,
3445 #ifdef ENABLE_PLUGINS
3446 static lang_input_statement_type
*plugin_insert
= NULL
;
3450 open_input_bfds (lang_statement_union_type
*s
, enum open_bfd_mode mode
)
3452 for (; s
!= NULL
; s
= s
->header
.next
)
3454 switch (s
->header
.type
)
3456 case lang_constructors_statement_enum
:
3457 open_input_bfds (constructor_list
.head
, mode
);
3459 case lang_output_section_statement_enum
:
3460 open_input_bfds (s
->output_section_statement
.children
.head
, mode
);
3462 case lang_wild_statement_enum
:
3463 /* Maybe we should load the file's symbols. */
3464 if ((mode
& OPEN_BFD_RESCAN
) == 0
3465 && s
->wild_statement
.filename
3466 && !wildcardp (s
->wild_statement
.filename
)
3467 && !archive_path (s
->wild_statement
.filename
))
3468 lookup_name (s
->wild_statement
.filename
);
3469 open_input_bfds (s
->wild_statement
.children
.head
, mode
);
3471 case lang_group_statement_enum
:
3473 struct bfd_link_hash_entry
*undefs
;
3475 /* We must continually search the entries in the group
3476 until no new symbols are added to the list of undefined
3481 undefs
= link_info
.hash
->undefs_tail
;
3482 open_input_bfds (s
->group_statement
.children
.head
,
3483 mode
| OPEN_BFD_FORCE
);
3485 while (undefs
!= link_info
.hash
->undefs_tail
);
3488 case lang_target_statement_enum
:
3489 current_target
= s
->target_statement
.target
;
3491 case lang_input_statement_enum
:
3492 if (s
->input_statement
.flags
.real
)
3494 lang_statement_union_type
**os_tail
;
3495 lang_statement_list_type add
;
3498 s
->input_statement
.target
= current_target
;
3500 /* If we are being called from within a group, and this
3501 is an archive which has already been searched, then
3502 force it to be researched unless the whole archive
3503 has been loaded already. Do the same for a rescan.
3504 Likewise reload --as-needed shared libs. */
3505 if (mode
!= OPEN_BFD_NORMAL
3506 #ifdef ENABLE_PLUGINS
3507 && ((mode
& OPEN_BFD_RESCAN
) == 0
3508 || plugin_insert
== NULL
)
3510 && s
->input_statement
.flags
.loaded
3511 && (abfd
= s
->input_statement
.the_bfd
) != NULL
3512 && ((bfd_get_format (abfd
) == bfd_archive
3513 && !s
->input_statement
.flags
.whole_archive
)
3514 || (bfd_get_format (abfd
) == bfd_object
3515 && ((abfd
->flags
) & DYNAMIC
) != 0
3516 && s
->input_statement
.flags
.add_DT_NEEDED_for_regular
3517 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3518 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)))
3520 s
->input_statement
.flags
.loaded
= FALSE
;
3521 s
->input_statement
.flags
.reload
= TRUE
;
3524 os_tail
= lang_os_list
.tail
;
3525 lang_list_init (&add
);
3527 if (!load_symbols (&s
->input_statement
, &add
))
3528 config
.make_executable
= FALSE
;
3530 if (add
.head
!= NULL
)
3532 /* If this was a script with output sections then
3533 tack any added statements on to the end of the
3534 list. This avoids having to reorder the output
3535 section statement list. Very likely the user
3536 forgot -T, and whatever we do here will not meet
3537 naive user expectations. */
3538 if (os_tail
!= lang_os_list
.tail
)
3540 einfo (_("%P: warning: %s contains output sections;"
3541 " did you forget -T?\n"),
3542 s
->input_statement
.filename
);
3543 *stat_ptr
->tail
= add
.head
;
3544 stat_ptr
->tail
= add
.tail
;
3548 *add
.tail
= s
->header
.next
;
3549 s
->header
.next
= add
.head
;
3553 #ifdef ENABLE_PLUGINS
3554 /* If we have found the point at which a plugin added new
3555 files, clear plugin_insert to enable archive rescan. */
3556 if (&s
->input_statement
== plugin_insert
)
3557 plugin_insert
= NULL
;
3560 case lang_assignment_statement_enum
:
3561 if (s
->assignment_statement
.exp
->type
.node_class
!= etree_assert
)
3562 exp_fold_tree_no_dot (s
->assignment_statement
.exp
);
3569 /* Exit if any of the files were missing. */
3570 if (input_flags
.missing_file
)
3574 /* Add the supplied name to the symbol table as an undefined reference.
3575 This is a two step process as the symbol table doesn't even exist at
3576 the time the ld command line is processed. First we put the name
3577 on a list, then, once the output file has been opened, transfer the
3578 name to the symbol table. */
3580 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3582 #define ldlang_undef_chain_list_head entry_symbol.next
3585 ldlang_add_undef (const char *const name
, bfd_boolean cmdline
)
3587 ldlang_undef_chain_list_type
*new_undef
;
3589 undef_from_cmdline
= undef_from_cmdline
|| cmdline
;
3590 new_undef
= (ldlang_undef_chain_list_type
*) stat_alloc (sizeof (*new_undef
));
3591 new_undef
->next
= ldlang_undef_chain_list_head
;
3592 ldlang_undef_chain_list_head
= new_undef
;
3594 new_undef
->name
= xstrdup (name
);
3596 if (link_info
.output_bfd
!= NULL
)
3597 insert_undefined (new_undef
->name
);
3600 /* Insert NAME as undefined in the symbol table. */
3603 insert_undefined (const char *name
)
3605 struct bfd_link_hash_entry
*h
;
3607 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
3609 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
3610 if (h
->type
== bfd_link_hash_new
)
3612 h
->type
= bfd_link_hash_undefined
;
3613 h
->u
.undef
.abfd
= NULL
;
3614 h
->non_ir_ref_regular
= TRUE
;
3615 if (is_elf_hash_table (link_info
.hash
))
3616 ((struct elf_link_hash_entry
*) h
)->mark
= 1;
3617 bfd_link_add_undef (link_info
.hash
, h
);
3621 /* Run through the list of undefineds created above and place them
3622 into the linker hash table as undefined symbols belonging to the
3626 lang_place_undefineds (void)
3628 ldlang_undef_chain_list_type
*ptr
;
3630 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3631 insert_undefined (ptr
->name
);
3634 /* Structure used to build the list of symbols that the user has required
3637 struct require_defined_symbol
3640 struct require_defined_symbol
*next
;
3643 /* The list of symbols that the user has required be defined. */
3645 static struct require_defined_symbol
*require_defined_symbol_list
;
3647 /* Add a new symbol NAME to the list of symbols that are required to be
3651 ldlang_add_require_defined (const char *const name
)
3653 struct require_defined_symbol
*ptr
;
3655 ldlang_add_undef (name
, TRUE
);
3656 ptr
= (struct require_defined_symbol
*) stat_alloc (sizeof (*ptr
));
3657 ptr
->next
= require_defined_symbol_list
;
3658 ptr
->name
= strdup (name
);
3659 require_defined_symbol_list
= ptr
;
3662 /* Check that all symbols the user required to be defined, are defined,
3663 raise an error if we find a symbol that is not defined. */
3666 ldlang_check_require_defined_symbols (void)
3668 struct require_defined_symbol
*ptr
;
3670 for (ptr
= require_defined_symbol_list
; ptr
!= NULL
; ptr
= ptr
->next
)
3672 struct bfd_link_hash_entry
*h
;
3674 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
,
3675 FALSE
, FALSE
, TRUE
);
3677 || (h
->type
!= bfd_link_hash_defined
3678 && h
->type
!= bfd_link_hash_defweak
))
3679 einfo(_("%X%P: required symbol `%s' not defined\n"), ptr
->name
);
3683 /* Check for all readonly or some readwrite sections. */
3686 check_input_sections
3687 (lang_statement_union_type
*s
,
3688 lang_output_section_statement_type
*output_section_statement
)
3690 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
3692 switch (s
->header
.type
)
3694 case lang_wild_statement_enum
:
3695 walk_wild (&s
->wild_statement
, check_section_callback
,
3696 output_section_statement
);
3697 if (!output_section_statement
->all_input_readonly
)
3700 case lang_constructors_statement_enum
:
3701 check_input_sections (constructor_list
.head
,
3702 output_section_statement
);
3703 if (!output_section_statement
->all_input_readonly
)
3706 case lang_group_statement_enum
:
3707 check_input_sections (s
->group_statement
.children
.head
,
3708 output_section_statement
);
3709 if (!output_section_statement
->all_input_readonly
)
3718 /* Update wildcard statements if needed. */
3721 update_wild_statements (lang_statement_union_type
*s
)
3723 struct wildcard_list
*sec
;
3725 switch (sort_section
)
3735 for (; s
!= NULL
; s
= s
->header
.next
)
3737 switch (s
->header
.type
)
3742 case lang_wild_statement_enum
:
3743 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
3745 /* Don't sort .init/.fini sections. */
3746 if (strcmp (sec
->spec
.name
, ".init") != 0
3747 && strcmp (sec
->spec
.name
, ".fini") != 0)
3748 switch (sec
->spec
.sorted
)
3751 sec
->spec
.sorted
= sort_section
;
3754 if (sort_section
== by_alignment
)
3755 sec
->spec
.sorted
= by_name_alignment
;
3758 if (sort_section
== by_name
)
3759 sec
->spec
.sorted
= by_alignment_name
;
3766 case lang_constructors_statement_enum
:
3767 update_wild_statements (constructor_list
.head
);
3770 case lang_output_section_statement_enum
:
3771 update_wild_statements
3772 (s
->output_section_statement
.children
.head
);
3775 case lang_group_statement_enum
:
3776 update_wild_statements (s
->group_statement
.children
.head
);
3784 /* Open input files and attach to output sections. */
3787 map_input_to_output_sections
3788 (lang_statement_union_type
*s
, const char *target
,
3789 lang_output_section_statement_type
*os
)
3791 for (; s
!= NULL
; s
= s
->header
.next
)
3793 lang_output_section_statement_type
*tos
;
3796 switch (s
->header
.type
)
3798 case lang_wild_statement_enum
:
3799 wild (&s
->wild_statement
, target
, os
);
3801 case lang_constructors_statement_enum
:
3802 map_input_to_output_sections (constructor_list
.head
,
3806 case lang_output_section_statement_enum
:
3807 tos
= &s
->output_section_statement
;
3808 if (tos
->constraint
!= 0)
3810 if (tos
->constraint
!= ONLY_IF_RW
3811 && tos
->constraint
!= ONLY_IF_RO
)
3813 tos
->all_input_readonly
= TRUE
;
3814 check_input_sections (tos
->children
.head
, tos
);
3815 if (tos
->all_input_readonly
!= (tos
->constraint
== ONLY_IF_RO
))
3817 tos
->constraint
= -1;
3821 map_input_to_output_sections (tos
->children
.head
,
3825 case lang_output_statement_enum
:
3827 case lang_target_statement_enum
:
3828 target
= s
->target_statement
.target
;
3830 case lang_group_statement_enum
:
3831 map_input_to_output_sections (s
->group_statement
.children
.head
,
3835 case lang_data_statement_enum
:
3836 /* Make sure that any sections mentioned in the expression
3838 exp_init_os (s
->data_statement
.exp
);
3839 /* The output section gets CONTENTS, ALLOC and LOAD, but
3840 these may be overridden by the script. */
3841 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
;
3842 switch (os
->sectype
)
3844 case normal_section
:
3845 case overlay_section
:
3846 case first_overlay_section
:
3848 case noalloc_section
:
3849 flags
= SEC_HAS_CONTENTS
;
3851 case noload_section
:
3852 if (bfd_get_flavour (link_info
.output_bfd
)
3853 == bfd_target_elf_flavour
)
3854 flags
= SEC_NEVER_LOAD
| SEC_ALLOC
;
3856 flags
= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
;
3859 if (os
->bfd_section
== NULL
)
3860 init_os (os
, flags
);
3862 os
->bfd_section
->flags
|= flags
;
3864 case lang_input_section_enum
:
3866 case lang_fill_statement_enum
:
3867 case lang_object_symbols_statement_enum
:
3868 case lang_reloc_statement_enum
:
3869 case lang_padding_statement_enum
:
3870 case lang_input_statement_enum
:
3871 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3874 case lang_assignment_statement_enum
:
3875 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3878 /* Make sure that any sections mentioned in the assignment
3880 exp_init_os (s
->assignment_statement
.exp
);
3882 case lang_address_statement_enum
:
3883 /* Mark the specified section with the supplied address.
3884 If this section was actually a segment marker, then the
3885 directive is ignored if the linker script explicitly
3886 processed the segment marker. Originally, the linker
3887 treated segment directives (like -Ttext on the
3888 command-line) as section directives. We honor the
3889 section directive semantics for backwards compatibility;
3890 linker scripts that do not specifically check for
3891 SEGMENT_START automatically get the old semantics. */
3892 if (!s
->address_statement
.segment
3893 || !s
->address_statement
.segment
->used
)
3895 const char *name
= s
->address_statement
.section_name
;
3897 /* Create the output section statement here so that
3898 orphans with a set address will be placed after other
3899 script sections. If we let the orphan placement code
3900 place them in amongst other sections then the address
3901 will affect following script sections, which is
3902 likely to surprise naive users. */
3903 tos
= lang_output_section_statement_lookup (name
, 0, TRUE
);
3904 tos
->addr_tree
= s
->address_statement
.address
;
3905 if (tos
->bfd_section
== NULL
)
3909 case lang_insert_statement_enum
:
3915 /* An insert statement snips out all the linker statements from the
3916 start of the list and places them after the output section
3917 statement specified by the insert. This operation is complicated
3918 by the fact that we keep a doubly linked list of output section
3919 statements as well as the singly linked list of all statements.
3920 FIXME someday: Twiddling with the list not only moves statements
3921 from the user's script but also input and group statements that are
3922 built from command line object files and --start-group. We only
3923 get away with this because the list pointers used by file_chain
3924 and input_file_chain are not reordered, and processing via
3925 statement_list after this point mostly ignores input statements.
3926 One exception is the map file, where LOAD and START GROUP/END GROUP
3927 can end up looking odd. */
3930 process_insert_statements (lang_statement_union_type
**start
)
3932 lang_statement_union_type
**s
;
3933 lang_output_section_statement_type
*first_os
= NULL
;
3934 lang_output_section_statement_type
*last_os
= NULL
;
3935 lang_output_section_statement_type
*os
;
3940 if ((*s
)->header
.type
== lang_output_section_statement_enum
)
3942 /* Keep pointers to the first and last output section
3943 statement in the sequence we may be about to move. */
3944 os
= &(*s
)->output_section_statement
;
3946 ASSERT (last_os
== NULL
|| last_os
->next
== os
);
3949 /* Set constraint negative so that lang_output_section_find
3950 won't match this output section statement. At this
3951 stage in linking constraint has values in the range
3952 [-1, ONLY_IN_RW]. */
3953 last_os
->constraint
= -2 - last_os
->constraint
;
3954 if (first_os
== NULL
)
3957 else if ((*s
)->header
.type
== lang_group_statement_enum
)
3959 /* A user might put -T between --start-group and
3960 --end-group. One way this odd construct might arise is
3961 from a wrapper around ld to change library search
3962 behaviour. For example:
3964 exec real_ld --start-group "$@" --end-group
3965 This isn't completely unreasonable so go looking inside a
3966 group statement for insert statements. */
3967 process_insert_statements (&(*s
)->group_statement
.children
.head
);
3969 else if ((*s
)->header
.type
== lang_insert_statement_enum
)
3971 lang_insert_statement_type
*i
= &(*s
)->insert_statement
;
3972 lang_output_section_statement_type
*where
;
3973 lang_statement_union_type
**ptr
;
3974 lang_statement_union_type
*first
;
3976 where
= lang_output_section_find (i
->where
);
3977 if (where
!= NULL
&& i
->is_before
)
3980 where
= where
->prev
;
3981 while (where
!= NULL
&& where
->constraint
< 0);
3985 einfo (_("%F%P: %s not found for insert\n"), i
->where
);
3989 /* Deal with reordering the output section statement list. */
3990 if (last_os
!= NULL
)
3992 asection
*first_sec
, *last_sec
;
3993 struct lang_output_section_statement_struct
**next
;
3995 /* Snip out the output sections we are moving. */
3996 first_os
->prev
->next
= last_os
->next
;
3997 if (last_os
->next
== NULL
)
3999 next
= &first_os
->prev
->next
;
4000 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4003 last_os
->next
->prev
= first_os
->prev
;
4004 /* Add them in at the new position. */
4005 last_os
->next
= where
->next
;
4006 if (where
->next
== NULL
)
4008 next
= &last_os
->next
;
4009 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4012 where
->next
->prev
= last_os
;
4013 first_os
->prev
= where
;
4014 where
->next
= first_os
;
4016 /* Move the bfd sections in the same way. */
4019 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4021 os
->constraint
= -2 - os
->constraint
;
4022 if (os
->bfd_section
!= NULL
4023 && os
->bfd_section
->owner
!= NULL
)
4025 last_sec
= os
->bfd_section
;
4026 if (first_sec
== NULL
)
4027 first_sec
= last_sec
;
4032 if (last_sec
!= NULL
)
4034 asection
*sec
= where
->bfd_section
;
4036 sec
= output_prev_sec_find (where
);
4038 /* The place we want to insert must come after the
4039 sections we are moving. So if we find no
4040 section or if the section is the same as our
4041 last section, then no move is needed. */
4042 if (sec
!= NULL
&& sec
!= last_sec
)
4044 /* Trim them off. */
4045 if (first_sec
->prev
!= NULL
)
4046 first_sec
->prev
->next
= last_sec
->next
;
4048 link_info
.output_bfd
->sections
= last_sec
->next
;
4049 if (last_sec
->next
!= NULL
)
4050 last_sec
->next
->prev
= first_sec
->prev
;
4052 link_info
.output_bfd
->section_last
= first_sec
->prev
;
4054 last_sec
->next
= sec
->next
;
4055 if (sec
->next
!= NULL
)
4056 sec
->next
->prev
= last_sec
;
4058 link_info
.output_bfd
->section_last
= last_sec
;
4059 first_sec
->prev
= sec
;
4060 sec
->next
= first_sec
;
4068 ptr
= insert_os_after (where
);
4069 /* Snip everything from the start of the list, up to and
4070 including the insert statement we are currently processing. */
4072 *start
= (*s
)->header
.next
;
4073 /* Add them back where they belong, minus the insert. */
4076 statement_list
.tail
= s
;
4081 s
= &(*s
)->header
.next
;
4084 /* Undo constraint twiddling. */
4085 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4087 os
->constraint
= -2 - os
->constraint
;
4093 /* An output section might have been removed after its statement was
4094 added. For example, ldemul_before_allocation can remove dynamic
4095 sections if they turn out to be not needed. Clean them up here. */
4098 strip_excluded_output_sections (void)
4100 lang_output_section_statement_type
*os
;
4102 /* Run lang_size_sections (if not already done). */
4103 if (expld
.phase
!= lang_mark_phase_enum
)
4105 expld
.phase
= lang_mark_phase_enum
;
4106 expld
.dataseg
.phase
= exp_seg_none
;
4107 one_lang_size_sections_pass (NULL
, FALSE
);
4108 lang_reset_memory_regions ();
4111 for (os
= &lang_os_list
.head
->output_section_statement
;
4115 asection
*output_section
;
4116 bfd_boolean exclude
;
4118 if (os
->constraint
< 0)
4121 output_section
= os
->bfd_section
;
4122 if (output_section
== NULL
)
4125 exclude
= (output_section
->rawsize
== 0
4126 && (output_section
->flags
& SEC_KEEP
) == 0
4127 && !bfd_section_removed_from_list (link_info
.output_bfd
,
4130 /* Some sections have not yet been sized, notably .gnu.version,
4131 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
4132 input sections, so don't drop output sections that have such
4133 input sections unless they are also marked SEC_EXCLUDE. */
4134 if (exclude
&& output_section
->map_head
.s
!= NULL
)
4138 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
4139 if ((s
->flags
& SEC_EXCLUDE
) == 0
4140 && ((s
->flags
& SEC_LINKER_CREATED
) != 0
4141 || link_info
.emitrelocations
))
4150 /* We don't set bfd_section to NULL since bfd_section of the
4151 removed output section statement may still be used. */
4152 if (!os
->update_dot
)
4154 output_section
->flags
|= SEC_EXCLUDE
;
4155 bfd_section_list_remove (link_info
.output_bfd
, output_section
);
4156 link_info
.output_bfd
->section_count
--;
4161 /* Called from ldwrite to clear out asection.map_head and
4162 asection.map_tail for use as link_orders in ldwrite. */
4165 lang_clear_os_map (void)
4167 lang_output_section_statement_type
*os
;
4169 if (map_head_is_link_order
)
4172 for (os
= &lang_os_list
.head
->output_section_statement
;
4176 asection
*output_section
;
4178 if (os
->constraint
< 0)
4181 output_section
= os
->bfd_section
;
4182 if (output_section
== NULL
)
4185 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
4186 output_section
->map_head
.link_order
= NULL
;
4187 output_section
->map_tail
.link_order
= NULL
;
4190 /* Stop future calls to lang_add_section from messing with map_head
4191 and map_tail link_order fields. */
4192 map_head_is_link_order
= TRUE
;
4196 print_output_section_statement
4197 (lang_output_section_statement_type
*output_section_statement
)
4199 asection
*section
= output_section_statement
->bfd_section
;
4202 if (output_section_statement
!= abs_output_section
)
4204 minfo ("\n%s", output_section_statement
->name
);
4206 if (section
!= NULL
)
4208 print_dot
= section
->vma
;
4210 len
= strlen (output_section_statement
->name
);
4211 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4216 while (len
< SECTION_NAME_MAP_LENGTH
)
4222 minfo ("0x%V %W", section
->vma
, TO_ADDR (section
->size
));
4224 if (section
->vma
!= section
->lma
)
4225 minfo (_(" load address 0x%V"), section
->lma
);
4227 if (output_section_statement
->update_dot_tree
!= NULL
)
4228 exp_fold_tree (output_section_statement
->update_dot_tree
,
4229 bfd_abs_section_ptr
, &print_dot
);
4235 print_statement_list (output_section_statement
->children
.head
,
4236 output_section_statement
);
4240 print_assignment (lang_assignment_statement_type
*assignment
,
4241 lang_output_section_statement_type
*output_section
)
4248 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4251 if (assignment
->exp
->type
.node_class
== etree_assert
)
4254 tree
= assignment
->exp
->assert_s
.child
;
4258 const char *dst
= assignment
->exp
->assign
.dst
;
4260 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
4261 tree
= assignment
->exp
;
4264 osec
= output_section
->bfd_section
;
4266 osec
= bfd_abs_section_ptr
;
4268 if (assignment
->exp
->type
.node_class
!= etree_provide
)
4269 exp_fold_tree (tree
, osec
, &print_dot
);
4271 expld
.result
.valid_p
= FALSE
;
4273 if (expld
.result
.valid_p
)
4277 if (assignment
->exp
->type
.node_class
== etree_assert
4279 || expld
.assign_name
!= NULL
)
4281 value
= expld
.result
.value
;
4283 if (expld
.result
.section
!= NULL
)
4284 value
+= expld
.result
.section
->vma
;
4286 minfo ("0x%V", value
);
4292 struct bfd_link_hash_entry
*h
;
4294 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
4295 FALSE
, FALSE
, TRUE
);
4297 && (h
->type
== bfd_link_hash_defined
4298 || h
->type
== bfd_link_hash_defweak
))
4300 value
= h
->u
.def
.value
;
4301 value
+= h
->u
.def
.section
->output_section
->vma
;
4302 value
+= h
->u
.def
.section
->output_offset
;
4304 minfo ("[0x%V]", value
);
4307 minfo ("[unresolved]");
4312 if (assignment
->exp
->type
.node_class
== etree_provide
)
4313 minfo ("[!provide]");
4320 expld
.assign_name
= NULL
;
4323 exp_print_tree (assignment
->exp
);
4328 print_input_statement (lang_input_statement_type
*statm
)
4330 if (statm
->filename
!= NULL
4331 && (statm
->the_bfd
== NULL
4332 || (statm
->the_bfd
->flags
& BFD_LINKER_CREATED
) == 0))
4333 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
4336 /* Print all symbols defined in a particular section. This is called
4337 via bfd_link_hash_traverse, or by print_all_symbols. */
4340 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
4342 asection
*sec
= (asection
*) ptr
;
4344 if ((hash_entry
->type
== bfd_link_hash_defined
4345 || hash_entry
->type
== bfd_link_hash_defweak
)
4346 && sec
== hash_entry
->u
.def
.section
)
4350 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4353 (hash_entry
->u
.def
.value
4354 + hash_entry
->u
.def
.section
->output_offset
4355 + hash_entry
->u
.def
.section
->output_section
->vma
));
4357 minfo (" %pT\n", hash_entry
->root
.string
);
4364 hash_entry_addr_cmp (const void *a
, const void *b
)
4366 const struct bfd_link_hash_entry
*l
= *(const struct bfd_link_hash_entry
**)a
;
4367 const struct bfd_link_hash_entry
*r
= *(const struct bfd_link_hash_entry
**)b
;
4369 if (l
->u
.def
.value
< r
->u
.def
.value
)
4371 else if (l
->u
.def
.value
> r
->u
.def
.value
)
4378 print_all_symbols (asection
*sec
)
4380 input_section_userdata_type
*ud
4381 = (input_section_userdata_type
*) get_userdata (sec
);
4382 struct map_symbol_def
*def
;
4383 struct bfd_link_hash_entry
**entries
;
4389 *ud
->map_symbol_def_tail
= 0;
4391 /* Sort the symbols by address. */
4392 entries
= (struct bfd_link_hash_entry
**)
4393 obstack_alloc (&map_obstack
,
4394 ud
->map_symbol_def_count
* sizeof (*entries
));
4396 for (i
= 0, def
= ud
->map_symbol_def_head
; def
; def
= def
->next
, i
++)
4397 entries
[i
] = def
->entry
;
4399 qsort (entries
, ud
->map_symbol_def_count
, sizeof (*entries
),
4400 hash_entry_addr_cmp
);
4402 /* Print the symbols. */
4403 for (i
= 0; i
< ud
->map_symbol_def_count
; i
++)
4404 print_one_symbol (entries
[i
], sec
);
4406 obstack_free (&map_obstack
, entries
);
4409 /* Print information about an input section to the map file. */
4412 print_input_section (asection
*i
, bfd_boolean is_discarded
)
4414 bfd_size_type size
= i
->size
;
4421 minfo ("%s", i
->name
);
4423 len
= 1 + strlen (i
->name
);
4424 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4429 while (len
< SECTION_NAME_MAP_LENGTH
)
4435 if (i
->output_section
!= NULL
4436 && i
->output_section
->owner
== link_info
.output_bfd
)
4437 addr
= i
->output_section
->vma
+ i
->output_offset
;
4445 minfo ("0x%V %W %pB\n", addr
, size
, i
->owner
);
4447 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
4449 len
= SECTION_NAME_MAP_LENGTH
+ 3;
4461 minfo (_("%W (size before relaxing)\n"), i
->rawsize
);
4464 if (i
->output_section
!= NULL
4465 && i
->output_section
->owner
== link_info
.output_bfd
)
4467 if (link_info
.reduce_memory_overheads
)
4468 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, i
);
4470 print_all_symbols (i
);
4472 /* Update print_dot, but make sure that we do not move it
4473 backwards - this could happen if we have overlays and a
4474 later overlay is shorter than an earier one. */
4475 if (addr
+ TO_ADDR (size
) > print_dot
)
4476 print_dot
= addr
+ TO_ADDR (size
);
4481 print_fill_statement (lang_fill_statement_type
*fill
)
4485 fputs (" FILL mask 0x", config
.map_file
);
4486 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
4487 fprintf (config
.map_file
, "%02x", *p
);
4488 fputs ("\n", config
.map_file
);
4492 print_data_statement (lang_data_statement_type
*data
)
4500 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4503 addr
= data
->output_offset
;
4504 if (data
->output_section
!= NULL
)
4505 addr
+= data
->output_section
->vma
;
4533 if (size
< TO_SIZE ((unsigned) 1))
4534 size
= TO_SIZE ((unsigned) 1);
4535 minfo ("0x%V %W %s 0x%v", addr
, TO_ADDR (size
), name
, data
->value
);
4537 if (data
->exp
->type
.node_class
!= etree_value
)
4540 exp_print_tree (data
->exp
);
4545 print_dot
= addr
+ TO_ADDR (size
);
4548 /* Print an address statement. These are generated by options like
4552 print_address_statement (lang_address_statement_type
*address
)
4554 minfo (_("Address of section %s set to "), address
->section_name
);
4555 exp_print_tree (address
->address
);
4559 /* Print a reloc statement. */
4562 print_reloc_statement (lang_reloc_statement_type
*reloc
)
4569 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4572 addr
= reloc
->output_offset
;
4573 if (reloc
->output_section
!= NULL
)
4574 addr
+= reloc
->output_section
->vma
;
4576 size
= bfd_get_reloc_size (reloc
->howto
);
4578 minfo ("0x%V %W RELOC %s ", addr
, TO_ADDR (size
), reloc
->howto
->name
);
4580 if (reloc
->name
!= NULL
)
4581 minfo ("%s+", reloc
->name
);
4583 minfo ("%s+", reloc
->section
->name
);
4585 exp_print_tree (reloc
->addend_exp
);
4589 print_dot
= addr
+ TO_ADDR (size
);
4593 print_padding_statement (lang_padding_statement_type
*s
)
4601 len
= sizeof " *fill*" - 1;
4602 while (len
< SECTION_NAME_MAP_LENGTH
)
4608 addr
= s
->output_offset
;
4609 if (s
->output_section
!= NULL
)
4610 addr
+= s
->output_section
->vma
;
4611 minfo ("0x%V %W ", addr
, TO_ADDR (s
->size
));
4613 if (s
->fill
->size
!= 0)
4617 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
4618 fprintf (config
.map_file
, "%02x", *p
);
4623 print_dot
= addr
+ TO_ADDR (s
->size
);
4627 print_wild_statement (lang_wild_statement_type
*w
,
4628 lang_output_section_statement_type
*os
)
4630 struct wildcard_list
*sec
;
4634 if (w
->exclude_name_list
)
4637 minfo ("EXCLUDE_FILE(%s", w
->exclude_name_list
->name
);
4638 for (tmp
= w
->exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4639 minfo (" %s", tmp
->name
);
4643 if (w
->filenames_sorted
)
4644 minfo ("SORT_BY_NAME(");
4645 if (w
->filename
!= NULL
)
4646 minfo ("%s", w
->filename
);
4649 if (w
->filenames_sorted
)
4653 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
4655 int closing_paren
= 0;
4657 switch (sec
->spec
.sorted
)
4663 minfo ("SORT_BY_NAME(");
4668 minfo ("SORT_BY_ALIGNMENT(");
4672 case by_name_alignment
:
4673 minfo ("SORT_BY_NAME(SORT_BY_ALIGNMENT(");
4677 case by_alignment_name
:
4678 minfo ("SORT_BY_ALIGNMENT(SORT_BY_NAME(");
4683 minfo ("SORT_NONE(");
4687 case by_init_priority
:
4688 minfo ("SORT_BY_INIT_PRIORITY(");
4693 if (sec
->spec
.exclude_name_list
!= NULL
)
4696 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
4697 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4698 minfo (" %s", tmp
->name
);
4701 if (sec
->spec
.name
!= NULL
)
4702 minfo ("%s", sec
->spec
.name
);
4705 for (;closing_paren
> 0; closing_paren
--)
4714 print_statement_list (w
->children
.head
, os
);
4717 /* Print a group statement. */
4720 print_group (lang_group_statement_type
*s
,
4721 lang_output_section_statement_type
*os
)
4723 fprintf (config
.map_file
, "START GROUP\n");
4724 print_statement_list (s
->children
.head
, os
);
4725 fprintf (config
.map_file
, "END GROUP\n");
4728 /* Print the list of statements in S.
4729 This can be called for any statement type. */
4732 print_statement_list (lang_statement_union_type
*s
,
4733 lang_output_section_statement_type
*os
)
4737 print_statement (s
, os
);
4742 /* Print the first statement in statement list S.
4743 This can be called for any statement type. */
4746 print_statement (lang_statement_union_type
*s
,
4747 lang_output_section_statement_type
*os
)
4749 switch (s
->header
.type
)
4752 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
4755 case lang_constructors_statement_enum
:
4756 if (constructor_list
.head
!= NULL
)
4758 if (constructors_sorted
)
4759 minfo (" SORT (CONSTRUCTORS)\n");
4761 minfo (" CONSTRUCTORS\n");
4762 print_statement_list (constructor_list
.head
, os
);
4765 case lang_wild_statement_enum
:
4766 print_wild_statement (&s
->wild_statement
, os
);
4768 case lang_address_statement_enum
:
4769 print_address_statement (&s
->address_statement
);
4771 case lang_object_symbols_statement_enum
:
4772 minfo (" CREATE_OBJECT_SYMBOLS\n");
4774 case lang_fill_statement_enum
:
4775 print_fill_statement (&s
->fill_statement
);
4777 case lang_data_statement_enum
:
4778 print_data_statement (&s
->data_statement
);
4780 case lang_reloc_statement_enum
:
4781 print_reloc_statement (&s
->reloc_statement
);
4783 case lang_input_section_enum
:
4784 print_input_section (s
->input_section
.section
, FALSE
);
4786 case lang_padding_statement_enum
:
4787 print_padding_statement (&s
->padding_statement
);
4789 case lang_output_section_statement_enum
:
4790 print_output_section_statement (&s
->output_section_statement
);
4792 case lang_assignment_statement_enum
:
4793 print_assignment (&s
->assignment_statement
, os
);
4795 case lang_target_statement_enum
:
4796 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
4798 case lang_output_statement_enum
:
4799 minfo ("OUTPUT(%s", s
->output_statement
.name
);
4800 if (output_target
!= NULL
)
4801 minfo (" %s", output_target
);
4804 case lang_input_statement_enum
:
4805 print_input_statement (&s
->input_statement
);
4807 case lang_group_statement_enum
:
4808 print_group (&s
->group_statement
, os
);
4810 case lang_insert_statement_enum
:
4811 minfo ("INSERT %s %s\n",
4812 s
->insert_statement
.is_before
? "BEFORE" : "AFTER",
4813 s
->insert_statement
.where
);
4819 print_statements (void)
4821 print_statement_list (statement_list
.head
, abs_output_section
);
4824 /* Print the first N statements in statement list S to STDERR.
4825 If N == 0, nothing is printed.
4826 If N < 0, the entire list is printed.
4827 Intended to be called from GDB. */
4830 dprint_statement (lang_statement_union_type
*s
, int n
)
4832 FILE *map_save
= config
.map_file
;
4834 config
.map_file
= stderr
;
4837 print_statement_list (s
, abs_output_section
);
4840 while (s
&& --n
>= 0)
4842 print_statement (s
, abs_output_section
);
4847 config
.map_file
= map_save
;
4851 insert_pad (lang_statement_union_type
**ptr
,
4853 bfd_size_type alignment_needed
,
4854 asection
*output_section
,
4857 static fill_type zero_fill
;
4858 lang_statement_union_type
*pad
= NULL
;
4860 if (ptr
!= &statement_list
.head
)
4861 pad
= ((lang_statement_union_type
*)
4862 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
4864 && pad
->header
.type
== lang_padding_statement_enum
4865 && pad
->padding_statement
.output_section
== output_section
)
4867 /* Use the existing pad statement. */
4869 else if ((pad
= *ptr
) != NULL
4870 && pad
->header
.type
== lang_padding_statement_enum
4871 && pad
->padding_statement
.output_section
== output_section
)
4873 /* Use the existing pad statement. */
4877 /* Make a new padding statement, linked into existing chain. */
4878 pad
= (lang_statement_union_type
*)
4879 stat_alloc (sizeof (lang_padding_statement_type
));
4880 pad
->header
.next
= *ptr
;
4882 pad
->header
.type
= lang_padding_statement_enum
;
4883 pad
->padding_statement
.output_section
= output_section
;
4886 pad
->padding_statement
.fill
= fill
;
4888 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
4889 pad
->padding_statement
.size
= alignment_needed
;
4890 if (!(output_section
->flags
& SEC_FIXED_SIZE
))
4891 output_section
->size
= TO_SIZE (dot
+ TO_ADDR (alignment_needed
)
4892 - output_section
->vma
);
4895 /* Work out how much this section will move the dot point. */
4899 (lang_statement_union_type
**this_ptr
,
4900 lang_output_section_statement_type
*output_section_statement
,
4904 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
4905 asection
*i
= is
->section
;
4906 asection
*o
= output_section_statement
->bfd_section
;
4908 if (i
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
4909 i
->output_offset
= i
->vma
- o
->vma
;
4910 else if (((i
->flags
& SEC_EXCLUDE
) != 0)
4911 || output_section_statement
->ignored
)
4912 i
->output_offset
= dot
- o
->vma
;
4915 bfd_size_type alignment_needed
;
4917 /* Align this section first to the input sections requirement,
4918 then to the output section's requirement. If this alignment
4919 is greater than any seen before, then record it too. Perform
4920 the alignment by inserting a magic 'padding' statement. */
4922 if (output_section_statement
->subsection_alignment
!= NULL
)
4924 = exp_get_power (output_section_statement
->subsection_alignment
,
4925 "subsection alignment");
4927 if (o
->alignment_power
< i
->alignment_power
)
4928 o
->alignment_power
= i
->alignment_power
;
4930 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
4932 if (alignment_needed
!= 0)
4934 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
4935 dot
+= alignment_needed
;
4938 /* Remember where in the output section this input section goes. */
4939 i
->output_offset
= dot
- o
->vma
;
4941 /* Mark how big the output section must be to contain this now. */
4942 dot
+= TO_ADDR (i
->size
);
4943 if (!(o
->flags
& SEC_FIXED_SIZE
))
4944 o
->size
= TO_SIZE (dot
- o
->vma
);
4957 sort_sections_by_lma (const void *arg1
, const void *arg2
)
4959 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
4960 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
4962 if (sec1
->lma
< sec2
->lma
)
4964 else if (sec1
->lma
> sec2
->lma
)
4966 else if (sec1
->id
< sec2
->id
)
4968 else if (sec1
->id
> sec2
->id
)
4975 sort_sections_by_vma (const void *arg1
, const void *arg2
)
4977 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
4978 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
4980 if (sec1
->vma
< sec2
->vma
)
4982 else if (sec1
->vma
> sec2
->vma
)
4984 else if (sec1
->id
< sec2
->id
)
4986 else if (sec1
->id
> sec2
->id
)
4992 #define IS_TBSS(s) \
4993 ((s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == SEC_THREAD_LOCAL)
4995 #define IGNORE_SECTION(s) \
4996 ((s->flags & SEC_ALLOC) == 0 || IS_TBSS (s))
4998 /* Check to see if any allocated sections overlap with other allocated
4999 sections. This can happen if a linker script specifies the output
5000 section addresses of the two sections. Also check whether any memory
5001 region has overflowed. */
5004 lang_check_section_addresses (void)
5007 struct check_sec
*sections
;
5012 bfd_vma p_start
= 0;
5014 lang_memory_region_type
*m
;
5015 bfd_boolean overlays
;
5017 /* Detect address space overflow on allocated sections. */
5018 addr_mask
= ((bfd_vma
) 1 <<
5019 (bfd_arch_bits_per_address (link_info
.output_bfd
) - 1)) - 1;
5020 addr_mask
= (addr_mask
<< 1) + 1;
5021 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5022 if ((s
->flags
& SEC_ALLOC
) != 0)
5024 s_end
= (s
->vma
+ s
->size
) & addr_mask
;
5025 if (s_end
!= 0 && s_end
< (s
->vma
& addr_mask
))
5026 einfo (_("%X%P: section %s VMA wraps around address space\n"),
5030 s_end
= (s
->lma
+ s
->size
) & addr_mask
;
5031 if (s_end
!= 0 && s_end
< (s
->lma
& addr_mask
))
5032 einfo (_("%X%P: section %s LMA wraps around address space\n"),
5037 if (bfd_count_sections (link_info
.output_bfd
) <= 1)
5040 count
= bfd_count_sections (link_info
.output_bfd
);
5041 sections
= XNEWVEC (struct check_sec
, count
);
5043 /* Scan all sections in the output list. */
5045 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5047 if (IGNORE_SECTION (s
)
5051 sections
[count
].sec
= s
;
5052 sections
[count
].warned
= FALSE
;
5062 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_lma
);
5064 /* First check section LMAs. There should be no overlap of LMAs on
5065 loadable sections, even with overlays. */
5066 for (p
= NULL
, i
= 0; i
< count
; i
++)
5068 s
= sections
[i
].sec
;
5069 if ((s
->flags
& SEC_LOAD
) != 0)
5072 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5074 /* Look for an overlap. We have sorted sections by lma, so
5075 we know that s_start >= p_start. Besides the obvious
5076 case of overlap when the current section starts before
5077 the previous one ends, we also must have overlap if the
5078 previous section wraps around the address space. */
5080 && (s_start
<= p_end
5081 || p_end
< p_start
))
5083 einfo (_("%X%P: section %s LMA [%V,%V]"
5084 " overlaps section %s LMA [%V,%V]\n"),
5085 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5086 sections
[i
].warned
= TRUE
;
5094 /* If any non-zero size allocated section (excluding tbss) starts at
5095 exactly the same VMA as another such section, then we have
5096 overlays. Overlays generated by the OVERLAY keyword will have
5097 this property. It is possible to intentionally generate overlays
5098 that fail this test, but it would be unusual. */
5099 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_vma
);
5101 p_start
= sections
[0].sec
->vma
;
5102 for (i
= 1; i
< count
; i
++)
5104 s_start
= sections
[i
].sec
->vma
;
5105 if (p_start
== s_start
)
5113 /* Now check section VMAs if no overlays were detected. */
5116 for (p
= NULL
, i
= 0; i
< count
; i
++)
5118 s
= sections
[i
].sec
;
5120 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5123 && !sections
[i
].warned
5124 && (s_start
<= p_end
5125 || p_end
< p_start
))
5126 einfo (_("%X%P: section %s VMA [%V,%V]"
5127 " overlaps section %s VMA [%V,%V]\n"),
5128 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5137 /* If any memory region has overflowed, report by how much.
5138 We do not issue this diagnostic for regions that had sections
5139 explicitly placed outside their bounds; os_region_check's
5140 diagnostics are adequate for that case.
5142 FIXME: It is conceivable that m->current - (m->origin + m->length)
5143 might overflow a 32-bit integer. There is, alas, no way to print
5144 a bfd_vma quantity in decimal. */
5145 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
5146 if (m
->had_full_message
)
5148 unsigned long over
= m
->current
- (m
->origin
+ m
->length
);
5149 einfo (ngettext ("%X%P: region `%s' overflowed by %lu byte\n",
5150 "%X%P: region `%s' overflowed by %lu bytes\n",
5152 m
->name_list
.name
, over
);
5156 /* Make sure the new address is within the region. We explicitly permit the
5157 current address to be at the exact end of the region when the address is
5158 non-zero, in case the region is at the end of addressable memory and the
5159 calculation wraps around. */
5162 os_region_check (lang_output_section_statement_type
*os
,
5163 lang_memory_region_type
*region
,
5167 if ((region
->current
< region
->origin
5168 || (region
->current
- region
->origin
> region
->length
))
5169 && ((region
->current
!= region
->origin
+ region
->length
)
5174 einfo (_("%X%P: address 0x%v of %pB section `%s'"
5175 " is not within region `%s'\n"),
5177 os
->bfd_section
->owner
,
5178 os
->bfd_section
->name
,
5179 region
->name_list
.name
);
5181 else if (!region
->had_full_message
)
5183 region
->had_full_message
= TRUE
;
5185 einfo (_("%X%P: %pB section `%s' will not fit in region `%s'\n"),
5186 os
->bfd_section
->owner
,
5187 os
->bfd_section
->name
,
5188 region
->name_list
.name
);
5194 ldlang_check_relro_region (lang_statement_union_type
*s
,
5195 seg_align_type
*seg
)
5197 if (seg
->relro
== exp_seg_relro_start
)
5199 if (!seg
->relro_start_stat
)
5200 seg
->relro_start_stat
= s
;
5203 ASSERT (seg
->relro_start_stat
== s
);
5206 else if (seg
->relro
== exp_seg_relro_end
)
5208 if (!seg
->relro_end_stat
)
5209 seg
->relro_end_stat
= s
;
5212 ASSERT (seg
->relro_end_stat
== s
);
5217 /* Set the sizes for all the output sections. */
5220 lang_size_sections_1
5221 (lang_statement_union_type
**prev
,
5222 lang_output_section_statement_type
*output_section_statement
,
5226 bfd_boolean check_regions
)
5228 lang_statement_union_type
*s
;
5230 /* Size up the sections from their constituent parts. */
5231 for (s
= *prev
; s
!= NULL
; s
= s
->header
.next
)
5233 switch (s
->header
.type
)
5235 case lang_output_section_statement_enum
:
5237 bfd_vma newdot
, after
, dotdelta
;
5238 lang_output_section_statement_type
*os
;
5239 lang_memory_region_type
*r
;
5240 int section_alignment
= 0;
5242 os
= &s
->output_section_statement
;
5243 if (os
->constraint
== -1)
5246 /* FIXME: We shouldn't need to zero section vmas for ld -r
5247 here, in lang_insert_orphan, or in the default linker scripts.
5248 This is covering for coff backend linker bugs. See PR6945. */
5249 if (os
->addr_tree
== NULL
5250 && bfd_link_relocatable (&link_info
)
5251 && (bfd_get_flavour (link_info
.output_bfd
)
5252 == bfd_target_coff_flavour
))
5253 os
->addr_tree
= exp_intop (0);
5254 if (os
->addr_tree
!= NULL
)
5256 os
->processed_vma
= FALSE
;
5257 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
5259 if (expld
.result
.valid_p
)
5261 dot
= expld
.result
.value
;
5262 if (expld
.result
.section
!= NULL
)
5263 dot
+= expld
.result
.section
->vma
;
5265 else if (expld
.phase
!= lang_mark_phase_enum
)
5266 einfo (_("%F%P:%pS: non constant or forward reference"
5267 " address expression for section %s\n"),
5268 os
->addr_tree
, os
->name
);
5271 if (os
->bfd_section
== NULL
)
5272 /* This section was removed or never actually created. */
5275 /* If this is a COFF shared library section, use the size and
5276 address from the input section. FIXME: This is COFF
5277 specific; it would be cleaner if there were some other way
5278 to do this, but nothing simple comes to mind. */
5279 if (((bfd_get_flavour (link_info
.output_bfd
)
5280 == bfd_target_ecoff_flavour
)
5281 || (bfd_get_flavour (link_info
.output_bfd
)
5282 == bfd_target_coff_flavour
))
5283 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
5287 if (os
->children
.head
== NULL
5288 || os
->children
.head
->header
.next
!= NULL
5289 || (os
->children
.head
->header
.type
5290 != lang_input_section_enum
))
5291 einfo (_("%X%P: internal error on COFF shared library"
5292 " section %s\n"), os
->name
);
5294 input
= os
->children
.head
->input_section
.section
;
5295 bfd_set_section_vma (os
->bfd_section
->owner
,
5297 bfd_section_vma (input
->owner
, input
));
5298 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5299 os
->bfd_section
->size
= input
->size
;
5305 if (bfd_is_abs_section (os
->bfd_section
))
5307 /* No matter what happens, an abs section starts at zero. */
5308 ASSERT (os
->bfd_section
->vma
== 0);
5312 if (os
->addr_tree
== NULL
)
5314 /* No address specified for this section, get one
5315 from the region specification. */
5316 if (os
->region
== NULL
5317 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
5318 && os
->region
->name_list
.name
[0] == '*'
5319 && strcmp (os
->region
->name_list
.name
,
5320 DEFAULT_MEMORY_REGION
) == 0))
5322 os
->region
= lang_memory_default (os
->bfd_section
);
5325 /* If a loadable section is using the default memory
5326 region, and some non default memory regions were
5327 defined, issue an error message. */
5329 && !IGNORE_SECTION (os
->bfd_section
)
5330 && !bfd_link_relocatable (&link_info
)
5332 && strcmp (os
->region
->name_list
.name
,
5333 DEFAULT_MEMORY_REGION
) == 0
5334 && lang_memory_region_list
!= NULL
5335 && (strcmp (lang_memory_region_list
->name_list
.name
,
5336 DEFAULT_MEMORY_REGION
) != 0
5337 || lang_memory_region_list
->next
!= NULL
)
5338 && expld
.phase
!= lang_mark_phase_enum
)
5340 /* By default this is an error rather than just a
5341 warning because if we allocate the section to the
5342 default memory region we can end up creating an
5343 excessively large binary, or even seg faulting when
5344 attempting to perform a negative seek. See
5345 sources.redhat.com/ml/binutils/2003-04/msg00423.html
5346 for an example of this. This behaviour can be
5347 overridden by the using the --no-check-sections
5349 if (command_line
.check_section_addresses
)
5350 einfo (_("%F%P: error: no memory region specified"
5351 " for loadable section `%s'\n"),
5352 bfd_get_section_name (link_info
.output_bfd
,
5355 einfo (_("%P: warning: no memory region specified"
5356 " for loadable section `%s'\n"),
5357 bfd_get_section_name (link_info
.output_bfd
,
5361 newdot
= os
->region
->current
;
5362 section_alignment
= os
->bfd_section
->alignment_power
;
5365 section_alignment
= exp_get_power (os
->section_alignment
,
5366 "section alignment");
5368 /* Align to what the section needs. */
5369 if (section_alignment
> 0)
5371 bfd_vma savedot
= newdot
;
5372 newdot
= align_power (newdot
, section_alignment
);
5374 dotdelta
= newdot
- savedot
;
5376 && (config
.warn_section_align
5377 || os
->addr_tree
!= NULL
)
5378 && expld
.phase
!= lang_mark_phase_enum
)
5379 einfo (ngettext ("%P: warning: changing start of "
5380 "section %s by %lu byte\n",
5381 "%P: warning: changing start of "
5382 "section %s by %lu bytes\n",
5383 (unsigned long) dotdelta
),
5384 os
->name
, (unsigned long) dotdelta
);
5387 bfd_set_section_vma (0, os
->bfd_section
, newdot
);
5389 os
->bfd_section
->output_offset
= 0;
5392 lang_size_sections_1 (&os
->children
.head
, os
,
5393 os
->fill
, newdot
, relax
, check_regions
);
5395 os
->processed_vma
= TRUE
;
5397 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5398 /* Except for some special linker created sections,
5399 no output section should change from zero size
5400 after strip_excluded_output_sections. A non-zero
5401 size on an ignored section indicates that some
5402 input section was not sized early enough. */
5403 ASSERT (os
->bfd_section
->size
== 0);
5406 dot
= os
->bfd_section
->vma
;
5408 /* Put the section within the requested block size, or
5409 align at the block boundary. */
5411 + TO_ADDR (os
->bfd_section
->size
)
5412 + os
->block_value
- 1)
5413 & - (bfd_vma
) os
->block_value
);
5415 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5416 os
->bfd_section
->size
= TO_SIZE (after
5417 - os
->bfd_section
->vma
);
5420 /* Set section lma. */
5423 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
5427 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
5428 os
->bfd_section
->lma
= lma
;
5430 else if (os
->lma_region
!= NULL
)
5432 bfd_vma lma
= os
->lma_region
->current
;
5434 if (os
->align_lma_with_input
)
5438 /* When LMA_REGION is the same as REGION, align the LMA
5439 as we did for the VMA, possibly including alignment
5440 from the bfd section. If a different region, then
5441 only align according to the value in the output
5443 if (os
->lma_region
!= os
->region
)
5444 section_alignment
= exp_get_power (os
->section_alignment
,
5445 "section alignment");
5446 if (section_alignment
> 0)
5447 lma
= align_power (lma
, section_alignment
);
5449 os
->bfd_section
->lma
= lma
;
5451 else if (r
->last_os
!= NULL
5452 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5457 last
= r
->last_os
->output_section_statement
.bfd_section
;
5459 /* A backwards move of dot should be accompanied by
5460 an explicit assignment to the section LMA (ie.
5461 os->load_base set) because backwards moves can
5462 create overlapping LMAs. */
5464 && os
->bfd_section
->size
!= 0
5465 && dot
+ TO_ADDR (os
->bfd_section
->size
) <= last
->vma
)
5467 /* If dot moved backwards then leave lma equal to
5468 vma. This is the old default lma, which might
5469 just happen to work when the backwards move is
5470 sufficiently large. Nag if this changes anything,
5471 so people can fix their linker scripts. */
5473 if (last
->vma
!= last
->lma
)
5474 einfo (_("%P: warning: dot moved backwards "
5475 "before `%s'\n"), os
->name
);
5479 /* If this is an overlay, set the current lma to that
5480 at the end of the previous section. */
5481 if (os
->sectype
== overlay_section
)
5482 lma
= last
->lma
+ TO_ADDR (last
->size
);
5484 /* Otherwise, keep the same lma to vma relationship
5485 as the previous section. */
5487 lma
= dot
+ last
->lma
- last
->vma
;
5489 if (section_alignment
> 0)
5490 lma
= align_power (lma
, section_alignment
);
5491 os
->bfd_section
->lma
= lma
;
5494 os
->processed_lma
= TRUE
;
5496 /* Keep track of normal sections using the default
5497 lma region. We use this to set the lma for
5498 following sections. Overlays or other linker
5499 script assignment to lma might mean that the
5500 default lma == vma is incorrect.
5501 To avoid warnings about dot moving backwards when using
5502 -Ttext, don't start tracking sections until we find one
5503 of non-zero size or with lma set differently to vma.
5504 Do this tracking before we short-cut the loop so that we
5505 track changes for the case where the section size is zero,
5506 but the lma is set differently to the vma. This is
5507 important, if an orphan section is placed after an
5508 otherwise empty output section that has an explicit lma
5509 set, we want that lma reflected in the orphans lma. */
5510 if (((!IGNORE_SECTION (os
->bfd_section
)
5511 && (os
->bfd_section
->size
!= 0
5512 || (r
->last_os
== NULL
5513 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
5514 || (r
->last_os
!= NULL
5515 && dot
>= (r
->last_os
->output_section_statement
5516 .bfd_section
->vma
))))
5517 || os
->sectype
== first_overlay_section
)
5518 && os
->lma_region
== NULL
5519 && !bfd_link_relocatable (&link_info
))
5522 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5525 /* .tbss sections effectively have zero size. */
5526 if (!IS_TBSS (os
->bfd_section
)
5527 || bfd_link_relocatable (&link_info
))
5528 dotdelta
= TO_ADDR (os
->bfd_section
->size
);
5533 if (os
->update_dot_tree
!= 0)
5534 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5536 /* Update dot in the region ?
5537 We only do this if the section is going to be allocated,
5538 since unallocated sections do not contribute to the region's
5539 overall size in memory. */
5540 if (os
->region
!= NULL
5541 && (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)))
5543 os
->region
->current
= dot
;
5546 /* Make sure the new address is within the region. */
5547 os_region_check (os
, os
->region
, os
->addr_tree
,
5548 os
->bfd_section
->vma
);
5550 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
5551 && ((os
->bfd_section
->flags
& SEC_LOAD
)
5552 || os
->align_lma_with_input
))
5554 os
->lma_region
->current
= os
->bfd_section
->lma
+ dotdelta
;
5557 os_region_check (os
, os
->lma_region
, NULL
,
5558 os
->bfd_section
->lma
);
5564 case lang_constructors_statement_enum
:
5565 dot
= lang_size_sections_1 (&constructor_list
.head
,
5566 output_section_statement
,
5567 fill
, dot
, relax
, check_regions
);
5570 case lang_data_statement_enum
:
5572 unsigned int size
= 0;
5574 s
->data_statement
.output_offset
=
5575 dot
- output_section_statement
->bfd_section
->vma
;
5576 s
->data_statement
.output_section
=
5577 output_section_statement
->bfd_section
;
5579 /* We might refer to provided symbols in the expression, and
5580 need to mark them as needed. */
5581 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5583 switch (s
->data_statement
.type
)
5601 if (size
< TO_SIZE ((unsigned) 1))
5602 size
= TO_SIZE ((unsigned) 1);
5603 dot
+= TO_ADDR (size
);
5604 if (!(output_section_statement
->bfd_section
->flags
5606 output_section_statement
->bfd_section
->size
5607 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5612 case lang_reloc_statement_enum
:
5616 s
->reloc_statement
.output_offset
=
5617 dot
- output_section_statement
->bfd_section
->vma
;
5618 s
->reloc_statement
.output_section
=
5619 output_section_statement
->bfd_section
;
5620 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
5621 dot
+= TO_ADDR (size
);
5622 if (!(output_section_statement
->bfd_section
->flags
5624 output_section_statement
->bfd_section
->size
5625 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5629 case lang_wild_statement_enum
:
5630 dot
= lang_size_sections_1 (&s
->wild_statement
.children
.head
,
5631 output_section_statement
,
5632 fill
, dot
, relax
, check_regions
);
5635 case lang_object_symbols_statement_enum
:
5636 link_info
.create_object_symbols_section
5637 = output_section_statement
->bfd_section
;
5638 output_section_statement
->bfd_section
->flags
|= SEC_KEEP
;
5641 case lang_output_statement_enum
:
5642 case lang_target_statement_enum
:
5645 case lang_input_section_enum
:
5649 i
= s
->input_section
.section
;
5654 if (!bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
5655 einfo (_("%F%P: can't relax section: %E\n"));
5659 dot
= size_input_section (prev
, output_section_statement
,
5664 case lang_input_statement_enum
:
5667 case lang_fill_statement_enum
:
5668 s
->fill_statement
.output_section
=
5669 output_section_statement
->bfd_section
;
5671 fill
= s
->fill_statement
.fill
;
5674 case lang_assignment_statement_enum
:
5676 bfd_vma newdot
= dot
;
5677 etree_type
*tree
= s
->assignment_statement
.exp
;
5679 expld
.dataseg
.relro
= exp_seg_relro_none
;
5681 exp_fold_tree (tree
,
5682 output_section_statement
->bfd_section
,
5685 ldlang_check_relro_region (s
, &expld
.dataseg
);
5687 expld
.dataseg
.relro
= exp_seg_relro_none
;
5689 /* This symbol may be relative to this section. */
5690 if ((tree
->type
.node_class
== etree_provided
5691 || tree
->type
.node_class
== etree_assign
)
5692 && (tree
->assign
.dst
[0] != '.'
5693 || tree
->assign
.dst
[1] != '\0'))
5694 output_section_statement
->update_dot
= 1;
5696 if (!output_section_statement
->ignored
)
5698 if (output_section_statement
== abs_output_section
)
5700 /* If we don't have an output section, then just adjust
5701 the default memory address. */
5702 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
5703 FALSE
)->current
= newdot
;
5705 else if (newdot
!= dot
)
5707 /* Insert a pad after this statement. We can't
5708 put the pad before when relaxing, in case the
5709 assignment references dot. */
5710 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
5711 output_section_statement
->bfd_section
, dot
);
5713 /* Don't neuter the pad below when relaxing. */
5716 /* If dot is advanced, this implies that the section
5717 should have space allocated to it, unless the
5718 user has explicitly stated that the section
5719 should not be allocated. */
5720 if (output_section_statement
->sectype
!= noalloc_section
5721 && (output_section_statement
->sectype
!= noload_section
5722 || (bfd_get_flavour (link_info
.output_bfd
)
5723 == bfd_target_elf_flavour
)))
5724 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
5731 case lang_padding_statement_enum
:
5732 /* If this is the first time lang_size_sections is called,
5733 we won't have any padding statements. If this is the
5734 second or later passes when relaxing, we should allow
5735 padding to shrink. If padding is needed on this pass, it
5736 will be added back in. */
5737 s
->padding_statement
.size
= 0;
5739 /* Make sure output_offset is valid. If relaxation shrinks
5740 the section and this pad isn't needed, it's possible to
5741 have output_offset larger than the final size of the
5742 section. bfd_set_section_contents will complain even for
5743 a pad size of zero. */
5744 s
->padding_statement
.output_offset
5745 = dot
- output_section_statement
->bfd_section
->vma
;
5748 case lang_group_statement_enum
:
5749 dot
= lang_size_sections_1 (&s
->group_statement
.children
.head
,
5750 output_section_statement
,
5751 fill
, dot
, relax
, check_regions
);
5754 case lang_insert_statement_enum
:
5757 /* We can only get here when relaxing is turned on. */
5758 case lang_address_statement_enum
:
5765 prev
= &s
->header
.next
;
5770 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
5771 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
5772 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
5773 segments. We are allowed an opportunity to override this decision. */
5776 ldlang_override_segment_assignment (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5777 bfd
*abfd ATTRIBUTE_UNUSED
,
5778 asection
*current_section
,
5779 asection
*previous_section
,
5780 bfd_boolean new_segment
)
5782 lang_output_section_statement_type
*cur
;
5783 lang_output_section_statement_type
*prev
;
5785 /* The checks below are only necessary when the BFD library has decided
5786 that the two sections ought to be placed into the same segment. */
5790 /* Paranoia checks. */
5791 if (current_section
== NULL
|| previous_section
== NULL
)
5794 /* If this flag is set, the target never wants code and non-code
5795 sections comingled in the same segment. */
5796 if (config
.separate_code
5797 && ((current_section
->flags
^ previous_section
->flags
) & SEC_CODE
))
5800 /* Find the memory regions associated with the two sections.
5801 We call lang_output_section_find() here rather than scanning the list
5802 of output sections looking for a matching section pointer because if
5803 we have a large number of sections then a hash lookup is faster. */
5804 cur
= lang_output_section_find (current_section
->name
);
5805 prev
= lang_output_section_find (previous_section
->name
);
5807 /* More paranoia. */
5808 if (cur
== NULL
|| prev
== NULL
)
5811 /* If the regions are different then force the sections to live in
5812 different segments. See the email thread starting at the following
5813 URL for the reasons why this is necessary:
5814 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
5815 return cur
->region
!= prev
->region
;
5819 one_lang_size_sections_pass (bfd_boolean
*relax
, bfd_boolean check_regions
)
5821 lang_statement_iteration
++;
5822 lang_size_sections_1 (&statement_list
.head
, abs_output_section
,
5823 0, 0, relax
, check_regions
);
5827 lang_size_segment (seg_align_type
*seg
)
5829 /* If XXX_SEGMENT_ALIGN XXX_SEGMENT_END pair was seen, check whether
5830 a page could be saved in the data segment. */
5831 bfd_vma first
, last
;
5833 first
= -seg
->base
& (seg
->pagesize
- 1);
5834 last
= seg
->end
& (seg
->pagesize
- 1);
5836 && ((seg
->base
& ~(seg
->pagesize
- 1))
5837 != (seg
->end
& ~(seg
->pagesize
- 1)))
5838 && first
+ last
<= seg
->pagesize
)
5840 seg
->phase
= exp_seg_adjust
;
5844 seg
->phase
= exp_seg_done
;
5849 lang_size_relro_segment_1 (seg_align_type
*seg
)
5851 bfd_vma relro_end
, desired_end
;
5854 /* Compute the expected PT_GNU_RELRO/PT_LOAD segment end. */
5855 relro_end
= ((seg
->relro_end
+ seg
->pagesize
- 1)
5856 & ~(seg
->pagesize
- 1));
5858 /* Adjust by the offset arg of XXX_SEGMENT_RELRO_END. */
5859 desired_end
= relro_end
- seg
->relro_offset
;
5861 /* For sections in the relro segment.. */
5862 for (sec
= link_info
.output_bfd
->section_last
; sec
; sec
= sec
->prev
)
5863 if ((sec
->flags
& SEC_ALLOC
) != 0
5864 && sec
->vma
>= seg
->base
5865 && sec
->vma
< seg
->relro_end
- seg
->relro_offset
)
5867 /* Where do we want to put this section so that it ends as
5869 bfd_vma start
, end
, bump
;
5871 end
= start
= sec
->vma
;
5873 end
+= TO_ADDR (sec
->size
);
5874 bump
= desired_end
- end
;
5875 /* We'd like to increase START by BUMP, but we must heed
5876 alignment so the increase might be less than optimum. */
5878 start
&= ~(((bfd_vma
) 1 << sec
->alignment_power
) - 1);
5879 /* This is now the desired end for the previous section. */
5880 desired_end
= start
;
5883 seg
->phase
= exp_seg_relro_adjust
;
5884 ASSERT (desired_end
>= seg
->base
);
5885 seg
->base
= desired_end
;
5890 lang_size_relro_segment (bfd_boolean
*relax
, bfd_boolean check_regions
)
5892 bfd_boolean do_reset
= FALSE
;
5893 bfd_boolean do_data_relro
;
5894 bfd_vma data_initial_base
, data_relro_end
;
5896 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
5898 do_data_relro
= TRUE
;
5899 data_initial_base
= expld
.dataseg
.base
;
5900 data_relro_end
= lang_size_relro_segment_1 (&expld
.dataseg
);
5904 do_data_relro
= FALSE
;
5905 data_initial_base
= data_relro_end
= 0;
5910 lang_reset_memory_regions ();
5911 one_lang_size_sections_pass (relax
, check_regions
);
5913 /* Assignments to dot, or to output section address in a user
5914 script have increased padding over the original. Revert. */
5915 if (do_data_relro
&& expld
.dataseg
.relro_end
> data_relro_end
)
5917 expld
.dataseg
.base
= data_initial_base
;;
5922 if (!do_data_relro
&& lang_size_segment (&expld
.dataseg
))
5929 lang_size_sections (bfd_boolean
*relax
, bfd_boolean check_regions
)
5931 expld
.phase
= lang_allocating_phase_enum
;
5932 expld
.dataseg
.phase
= exp_seg_none
;
5934 one_lang_size_sections_pass (relax
, check_regions
);
5936 if (expld
.dataseg
.phase
!= exp_seg_end_seen
)
5937 expld
.dataseg
.phase
= exp_seg_done
;
5939 if (expld
.dataseg
.phase
== exp_seg_end_seen
)
5941 bfd_boolean do_reset
5942 = lang_size_relro_segment (relax
, check_regions
);
5946 lang_reset_memory_regions ();
5947 one_lang_size_sections_pass (relax
, check_regions
);
5950 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
5952 link_info
.relro_start
= expld
.dataseg
.base
;
5953 link_info
.relro_end
= expld
.dataseg
.relro_end
;
5958 static lang_output_section_statement_type
*current_section
;
5959 static lang_assignment_statement_type
*current_assign
;
5960 static bfd_boolean prefer_next_section
;
5962 /* Worker function for lang_do_assignments. Recursiveness goes here. */
5965 lang_do_assignments_1 (lang_statement_union_type
*s
,
5966 lang_output_section_statement_type
*current_os
,
5969 bfd_boolean
*found_end
)
5971 for (; s
!= NULL
; s
= s
->header
.next
)
5973 switch (s
->header
.type
)
5975 case lang_constructors_statement_enum
:
5976 dot
= lang_do_assignments_1 (constructor_list
.head
,
5977 current_os
, fill
, dot
, found_end
);
5980 case lang_output_section_statement_enum
:
5982 lang_output_section_statement_type
*os
;
5985 os
= &(s
->output_section_statement
);
5986 os
->after_end
= *found_end
;
5987 if (os
->bfd_section
!= NULL
&& !os
->ignored
)
5989 if ((os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5991 current_section
= os
;
5992 prefer_next_section
= FALSE
;
5994 dot
= os
->bfd_section
->vma
;
5996 newdot
= lang_do_assignments_1 (os
->children
.head
,
5997 os
, os
->fill
, dot
, found_end
);
6000 if (os
->bfd_section
!= NULL
)
6002 /* .tbss sections effectively have zero size. */
6003 if (!IS_TBSS (os
->bfd_section
)
6004 || bfd_link_relocatable (&link_info
))
6005 dot
+= TO_ADDR (os
->bfd_section
->size
);
6007 if (os
->update_dot_tree
!= NULL
)
6008 exp_fold_tree (os
->update_dot_tree
,
6009 bfd_abs_section_ptr
, &dot
);
6017 case lang_wild_statement_enum
:
6019 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
6020 current_os
, fill
, dot
, found_end
);
6023 case lang_object_symbols_statement_enum
:
6024 case lang_output_statement_enum
:
6025 case lang_target_statement_enum
:
6028 case lang_data_statement_enum
:
6029 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
6030 if (expld
.result
.valid_p
)
6032 s
->data_statement
.value
= expld
.result
.value
;
6033 if (expld
.result
.section
!= NULL
)
6034 s
->data_statement
.value
+= expld
.result
.section
->vma
;
6036 else if (expld
.phase
== lang_final_phase_enum
)
6037 einfo (_("%F%P: invalid data statement\n"));
6040 switch (s
->data_statement
.type
)
6058 if (size
< TO_SIZE ((unsigned) 1))
6059 size
= TO_SIZE ((unsigned) 1);
6060 dot
+= TO_ADDR (size
);
6064 case lang_reloc_statement_enum
:
6065 exp_fold_tree (s
->reloc_statement
.addend_exp
,
6066 bfd_abs_section_ptr
, &dot
);
6067 if (expld
.result
.valid_p
)
6068 s
->reloc_statement
.addend_value
= expld
.result
.value
;
6069 else if (expld
.phase
== lang_final_phase_enum
)
6070 einfo (_("%F%P: invalid reloc statement\n"));
6071 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
6074 case lang_input_section_enum
:
6076 asection
*in
= s
->input_section
.section
;
6078 if ((in
->flags
& SEC_EXCLUDE
) == 0)
6079 dot
+= TO_ADDR (in
->size
);
6083 case lang_input_statement_enum
:
6086 case lang_fill_statement_enum
:
6087 fill
= s
->fill_statement
.fill
;
6090 case lang_assignment_statement_enum
:
6091 current_assign
= &s
->assignment_statement
;
6092 if (current_assign
->exp
->type
.node_class
!= etree_assert
)
6094 const char *p
= current_assign
->exp
->assign
.dst
;
6096 if (current_os
== abs_output_section
&& p
[0] == '.' && p
[1] == 0)
6097 prefer_next_section
= TRUE
;
6101 if (strcmp (p
, "end") == 0)
6104 exp_fold_tree (s
->assignment_statement
.exp
,
6105 (current_os
->bfd_section
!= NULL
6106 ? current_os
->bfd_section
: bfd_und_section_ptr
),
6110 case lang_padding_statement_enum
:
6111 dot
+= TO_ADDR (s
->padding_statement
.size
);
6114 case lang_group_statement_enum
:
6115 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
6116 current_os
, fill
, dot
, found_end
);
6119 case lang_insert_statement_enum
:
6122 case lang_address_statement_enum
:
6134 lang_do_assignments (lang_phase_type phase
)
6136 bfd_boolean found_end
= FALSE
;
6138 current_section
= NULL
;
6139 prefer_next_section
= FALSE
;
6140 expld
.phase
= phase
;
6141 lang_statement_iteration
++;
6142 lang_do_assignments_1 (statement_list
.head
,
6143 abs_output_section
, NULL
, 0, &found_end
);
6146 /* For an assignment statement outside of an output section statement,
6147 choose the best of neighbouring output sections to use for values
6151 section_for_dot (void)
6155 /* Assignments belong to the previous output section, unless there
6156 has been an assignment to "dot", in which case following
6157 assignments belong to the next output section. (The assumption
6158 is that an assignment to "dot" is setting up the address for the
6159 next output section.) Except that past the assignment to "_end"
6160 we always associate with the previous section. This exception is
6161 for targets like SH that define an alloc .stack or other
6162 weirdness after non-alloc sections. */
6163 if (current_section
== NULL
|| prefer_next_section
)
6165 lang_statement_union_type
*stmt
;
6166 lang_output_section_statement_type
*os
;
6168 for (stmt
= (lang_statement_union_type
*) current_assign
;
6170 stmt
= stmt
->header
.next
)
6171 if (stmt
->header
.type
== lang_output_section_statement_enum
)
6174 os
= &stmt
->output_section_statement
;
6177 && (os
->bfd_section
== NULL
6178 || (os
->bfd_section
->flags
& SEC_EXCLUDE
) != 0
6179 || bfd_section_removed_from_list (link_info
.output_bfd
,
6183 if (current_section
== NULL
|| os
== NULL
|| !os
->after_end
)
6186 s
= os
->bfd_section
;
6188 s
= link_info
.output_bfd
->section_last
;
6190 && ((s
->flags
& SEC_ALLOC
) == 0
6191 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6196 return bfd_abs_section_ptr
;
6200 s
= current_section
->bfd_section
;
6202 /* The section may have been stripped. */
6204 && ((s
->flags
& SEC_EXCLUDE
) != 0
6205 || (s
->flags
& SEC_ALLOC
) == 0
6206 || (s
->flags
& SEC_THREAD_LOCAL
) != 0
6207 || bfd_section_removed_from_list (link_info
.output_bfd
, s
)))
6210 s
= link_info
.output_bfd
->sections
;
6212 && ((s
->flags
& SEC_ALLOC
) == 0
6213 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6218 return bfd_abs_section_ptr
;
6221 /* Array of __start/__stop/.startof./.sizeof/ symbols. */
6223 static struct bfd_link_hash_entry
**start_stop_syms
;
6224 static size_t start_stop_count
= 0;
6225 static size_t start_stop_alloc
= 0;
6227 /* Give start/stop SYMBOL for SEC a preliminary definition, and add it
6228 to start_stop_syms. */
6231 lang_define_start_stop (const char *symbol
, asection
*sec
)
6233 struct bfd_link_hash_entry
*h
;
6235 h
= bfd_define_start_stop (link_info
.output_bfd
, &link_info
, symbol
, sec
);
6238 if (start_stop_count
== start_stop_alloc
)
6240 start_stop_alloc
= 2 * start_stop_alloc
+ 10;
6242 = xrealloc (start_stop_syms
,
6243 start_stop_alloc
* sizeof (*start_stop_syms
));
6245 start_stop_syms
[start_stop_count
++] = h
;
6249 /* Check for input sections whose names match references to
6250 __start_SECNAME or __stop_SECNAME symbols. Give the symbols
6251 preliminary definitions. */
6254 lang_init_start_stop (void)
6258 char leading_char
= bfd_get_symbol_leading_char (link_info
.output_bfd
);
6260 for (abfd
= link_info
.input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6261 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6264 const char *secname
= s
->name
;
6266 for (ps
= secname
; *ps
!= '\0'; ps
++)
6267 if (!ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
6271 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6273 symbol
[0] = leading_char
;
6274 sprintf (symbol
+ (leading_char
!= 0), "__start_%s", secname
);
6275 lang_define_start_stop (symbol
, s
);
6277 symbol
[1] = leading_char
;
6278 memcpy (symbol
+ 1 + (leading_char
!= 0), "__stop", 6);
6279 lang_define_start_stop (symbol
+ 1, s
);
6286 /* Iterate over start_stop_syms. */
6289 foreach_start_stop (void (*func
) (struct bfd_link_hash_entry
*))
6293 for (i
= 0; i
< start_stop_count
; ++i
)
6294 func (start_stop_syms
[i
]);
6297 /* __start and __stop symbols are only supposed to be defined by the
6298 linker for orphan sections, but we now extend that to sections that
6299 map to an output section of the same name. The symbols were
6300 defined early for --gc-sections, before we mapped input to output
6301 sections, so undo those that don't satisfy this rule. */
6304 undef_start_stop (struct bfd_link_hash_entry
*h
)
6306 if (h
->ldscript_def
)
6309 if (h
->u
.def
.section
->output_section
== NULL
6310 || h
->u
.def
.section
->output_section
->owner
!= link_info
.output_bfd
6311 || strcmp (h
->u
.def
.section
->name
,
6312 h
->u
.def
.section
->output_section
->name
) != 0)
6314 asection
*sec
= bfd_get_section_by_name (link_info
.output_bfd
,
6315 h
->u
.def
.section
->name
);
6318 /* When there are more than one input sections with the same
6319 section name, SECNAME, linker picks the first one to define
6320 __start_SECNAME and __stop_SECNAME symbols. When the first
6321 input section is removed by comdat group, we need to check
6322 if there is still an output section with section name
6325 for (i
= sec
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
6326 if (strcmp (h
->u
.def
.section
->name
, i
->name
) == 0)
6328 h
->u
.def
.section
= i
;
6332 h
->type
= bfd_link_hash_undefined
;
6333 h
->u
.undef
.abfd
= NULL
;
6338 lang_undef_start_stop (void)
6340 foreach_start_stop (undef_start_stop
);
6343 /* Check for output sections whose names match references to
6344 .startof.SECNAME or .sizeof.SECNAME symbols. Give the symbols
6345 preliminary definitions. */
6348 lang_init_startof_sizeof (void)
6352 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6354 const char *secname
= s
->name
;
6355 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6357 sprintf (symbol
, ".startof.%s", secname
);
6358 lang_define_start_stop (symbol
, s
);
6360 memcpy (symbol
+ 1, ".size", 5);
6361 lang_define_start_stop (symbol
+ 1, s
);
6366 /* Set .startof., .sizeof., __start and __stop symbols final values. */
6369 set_start_stop (struct bfd_link_hash_entry
*h
)
6372 || h
->type
!= bfd_link_hash_defined
)
6375 if (h
->root
.string
[0] == '.')
6377 /* .startof. or .sizeof. symbol.
6378 .startof. already has final value. */
6379 if (h
->root
.string
[2] == 'i')
6382 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6383 h
->u
.def
.section
= bfd_abs_section_ptr
;
6388 /* __start or __stop symbol. */
6389 int has_lead
= bfd_get_symbol_leading_char (link_info
.output_bfd
) != 0;
6391 h
->u
.def
.section
= h
->u
.def
.section
->output_section
;
6392 if (h
->root
.string
[4 + has_lead
] == 'o')
6395 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6401 lang_finalize_start_stop (void)
6403 foreach_start_stop (set_start_stop
);
6409 struct bfd_link_hash_entry
*h
;
6412 if ((bfd_link_relocatable (&link_info
) && !link_info
.gc_sections
)
6413 || bfd_link_dll (&link_info
))
6414 warn
= entry_from_cmdline
;
6418 /* Force the user to specify a root when generating a relocatable with
6419 --gc-sections, unless --gc-keep-exported was also given. */
6420 if (bfd_link_relocatable (&link_info
)
6421 && link_info
.gc_sections
6422 && !link_info
.gc_keep_exported
6423 && !(entry_from_cmdline
|| undef_from_cmdline
))
6424 einfo (_("%F%P: gc-sections requires either an entry or "
6425 "an undefined symbol\n"));
6427 if (entry_symbol
.name
== NULL
)
6429 /* No entry has been specified. Look for the default entry, but
6430 don't warn if we don't find it. */
6431 entry_symbol
.name
= entry_symbol_default
;
6435 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
6436 FALSE
, FALSE
, TRUE
);
6438 && (h
->type
== bfd_link_hash_defined
6439 || h
->type
== bfd_link_hash_defweak
)
6440 && h
->u
.def
.section
->output_section
!= NULL
)
6444 val
= (h
->u
.def
.value
6445 + bfd_get_section_vma (link_info
.output_bfd
,
6446 h
->u
.def
.section
->output_section
)
6447 + h
->u
.def
.section
->output_offset
);
6448 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6449 einfo (_("%F%P: %s: can't set start address\n"), entry_symbol
.name
);
6456 /* We couldn't find the entry symbol. Try parsing it as a
6458 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
6461 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6462 einfo (_("%F%P: can't set start address\n"));
6468 /* Can't find the entry symbol, and it's not a number. Use
6469 the first address in the text section. */
6470 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
6474 einfo (_("%P: warning: cannot find entry symbol %s;"
6475 " defaulting to %V\n"),
6477 bfd_get_section_vma (link_info
.output_bfd
, ts
));
6478 if (!(bfd_set_start_address
6479 (link_info
.output_bfd
,
6480 bfd_get_section_vma (link_info
.output_bfd
, ts
))))
6481 einfo (_("%F%P: can't set start address\n"));
6486 einfo (_("%P: warning: cannot find entry symbol %s;"
6487 " not setting start address\n"),
6494 /* This is a small function used when we want to ignore errors from
6498 ignore_bfd_errors (const char *fmt ATTRIBUTE_UNUSED
,
6499 va_list ap ATTRIBUTE_UNUSED
)
6501 /* Don't do anything. */
6504 /* Check that the architecture of all the input files is compatible
6505 with the output file. Also call the backend to let it do any
6506 other checking that is needed. */
6511 lang_statement_union_type
*file
;
6513 const bfd_arch_info_type
*compatible
;
6515 for (file
= file_chain
.head
; file
!= NULL
; file
= file
->input_statement
.next
)
6517 #ifdef ENABLE_PLUGINS
6518 /* Don't check format of files claimed by plugin. */
6519 if (file
->input_statement
.flags
.claimed
)
6521 #endif /* ENABLE_PLUGINS */
6522 input_bfd
= file
->input_statement
.the_bfd
;
6524 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
6525 command_line
.accept_unknown_input_arch
);
6527 /* In general it is not possible to perform a relocatable
6528 link between differing object formats when the input
6529 file has relocations, because the relocations in the
6530 input format may not have equivalent representations in
6531 the output format (and besides BFD does not translate
6532 relocs for other link purposes than a final link). */
6533 if ((bfd_link_relocatable (&link_info
)
6534 || link_info
.emitrelocations
)
6535 && (compatible
== NULL
6536 || (bfd_get_flavour (input_bfd
)
6537 != bfd_get_flavour (link_info
.output_bfd
)))
6538 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
6540 einfo (_("%F%P: relocatable linking with relocations from"
6541 " format %s (%pB) to format %s (%pB) is not supported\n"),
6542 bfd_get_target (input_bfd
), input_bfd
,
6543 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
6544 /* einfo with %F exits. */
6547 if (compatible
== NULL
)
6549 if (command_line
.warn_mismatch
)
6550 einfo (_("%X%P: %s architecture of input file `%pB'"
6551 " is incompatible with %s output\n"),
6552 bfd_printable_name (input_bfd
), input_bfd
,
6553 bfd_printable_name (link_info
.output_bfd
));
6555 else if (bfd_count_sections (input_bfd
))
6557 /* If the input bfd has no contents, it shouldn't set the
6558 private data of the output bfd. */
6560 bfd_error_handler_type pfn
= NULL
;
6562 /* If we aren't supposed to warn about mismatched input
6563 files, temporarily set the BFD error handler to a
6564 function which will do nothing. We still want to call
6565 bfd_merge_private_bfd_data, since it may set up
6566 information which is needed in the output file. */
6567 if (!command_line
.warn_mismatch
)
6568 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
6569 if (!bfd_merge_private_bfd_data (input_bfd
, &link_info
))
6571 if (command_line
.warn_mismatch
)
6572 einfo (_("%X%P: failed to merge target specific data"
6573 " of file %pB\n"), input_bfd
);
6575 if (!command_line
.warn_mismatch
)
6576 bfd_set_error_handler (pfn
);
6581 /* Look through all the global common symbols and attach them to the
6582 correct section. The -sort-common command line switch may be used
6583 to roughly sort the entries by alignment. */
6588 if (link_info
.inhibit_common_definition
)
6590 if (bfd_link_relocatable (&link_info
)
6591 && !command_line
.force_common_definition
)
6594 if (!config
.sort_common
)
6595 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
6600 if (config
.sort_common
== sort_descending
)
6602 for (power
= 4; power
> 0; power
--)
6603 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6606 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6610 for (power
= 0; power
<= 4; power
++)
6611 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6613 power
= (unsigned int) -1;
6614 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6619 /* Place one common symbol in the correct section. */
6622 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
6624 unsigned int power_of_two
;
6628 if (h
->type
!= bfd_link_hash_common
)
6632 power_of_two
= h
->u
.c
.p
->alignment_power
;
6634 if (config
.sort_common
== sort_descending
6635 && power_of_two
< *(unsigned int *) info
)
6637 else if (config
.sort_common
== sort_ascending
6638 && power_of_two
> *(unsigned int *) info
)
6641 section
= h
->u
.c
.p
->section
;
6642 if (!bfd_define_common_symbol (link_info
.output_bfd
, &link_info
, h
))
6643 einfo (_("%F%P: could not define common symbol `%pT': %E\n"),
6646 if (config
.map_file
!= NULL
)
6648 static bfd_boolean header_printed
;
6653 if (!header_printed
)
6655 minfo (_("\nAllocating common symbols\n"));
6656 minfo (_("Common symbol size file\n\n"));
6657 header_printed
= TRUE
;
6660 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
6661 DMGL_ANSI
| DMGL_PARAMS
);
6664 minfo ("%s", h
->root
.string
);
6665 len
= strlen (h
->root
.string
);
6670 len
= strlen (name
);
6686 if (size
<= 0xffffffff)
6687 sprintf (buf
, "%lx", (unsigned long) size
);
6689 sprintf_vma (buf
, size
);
6699 minfo ("%pB\n", section
->owner
);
6705 /* Handle a single orphan section S, placing the orphan into an appropriate
6706 output section. The effects of the --orphan-handling command line
6707 option are handled here. */
6710 ldlang_place_orphan (asection
*s
)
6712 if (config
.orphan_handling
== orphan_handling_discard
)
6714 lang_output_section_statement_type
*os
;
6715 os
= lang_output_section_statement_lookup (DISCARD_SECTION_NAME
, 0,
6717 if (os
->addr_tree
== NULL
6718 && (bfd_link_relocatable (&link_info
)
6719 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6720 os
->addr_tree
= exp_intop (0);
6721 lang_add_section (&os
->children
, s
, NULL
, os
);
6725 lang_output_section_statement_type
*os
;
6726 const char *name
= s
->name
;
6729 if (config
.orphan_handling
== orphan_handling_error
)
6730 einfo (_("%X%P: error: unplaced orphan section `%pA' from `%pB'\n"),
6733 if (config
.unique_orphan_sections
|| unique_section_p (s
, NULL
))
6734 constraint
= SPECIAL
;
6736 os
= ldemul_place_orphan (s
, name
, constraint
);
6739 os
= lang_output_section_statement_lookup (name
, constraint
, TRUE
);
6740 if (os
->addr_tree
== NULL
6741 && (bfd_link_relocatable (&link_info
)
6742 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6743 os
->addr_tree
= exp_intop (0);
6744 lang_add_section (&os
->children
, s
, NULL
, os
);
6747 if (config
.orphan_handling
== orphan_handling_warn
)
6748 einfo (_("%P: warning: orphan section `%pA' from `%pB' being "
6749 "placed in section `%s'\n"),
6750 s
, s
->owner
, os
->name
);
6754 /* Run through the input files and ensure that every input section has
6755 somewhere to go. If one is found without a destination then create
6756 an input request and place it into the statement tree. */
6759 lang_place_orphans (void)
6761 LANG_FOR_EACH_INPUT_STATEMENT (file
)
6765 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6767 if (s
->output_section
== NULL
)
6769 /* This section of the file is not attached, root
6770 around for a sensible place for it to go. */
6772 if (file
->flags
.just_syms
)
6773 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
6774 else if (lang_discard_section_p (s
))
6775 s
->output_section
= bfd_abs_section_ptr
;
6776 else if (strcmp (s
->name
, "COMMON") == 0)
6778 /* This is a lonely common section which must have
6779 come from an archive. We attach to the section
6780 with the wildcard. */
6781 if (!bfd_link_relocatable (&link_info
)
6782 || command_line
.force_common_definition
)
6784 if (default_common_section
== NULL
)
6785 default_common_section
6786 = lang_output_section_statement_lookup (".bss", 0,
6788 lang_add_section (&default_common_section
->children
, s
,
6789 NULL
, default_common_section
);
6793 ldlang_place_orphan (s
);
6800 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
6802 flagword
*ptr_flags
;
6804 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
6810 /* PR 17900: An exclamation mark in the attributes reverses
6811 the sense of any of the attributes that follow. */
6814 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
6818 *ptr_flags
|= SEC_ALLOC
;
6822 *ptr_flags
|= SEC_READONLY
;
6826 *ptr_flags
|= SEC_DATA
;
6830 *ptr_flags
|= SEC_CODE
;
6835 *ptr_flags
|= SEC_LOAD
;
6839 einfo (_("%F%P: invalid character %c (%d) in flags\n"),
6847 /* Call a function on each input file. This function will be called
6848 on an archive, but not on the elements. */
6851 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
6853 lang_input_statement_type
*f
;
6855 for (f
= &input_file_chain
.head
->input_statement
;
6857 f
= &f
->next_real_file
->input_statement
)
6861 /* Call a function on each file. The function will be called on all
6862 the elements of an archive which are included in the link, but will
6863 not be called on the archive file itself. */
6866 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
6868 LANG_FOR_EACH_INPUT_STATEMENT (f
)
6875 ldlang_add_file (lang_input_statement_type
*entry
)
6877 lang_statement_append (&file_chain
,
6878 (lang_statement_union_type
*) entry
,
6881 /* The BFD linker needs to have a list of all input BFDs involved in
6883 ASSERT (entry
->the_bfd
->link
.next
== NULL
);
6884 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
6886 *link_info
.input_bfds_tail
= entry
->the_bfd
;
6887 link_info
.input_bfds_tail
= &entry
->the_bfd
->link
.next
;
6888 entry
->the_bfd
->usrdata
= entry
;
6889 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
6891 /* Look through the sections and check for any which should not be
6892 included in the link. We need to do this now, so that we can
6893 notice when the backend linker tries to report multiple
6894 definition errors for symbols which are in sections we aren't
6895 going to link. FIXME: It might be better to entirely ignore
6896 symbols which are defined in sections which are going to be
6897 discarded. This would require modifying the backend linker for
6898 each backend which might set the SEC_LINK_ONCE flag. If we do
6899 this, we should probably handle SEC_EXCLUDE in the same way. */
6901 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
6905 lang_add_output (const char *name
, int from_script
)
6907 /* Make -o on command line override OUTPUT in script. */
6908 if (!had_output_filename
|| !from_script
)
6910 output_filename
= name
;
6911 had_output_filename
= TRUE
;
6915 lang_output_section_statement_type
*
6916 lang_enter_output_section_statement (const char *output_section_statement_name
,
6917 etree_type
*address_exp
,
6918 enum section_type sectype
,
6920 etree_type
*subalign
,
6923 int align_with_input
)
6925 lang_output_section_statement_type
*os
;
6927 os
= lang_output_section_statement_lookup (output_section_statement_name
,
6929 current_section
= os
;
6931 if (os
->addr_tree
== NULL
)
6933 os
->addr_tree
= address_exp
;
6935 os
->sectype
= sectype
;
6936 if (sectype
!= noload_section
)
6937 os
->flags
= SEC_NO_FLAGS
;
6939 os
->flags
= SEC_NEVER_LOAD
;
6940 os
->block_value
= 1;
6942 /* Make next things chain into subchain of this. */
6943 push_stat_ptr (&os
->children
);
6945 os
->align_lma_with_input
= align_with_input
== ALIGN_WITH_INPUT
;
6946 if (os
->align_lma_with_input
&& align
!= NULL
)
6947 einfo (_("%F%P:%pS: error: align with input and explicit align specified\n"),
6950 os
->subsection_alignment
= subalign
;
6951 os
->section_alignment
= align
;
6953 os
->load_base
= ebase
;
6960 lang_output_statement_type
*new_stmt
;
6962 new_stmt
= new_stat (lang_output_statement
, stat_ptr
);
6963 new_stmt
->name
= output_filename
;
6966 /* Reset the current counters in the regions. */
6969 lang_reset_memory_regions (void)
6971 lang_memory_region_type
*p
= lang_memory_region_list
;
6973 lang_output_section_statement_type
*os
;
6975 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
6977 p
->current
= p
->origin
;
6981 for (os
= &lang_os_list
.head
->output_section_statement
;
6985 os
->processed_vma
= FALSE
;
6986 os
->processed_lma
= FALSE
;
6989 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6991 /* Save the last size for possible use by bfd_relax_section. */
6992 o
->rawsize
= o
->size
;
6993 if (!(o
->flags
& SEC_FIXED_SIZE
))
6998 /* Worker for lang_gc_sections_1. */
7001 gc_section_callback (lang_wild_statement_type
*ptr
,
7002 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7004 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
7005 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7006 void *data ATTRIBUTE_UNUSED
)
7008 /* If the wild pattern was marked KEEP, the member sections
7009 should be as well. */
7010 if (ptr
->keep_sections
)
7011 section
->flags
|= SEC_KEEP
;
7014 /* Iterate over sections marking them against GC. */
7017 lang_gc_sections_1 (lang_statement_union_type
*s
)
7019 for (; s
!= NULL
; s
= s
->header
.next
)
7021 switch (s
->header
.type
)
7023 case lang_wild_statement_enum
:
7024 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
7026 case lang_constructors_statement_enum
:
7027 lang_gc_sections_1 (constructor_list
.head
);
7029 case lang_output_section_statement_enum
:
7030 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
7032 case lang_group_statement_enum
:
7033 lang_gc_sections_1 (s
->group_statement
.children
.head
);
7042 lang_gc_sections (void)
7044 /* Keep all sections so marked in the link script. */
7045 lang_gc_sections_1 (statement_list
.head
);
7047 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
7048 the special case of debug info. (See bfd/stabs.c)
7049 Twiddle the flag here, to simplify later linker code. */
7050 if (bfd_link_relocatable (&link_info
))
7052 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7055 #ifdef ENABLE_PLUGINS
7056 if (f
->flags
.claimed
)
7059 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7060 if ((sec
->flags
& SEC_DEBUGGING
) == 0)
7061 sec
->flags
&= ~SEC_EXCLUDE
;
7065 if (link_info
.gc_sections
)
7066 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
7069 /* Worker for lang_find_relro_sections_1. */
7072 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
7073 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7075 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
7076 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7079 /* Discarded, excluded and ignored sections effectively have zero
7081 if (section
->output_section
!= NULL
7082 && section
->output_section
->owner
== link_info
.output_bfd
7083 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
7084 && !IGNORE_SECTION (section
)
7085 && section
->size
!= 0)
7087 bfd_boolean
*has_relro_section
= (bfd_boolean
*) data
;
7088 *has_relro_section
= TRUE
;
7092 /* Iterate over sections for relro sections. */
7095 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
7096 seg_align_type
*seg
,
7097 bfd_boolean
*has_relro_section
)
7099 if (*has_relro_section
)
7102 for (; s
!= NULL
; s
= s
->header
.next
)
7104 if (s
== seg
->relro_end_stat
)
7107 switch (s
->header
.type
)
7109 case lang_wild_statement_enum
:
7110 walk_wild (&s
->wild_statement
,
7111 find_relro_section_callback
,
7114 case lang_constructors_statement_enum
:
7115 lang_find_relro_sections_1 (constructor_list
.head
,
7116 seg
, has_relro_section
);
7118 case lang_output_section_statement_enum
:
7119 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
7120 seg
, has_relro_section
);
7122 case lang_group_statement_enum
:
7123 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
7124 seg
, has_relro_section
);
7133 lang_find_relro_sections (void)
7135 bfd_boolean has_relro_section
= FALSE
;
7137 /* Check all sections in the link script. */
7139 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
7140 &expld
.dataseg
, &has_relro_section
);
7142 if (!has_relro_section
)
7143 link_info
.relro
= FALSE
;
7146 /* Relax all sections until bfd_relax_section gives up. */
7149 lang_relax_sections (bfd_boolean need_layout
)
7151 if (RELAXATION_ENABLED
)
7153 /* We may need more than one relaxation pass. */
7154 int i
= link_info
.relax_pass
;
7156 /* The backend can use it to determine the current pass. */
7157 link_info
.relax_pass
= 0;
7161 /* Keep relaxing until bfd_relax_section gives up. */
7162 bfd_boolean relax_again
;
7164 link_info
.relax_trip
= -1;
7167 link_info
.relax_trip
++;
7169 /* Note: pe-dll.c does something like this also. If you find
7170 you need to change this code, you probably need to change
7171 pe-dll.c also. DJ */
7173 /* Do all the assignments with our current guesses as to
7175 lang_do_assignments (lang_assigning_phase_enum
);
7177 /* We must do this after lang_do_assignments, because it uses
7179 lang_reset_memory_regions ();
7181 /* Perform another relax pass - this time we know where the
7182 globals are, so can make a better guess. */
7183 relax_again
= FALSE
;
7184 lang_size_sections (&relax_again
, FALSE
);
7186 while (relax_again
);
7188 link_info
.relax_pass
++;
7195 /* Final extra sizing to report errors. */
7196 lang_do_assignments (lang_assigning_phase_enum
);
7197 lang_reset_memory_regions ();
7198 lang_size_sections (NULL
, TRUE
);
7202 #ifdef ENABLE_PLUGINS
7203 /* Find the insert point for the plugin's replacement files. We
7204 place them after the first claimed real object file, or if the
7205 first claimed object is an archive member, after the last real
7206 object file immediately preceding the archive. In the event
7207 no objects have been claimed at all, we return the first dummy
7208 object file on the list as the insert point; that works, but
7209 the callee must be careful when relinking the file_chain as it
7210 is not actually on that chain, only the statement_list and the
7211 input_file list; in that case, the replacement files must be
7212 inserted at the head of the file_chain. */
7214 static lang_input_statement_type
*
7215 find_replacements_insert_point (void)
7217 lang_input_statement_type
*claim1
, *lastobject
;
7218 lastobject
= &input_file_chain
.head
->input_statement
;
7219 for (claim1
= &file_chain
.head
->input_statement
;
7221 claim1
= &claim1
->next
->input_statement
)
7223 if (claim1
->flags
.claimed
)
7224 return claim1
->flags
.claim_archive
? lastobject
: claim1
;
7225 /* Update lastobject if this is a real object file. */
7226 if (claim1
->the_bfd
!= NULL
&& claim1
->the_bfd
->my_archive
== NULL
)
7227 lastobject
= claim1
;
7229 /* No files were claimed by the plugin. Choose the last object
7230 file found on the list (maybe the first, dummy entry) as the
7235 /* Find where to insert ADD, an archive element or shared library
7236 added during a rescan. */
7238 static lang_statement_union_type
**
7239 find_rescan_insertion (lang_input_statement_type
*add
)
7241 bfd
*add_bfd
= add
->the_bfd
;
7242 lang_input_statement_type
*f
;
7243 lang_input_statement_type
*last_loaded
= NULL
;
7244 lang_input_statement_type
*before
= NULL
;
7245 lang_statement_union_type
**iter
= NULL
;
7247 if (add_bfd
->my_archive
!= NULL
)
7248 add_bfd
= add_bfd
->my_archive
;
7250 /* First look through the input file chain, to find an object file
7251 before the one we've rescanned. Normal object files always
7252 appear on both the input file chain and the file chain, so this
7253 lets us get quickly to somewhere near the correct place on the
7254 file chain if it is full of archive elements. Archives don't
7255 appear on the file chain, but if an element has been extracted
7256 then their input_statement->next points at it. */
7257 for (f
= &input_file_chain
.head
->input_statement
;
7259 f
= &f
->next_real_file
->input_statement
)
7261 if (f
->the_bfd
== add_bfd
)
7263 before
= last_loaded
;
7264 if (f
->next
!= NULL
)
7265 return &f
->next
->input_statement
.next
;
7267 if (f
->the_bfd
!= NULL
&& f
->next
!= NULL
)
7271 for (iter
= before
? &before
->next
: &file_chain
.head
->input_statement
.next
;
7273 iter
= &(*iter
)->input_statement
.next
)
7274 if (!(*iter
)->input_statement
.flags
.claim_archive
7275 && (*iter
)->input_statement
.the_bfd
->my_archive
== NULL
)
7281 /* Insert SRCLIST into DESTLIST after given element by chaining
7282 on FIELD as the next-pointer. (Counterintuitively does not need
7283 a pointer to the actual after-node itself, just its chain field.) */
7286 lang_list_insert_after (lang_statement_list_type
*destlist
,
7287 lang_statement_list_type
*srclist
,
7288 lang_statement_union_type
**field
)
7290 *(srclist
->tail
) = *field
;
7291 *field
= srclist
->head
;
7292 if (destlist
->tail
== field
)
7293 destlist
->tail
= srclist
->tail
;
7296 /* Detach new nodes added to DESTLIST since the time ORIGLIST
7297 was taken as a copy of it and leave them in ORIGLIST. */
7300 lang_list_remove_tail (lang_statement_list_type
*destlist
,
7301 lang_statement_list_type
*origlist
)
7303 union lang_statement_union
**savetail
;
7304 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
7305 ASSERT (origlist
->head
== destlist
->head
);
7306 savetail
= origlist
->tail
;
7307 origlist
->head
= *(savetail
);
7308 origlist
->tail
= destlist
->tail
;
7309 destlist
->tail
= savetail
;
7312 #endif /* ENABLE_PLUGINS */
7314 /* Add NAME to the list of garbage collection entry points. */
7317 lang_add_gc_name (const char *name
)
7319 struct bfd_sym_chain
*sym
;
7324 sym
= (struct bfd_sym_chain
*) stat_alloc (sizeof (*sym
));
7326 sym
->next
= link_info
.gc_sym_list
;
7328 link_info
.gc_sym_list
= sym
;
7331 /* Check relocations. */
7334 lang_check_relocs (void)
7336 if (link_info
.check_relocs_after_open_input
)
7340 for (abfd
= link_info
.input_bfds
;
7341 abfd
!= (bfd
*) NULL
; abfd
= abfd
->link
.next
)
7342 if (!bfd_link_check_relocs (abfd
, &link_info
))
7344 /* No object output, fail return. */
7345 config
.make_executable
= FALSE
;
7346 /* Note: we do not abort the loop, but rather
7347 continue the scan in case there are other
7348 bad relocations to report. */
7353 /* Look through all output sections looking for places where we can
7354 propagate forward the lma region. */
7357 lang_propagate_lma_regions (void)
7359 lang_output_section_statement_type
*os
;
7361 for (os
= &lang_os_list
.head
->output_section_statement
;
7365 if (os
->prev
!= NULL
7366 && os
->lma_region
== NULL
7367 && os
->load_base
== NULL
7368 && os
->addr_tree
== NULL
7369 && os
->region
== os
->prev
->region
)
7370 os
->lma_region
= os
->prev
->lma_region
;
7377 /* Finalize dynamic list. */
7378 if (link_info
.dynamic_list
)
7379 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
7381 current_target
= default_target
;
7383 /* Open the output file. */
7384 lang_for_each_statement (ldlang_open_output
);
7387 ldemul_create_output_section_statements ();
7389 /* Add to the hash table all undefineds on the command line. */
7390 lang_place_undefineds ();
7392 if (!bfd_section_already_linked_table_init ())
7393 einfo (_("%F%P: can not create hash table: %E\n"));
7395 /* Create a bfd for each input file. */
7396 current_target
= default_target
;
7397 lang_statement_iteration
++;
7398 open_input_bfds (statement_list
.head
, OPEN_BFD_NORMAL
);
7399 /* open_input_bfds also handles assignments, so we can give values
7400 to symbolic origin/length now. */
7401 lang_do_memory_regions ();
7403 #ifdef ENABLE_PLUGINS
7404 if (link_info
.lto_plugin_active
)
7406 lang_statement_list_type added
;
7407 lang_statement_list_type files
, inputfiles
;
7409 /* Now all files are read, let the plugin(s) decide if there
7410 are any more to be added to the link before we call the
7411 emulation's after_open hook. We create a private list of
7412 input statements for this purpose, which we will eventually
7413 insert into the global statement list after the first claimed
7416 /* We need to manipulate all three chains in synchrony. */
7418 inputfiles
= input_file_chain
;
7419 if (plugin_call_all_symbols_read ())
7420 einfo (_("%F%P: %s: plugin reported error after all symbols read\n"),
7421 plugin_error_plugin ());
7422 /* Open any newly added files, updating the file chains. */
7423 open_input_bfds (*added
.tail
, OPEN_BFD_NORMAL
);
7424 /* Restore the global list pointer now they have all been added. */
7425 lang_list_remove_tail (stat_ptr
, &added
);
7426 /* And detach the fresh ends of the file lists. */
7427 lang_list_remove_tail (&file_chain
, &files
);
7428 lang_list_remove_tail (&input_file_chain
, &inputfiles
);
7429 /* Were any new files added? */
7430 if (added
.head
!= NULL
)
7432 /* If so, we will insert them into the statement list immediately
7433 after the first input file that was claimed by the plugin. */
7434 plugin_insert
= find_replacements_insert_point ();
7435 /* If a plugin adds input files without having claimed any, we
7436 don't really have a good idea where to place them. Just putting
7437 them at the start or end of the list is liable to leave them
7438 outside the crtbegin...crtend range. */
7439 ASSERT (plugin_insert
!= NULL
);
7440 /* Splice the new statement list into the old one. */
7441 lang_list_insert_after (stat_ptr
, &added
,
7442 &plugin_insert
->header
.next
);
7443 /* Likewise for the file chains. */
7444 lang_list_insert_after (&input_file_chain
, &inputfiles
,
7445 &plugin_insert
->next_real_file
);
7446 /* We must be careful when relinking file_chain; we may need to
7447 insert the new files at the head of the list if the insert
7448 point chosen is the dummy first input file. */
7449 if (plugin_insert
->filename
)
7450 lang_list_insert_after (&file_chain
, &files
, &plugin_insert
->next
);
7452 lang_list_insert_after (&file_chain
, &files
, &file_chain
.head
);
7454 /* Rescan archives in case new undefined symbols have appeared. */
7456 lang_statement_iteration
++;
7457 open_input_bfds (statement_list
.head
, OPEN_BFD_RESCAN
);
7458 lang_list_remove_tail (&file_chain
, &files
);
7459 while (files
.head
!= NULL
)
7461 lang_statement_union_type
**insert
;
7462 lang_statement_union_type
**iter
, *temp
;
7465 insert
= find_rescan_insertion (&files
.head
->input_statement
);
7466 /* All elements from an archive can be added at once. */
7467 iter
= &files
.head
->input_statement
.next
;
7468 my_arch
= files
.head
->input_statement
.the_bfd
->my_archive
;
7469 if (my_arch
!= NULL
)
7470 for (; *iter
!= NULL
; iter
= &(*iter
)->input_statement
.next
)
7471 if ((*iter
)->input_statement
.the_bfd
->my_archive
!= my_arch
)
7474 *insert
= files
.head
;
7477 if (my_arch
!= NULL
)
7479 lang_input_statement_type
*parent
= my_arch
->usrdata
;
7481 parent
->next
= (lang_statement_union_type
*)
7483 - offsetof (lang_input_statement_type
, next
));
7488 #endif /* ENABLE_PLUGINS */
7490 /* Make sure that nobody has tried to add a symbol to this list
7492 ASSERT (link_info
.gc_sym_list
== NULL
);
7494 link_info
.gc_sym_list
= &entry_symbol
;
7496 if (entry_symbol
.name
== NULL
)
7498 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
7500 /* entry_symbol is normally initialied by a ENTRY definition in the
7501 linker script or the -e command line option. But if neither of
7502 these have been used, the target specific backend may still have
7503 provided an entry symbol via a call to lang_default_entry().
7504 Unfortunately this value will not be processed until lang_end()
7505 is called, long after this function has finished. So detect this
7506 case here and add the target's entry symbol to the list of starting
7507 points for garbage collection resolution. */
7508 lang_add_gc_name (entry_symbol_default
);
7511 lang_add_gc_name (link_info
.init_function
);
7512 lang_add_gc_name (link_info
.fini_function
);
7514 ldemul_after_open ();
7515 if (config
.map_file
!= NULL
)
7516 lang_print_asneeded ();
7518 bfd_section_already_linked_table_free ();
7520 /* Make sure that we're not mixing architectures. We call this
7521 after all the input files have been opened, but before we do any
7522 other processing, so that any operations merge_private_bfd_data
7523 does on the output file will be known during the rest of the
7527 /* Handle .exports instead of a version script if we're told to do so. */
7528 if (command_line
.version_exports_section
)
7529 lang_do_version_exports_section ();
7531 /* Build all sets based on the information gathered from the input
7533 ldctor_build_sets ();
7535 /* Give initial values for __start and __stop symbols, so that ELF
7536 gc_sections will keep sections referenced by these symbols. Must
7537 be done before lang_do_assignments below. */
7538 if (config
.build_constructors
)
7539 lang_init_start_stop ();
7541 /* PR 13683: We must rerun the assignments prior to running garbage
7542 collection in order to make sure that all symbol aliases are resolved. */
7543 lang_do_assignments (lang_mark_phase_enum
);
7544 expld
.phase
= lang_first_phase_enum
;
7546 /* Size up the common data. */
7549 /* Remove unreferenced sections if asked to. */
7550 lang_gc_sections ();
7552 /* Check relocations. */
7553 lang_check_relocs ();
7555 ldemul_after_check_relocs ();
7557 /* Update wild statements. */
7558 update_wild_statements (statement_list
.head
);
7560 /* Run through the contours of the script and attach input sections
7561 to the correct output sections. */
7562 lang_statement_iteration
++;
7563 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
7565 /* Start at the statement immediately after the special abs_section
7566 output statement, so that it isn't reordered. */
7567 process_insert_statements (&lang_os_list
.head
->header
.next
);
7569 /* Find any sections not attached explicitly and handle them. */
7570 lang_place_orphans ();
7572 if (!bfd_link_relocatable (&link_info
))
7576 /* Merge SEC_MERGE sections. This has to be done after GC of
7577 sections, so that GCed sections are not merged, but before
7578 assigning dynamic symbols, since removing whole input sections
7580 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
7582 /* Look for a text section and set the readonly attribute in it. */
7583 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
7587 if (config
.text_read_only
)
7588 found
->flags
|= SEC_READONLY
;
7590 found
->flags
&= ~SEC_READONLY
;
7594 /* Copy forward lma regions for output sections in same lma region. */
7595 lang_propagate_lma_regions ();
7597 /* Defining __start/__stop symbols early for --gc-sections to work
7598 around a glibc build problem can result in these symbols being
7599 defined when they should not be. Fix them now. */
7600 if (config
.build_constructors
)
7601 lang_undef_start_stop ();
7603 /* Define .startof./.sizeof. symbols with preliminary values before
7604 dynamic symbols are created. */
7605 if (!bfd_link_relocatable (&link_info
))
7606 lang_init_startof_sizeof ();
7608 /* Do anything special before sizing sections. This is where ELF
7609 and other back-ends size dynamic sections. */
7610 ldemul_before_allocation ();
7612 /* We must record the program headers before we try to fix the
7613 section positions, since they will affect SIZEOF_HEADERS. */
7614 lang_record_phdrs ();
7616 /* Check relro sections. */
7617 if (link_info
.relro
&& !bfd_link_relocatable (&link_info
))
7618 lang_find_relro_sections ();
7620 /* Size up the sections. */
7621 lang_size_sections (NULL
, !RELAXATION_ENABLED
);
7623 /* See if anything special should be done now we know how big
7624 everything is. This is where relaxation is done. */
7625 ldemul_after_allocation ();
7627 /* Fix any __start, __stop, .startof. or .sizeof. symbols. */
7628 lang_finalize_start_stop ();
7630 /* Do all the assignments again, to report errors. Assignment
7631 statements are processed multiple times, updating symbols; In
7632 open_input_bfds, lang_do_assignments, and lang_size_sections.
7633 Since lang_relax_sections calls lang_do_assignments, symbols are
7634 also updated in ldemul_after_allocation. */
7635 lang_do_assignments (lang_final_phase_enum
);
7639 /* Convert absolute symbols to section relative. */
7640 ldexp_finalize_syms ();
7642 /* Make sure that the section addresses make sense. */
7643 if (command_line
.check_section_addresses
)
7644 lang_check_section_addresses ();
7646 /* Check any required symbols are known. */
7647 ldlang_check_require_defined_symbols ();
7652 /* EXPORTED TO YACC */
7655 lang_add_wild (struct wildcard_spec
*filespec
,
7656 struct wildcard_list
*section_list
,
7657 bfd_boolean keep_sections
)
7659 struct wildcard_list
*curr
, *next
;
7660 lang_wild_statement_type
*new_stmt
;
7662 /* Reverse the list as the parser puts it back to front. */
7663 for (curr
= section_list
, section_list
= NULL
;
7665 section_list
= curr
, curr
= next
)
7668 curr
->next
= section_list
;
7671 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
7673 if (strcmp (filespec
->name
, "*") == 0)
7674 filespec
->name
= NULL
;
7675 else if (!wildcardp (filespec
->name
))
7676 lang_has_input_file
= TRUE
;
7679 new_stmt
= new_stat (lang_wild_statement
, stat_ptr
);
7680 new_stmt
->filename
= NULL
;
7681 new_stmt
->filenames_sorted
= FALSE
;
7682 new_stmt
->section_flag_list
= NULL
;
7683 new_stmt
->exclude_name_list
= NULL
;
7684 if (filespec
!= NULL
)
7686 new_stmt
->filename
= filespec
->name
;
7687 new_stmt
->filenames_sorted
= filespec
->sorted
== by_name
;
7688 new_stmt
->section_flag_list
= filespec
->section_flag_list
;
7689 new_stmt
->exclude_name_list
= filespec
->exclude_name_list
;
7691 new_stmt
->section_list
= section_list
;
7692 new_stmt
->keep_sections
= keep_sections
;
7693 lang_list_init (&new_stmt
->children
);
7694 analyze_walk_wild_section_handler (new_stmt
);
7698 lang_section_start (const char *name
, etree_type
*address
,
7699 const segment_type
*segment
)
7701 lang_address_statement_type
*ad
;
7703 ad
= new_stat (lang_address_statement
, stat_ptr
);
7704 ad
->section_name
= name
;
7705 ad
->address
= address
;
7706 ad
->segment
= segment
;
7709 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
7710 because of a -e argument on the command line, or zero if this is
7711 called by ENTRY in a linker script. Command line arguments take
7715 lang_add_entry (const char *name
, bfd_boolean cmdline
)
7717 if (entry_symbol
.name
== NULL
7719 || !entry_from_cmdline
)
7721 entry_symbol
.name
= name
;
7722 entry_from_cmdline
= cmdline
;
7726 /* Set the default start symbol to NAME. .em files should use this,
7727 not lang_add_entry, to override the use of "start" if neither the
7728 linker script nor the command line specifies an entry point. NAME
7729 must be permanently allocated. */
7731 lang_default_entry (const char *name
)
7733 entry_symbol_default
= name
;
7737 lang_add_target (const char *name
)
7739 lang_target_statement_type
*new_stmt
;
7741 new_stmt
= new_stat (lang_target_statement
, stat_ptr
);
7742 new_stmt
->target
= name
;
7746 lang_add_map (const char *name
)
7753 map_option_f
= TRUE
;
7761 lang_add_fill (fill_type
*fill
)
7763 lang_fill_statement_type
*new_stmt
;
7765 new_stmt
= new_stat (lang_fill_statement
, stat_ptr
);
7766 new_stmt
->fill
= fill
;
7770 lang_add_data (int type
, union etree_union
*exp
)
7772 lang_data_statement_type
*new_stmt
;
7774 new_stmt
= new_stat (lang_data_statement
, stat_ptr
);
7775 new_stmt
->exp
= exp
;
7776 new_stmt
->type
= type
;
7779 /* Create a new reloc statement. RELOC is the BFD relocation type to
7780 generate. HOWTO is the corresponding howto structure (we could
7781 look this up, but the caller has already done so). SECTION is the
7782 section to generate a reloc against, or NAME is the name of the
7783 symbol to generate a reloc against. Exactly one of SECTION and
7784 NAME must be NULL. ADDEND is an expression for the addend. */
7787 lang_add_reloc (bfd_reloc_code_real_type reloc
,
7788 reloc_howto_type
*howto
,
7791 union etree_union
*addend
)
7793 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
7797 p
->section
= section
;
7799 p
->addend_exp
= addend
;
7801 p
->addend_value
= 0;
7802 p
->output_section
= NULL
;
7803 p
->output_offset
= 0;
7806 lang_assignment_statement_type
*
7807 lang_add_assignment (etree_type
*exp
)
7809 lang_assignment_statement_type
*new_stmt
;
7811 new_stmt
= new_stat (lang_assignment_statement
, stat_ptr
);
7812 new_stmt
->exp
= exp
;
7817 lang_add_attribute (enum statement_enum attribute
)
7819 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
7823 lang_startup (const char *name
)
7825 if (first_file
->filename
!= NULL
)
7827 einfo (_("%F%P: multiple STARTUP files\n"));
7829 first_file
->filename
= name
;
7830 first_file
->local_sym_name
= name
;
7831 first_file
->flags
.real
= TRUE
;
7835 lang_float (bfd_boolean maybe
)
7837 lang_float_flag
= maybe
;
7841 /* Work out the load- and run-time regions from a script statement, and
7842 store them in *LMA_REGION and *REGION respectively.
7844 MEMSPEC is the name of the run-time region, or the value of
7845 DEFAULT_MEMORY_REGION if the statement didn't specify one.
7846 LMA_MEMSPEC is the name of the load-time region, or null if the
7847 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
7848 had an explicit load address.
7850 It is an error to specify both a load region and a load address. */
7853 lang_get_regions (lang_memory_region_type
**region
,
7854 lang_memory_region_type
**lma_region
,
7855 const char *memspec
,
7856 const char *lma_memspec
,
7857 bfd_boolean have_lma
,
7858 bfd_boolean have_vma
)
7860 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
7862 /* If no runtime region or VMA has been specified, but the load region
7863 has been specified, then use the load region for the runtime region
7865 if (lma_memspec
!= NULL
7867 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
7868 *region
= *lma_region
;
7870 *region
= lang_memory_region_lookup (memspec
, FALSE
);
7872 if (have_lma
&& lma_memspec
!= 0)
7873 einfo (_("%X%P:%pS: section has both a load address and a load region\n"),
7878 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
7879 lang_output_section_phdr_list
*phdrs
,
7880 const char *lma_memspec
)
7882 lang_get_regions (¤t_section
->region
,
7883 ¤t_section
->lma_region
,
7884 memspec
, lma_memspec
,
7885 current_section
->load_base
!= NULL
,
7886 current_section
->addr_tree
!= NULL
);
7888 current_section
->fill
= fill
;
7889 current_section
->phdrs
= phdrs
;
7894 lang_statement_append (lang_statement_list_type
*list
,
7895 lang_statement_union_type
*element
,
7896 lang_statement_union_type
**field
)
7898 *(list
->tail
) = element
;
7902 /* Set the output format type. -oformat overrides scripts. */
7905 lang_add_output_format (const char *format
,
7910 if (output_target
== NULL
|| !from_script
)
7912 if (command_line
.endian
== ENDIAN_BIG
7915 else if (command_line
.endian
== ENDIAN_LITTLE
7919 output_target
= format
;
7924 lang_add_insert (const char *where
, int is_before
)
7926 lang_insert_statement_type
*new_stmt
;
7928 new_stmt
= new_stat (lang_insert_statement
, stat_ptr
);
7929 new_stmt
->where
= where
;
7930 new_stmt
->is_before
= is_before
;
7931 saved_script_handle
= previous_script_handle
;
7934 /* Enter a group. This creates a new lang_group_statement, and sets
7935 stat_ptr to build new statements within the group. */
7938 lang_enter_group (void)
7940 lang_group_statement_type
*g
;
7942 g
= new_stat (lang_group_statement
, stat_ptr
);
7943 lang_list_init (&g
->children
);
7944 push_stat_ptr (&g
->children
);
7947 /* Leave a group. This just resets stat_ptr to start writing to the
7948 regular list of statements again. Note that this will not work if
7949 groups can occur inside anything else which can adjust stat_ptr,
7950 but currently they can't. */
7953 lang_leave_group (void)
7958 /* Add a new program header. This is called for each entry in a PHDRS
7959 command in a linker script. */
7962 lang_new_phdr (const char *name
,
7964 bfd_boolean filehdr
,
7969 struct lang_phdr
*n
, **pp
;
7972 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
7975 n
->type
= exp_get_vma (type
, 0, "program header type");
7976 n
->filehdr
= filehdr
;
7981 hdrs
= n
->type
== 1 && (phdrs
|| filehdr
);
7983 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
7986 && !((*pp
)->filehdr
|| (*pp
)->phdrs
))
7988 einfo (_("%X%P:%pS: PHDRS and FILEHDR are not supported"
7989 " when prior PT_LOAD headers lack them\n"), NULL
);
7996 /* Record the program header information in the output BFD. FIXME: We
7997 should not be calling an ELF specific function here. */
8000 lang_record_phdrs (void)
8004 lang_output_section_phdr_list
*last
;
8005 struct lang_phdr
*l
;
8006 lang_output_section_statement_type
*os
;
8009 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
8012 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
8019 for (os
= &lang_os_list
.head
->output_section_statement
;
8023 lang_output_section_phdr_list
*pl
;
8025 if (os
->constraint
< 0)
8033 if (os
->sectype
== noload_section
8034 || os
->bfd_section
== NULL
8035 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
8038 /* Don't add orphans to PT_INTERP header. */
8044 lang_output_section_statement_type
*tmp_os
;
8046 /* If we have not run across a section with a program
8047 header assigned to it yet, then scan forwards to find
8048 one. This prevents inconsistencies in the linker's
8049 behaviour when a script has specified just a single
8050 header and there are sections in that script which are
8051 not assigned to it, and which occur before the first
8052 use of that header. See here for more details:
8053 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
8054 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
8057 last
= tmp_os
->phdrs
;
8061 einfo (_("%F%P: no sections assigned to phdrs\n"));
8066 if (os
->bfd_section
== NULL
)
8069 for (; pl
!= NULL
; pl
= pl
->next
)
8071 if (strcmp (pl
->name
, l
->name
) == 0)
8076 secs
= (asection
**) xrealloc (secs
,
8077 alc
* sizeof (asection
*));
8079 secs
[c
] = os
->bfd_section
;
8086 if (l
->flags
== NULL
)
8089 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
8094 at
= exp_get_vma (l
->at
, 0, "phdr load address");
8096 if (!bfd_record_phdr (link_info
.output_bfd
, l
->type
,
8097 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
8098 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
8099 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
8104 /* Make sure all the phdr assignments succeeded. */
8105 for (os
= &lang_os_list
.head
->output_section_statement
;
8109 lang_output_section_phdr_list
*pl
;
8111 if (os
->constraint
< 0
8112 || os
->bfd_section
== NULL
)
8115 for (pl
= os
->phdrs
;
8118 if (!pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
8119 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
8120 os
->name
, pl
->name
);
8124 /* Record a list of sections which may not be cross referenced. */
8127 lang_add_nocrossref (lang_nocrossref_type
*l
)
8129 struct lang_nocrossrefs
*n
;
8131 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
8132 n
->next
= nocrossref_list
;
8134 n
->onlyfirst
= FALSE
;
8135 nocrossref_list
= n
;
8137 /* Set notice_all so that we get informed about all symbols. */
8138 link_info
.notice_all
= TRUE
;
8141 /* Record a section that cannot be referenced from a list of sections. */
8144 lang_add_nocrossref_to (lang_nocrossref_type
*l
)
8146 lang_add_nocrossref (l
);
8147 nocrossref_list
->onlyfirst
= TRUE
;
8150 /* Overlay handling. We handle overlays with some static variables. */
8152 /* The overlay virtual address. */
8153 static etree_type
*overlay_vma
;
8154 /* And subsection alignment. */
8155 static etree_type
*overlay_subalign
;
8157 /* An expression for the maximum section size seen so far. */
8158 static etree_type
*overlay_max
;
8160 /* A list of all the sections in this overlay. */
8162 struct overlay_list
{
8163 struct overlay_list
*next
;
8164 lang_output_section_statement_type
*os
;
8167 static struct overlay_list
*overlay_list
;
8169 /* Start handling an overlay. */
8172 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
8174 /* The grammar should prevent nested overlays from occurring. */
8175 ASSERT (overlay_vma
== NULL
8176 && overlay_subalign
== NULL
8177 && overlay_max
== NULL
);
8179 overlay_vma
= vma_expr
;
8180 overlay_subalign
= subalign
;
8183 /* Start a section in an overlay. We handle this by calling
8184 lang_enter_output_section_statement with the correct VMA.
8185 lang_leave_overlay sets up the LMA and memory regions. */
8188 lang_enter_overlay_section (const char *name
)
8190 struct overlay_list
*n
;
8193 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
8194 0, overlay_subalign
, 0, 0, 0);
8196 /* If this is the first section, then base the VMA of future
8197 sections on this one. This will work correctly even if `.' is
8198 used in the addresses. */
8199 if (overlay_list
== NULL
)
8200 overlay_vma
= exp_nameop (ADDR
, name
);
8202 /* Remember the section. */
8203 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
8204 n
->os
= current_section
;
8205 n
->next
= overlay_list
;
8208 size
= exp_nameop (SIZEOF
, name
);
8210 /* Arrange to work out the maximum section end address. */
8211 if (overlay_max
== NULL
)
8214 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
8217 /* Finish a section in an overlay. There isn't any special to do
8221 lang_leave_overlay_section (fill_type
*fill
,
8222 lang_output_section_phdr_list
*phdrs
)
8229 name
= current_section
->name
;
8231 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
8232 region and that no load-time region has been specified. It doesn't
8233 really matter what we say here, since lang_leave_overlay will
8235 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
8237 /* Define the magic symbols. */
8239 clean
= (char *) xmalloc (strlen (name
) + 1);
8241 for (s1
= name
; *s1
!= '\0'; s1
++)
8242 if (ISALNUM (*s1
) || *s1
== '_')
8246 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_start_");
8247 sprintf (buf
, "__load_start_%s", clean
);
8248 lang_add_assignment (exp_provide (buf
,
8249 exp_nameop (LOADADDR
, name
),
8252 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_stop_");
8253 sprintf (buf
, "__load_stop_%s", clean
);
8254 lang_add_assignment (exp_provide (buf
,
8256 exp_nameop (LOADADDR
, name
),
8257 exp_nameop (SIZEOF
, name
)),
8263 /* Finish an overlay. If there are any overlay wide settings, this
8264 looks through all the sections in the overlay and sets them. */
8267 lang_leave_overlay (etree_type
*lma_expr
,
8270 const char *memspec
,
8271 lang_output_section_phdr_list
*phdrs
,
8272 const char *lma_memspec
)
8274 lang_memory_region_type
*region
;
8275 lang_memory_region_type
*lma_region
;
8276 struct overlay_list
*l
;
8277 lang_nocrossref_type
*nocrossref
;
8279 lang_get_regions (®ion
, &lma_region
,
8280 memspec
, lma_memspec
,
8281 lma_expr
!= NULL
, FALSE
);
8285 /* After setting the size of the last section, set '.' to end of the
8287 if (overlay_list
!= NULL
)
8289 overlay_list
->os
->update_dot
= 1;
8290 overlay_list
->os
->update_dot_tree
8291 = exp_assign (".", exp_binop ('+', overlay_vma
, overlay_max
), FALSE
);
8297 struct overlay_list
*next
;
8299 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
8302 l
->os
->region
= region
;
8303 l
->os
->lma_region
= lma_region
;
8305 /* The first section has the load address specified in the
8306 OVERLAY statement. The rest are worked out from that.
8307 The base address is not needed (and should be null) if
8308 an LMA region was specified. */
8311 l
->os
->load_base
= lma_expr
;
8312 l
->os
->sectype
= first_overlay_section
;
8314 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
8315 l
->os
->phdrs
= phdrs
;
8319 lang_nocrossref_type
*nc
;
8321 nc
= (lang_nocrossref_type
*) xmalloc (sizeof *nc
);
8322 nc
->name
= l
->os
->name
;
8323 nc
->next
= nocrossref
;
8332 if (nocrossref
!= NULL
)
8333 lang_add_nocrossref (nocrossref
);
8336 overlay_list
= NULL
;
8338 overlay_subalign
= NULL
;
8341 /* Version handling. This is only useful for ELF. */
8343 /* If PREV is NULL, return first version pattern matching particular symbol.
8344 If PREV is non-NULL, return first version pattern matching particular
8345 symbol after PREV (previously returned by lang_vers_match). */
8347 static struct bfd_elf_version_expr
*
8348 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
8349 struct bfd_elf_version_expr
*prev
,
8353 const char *cxx_sym
= sym
;
8354 const char *java_sym
= sym
;
8355 struct bfd_elf_version_expr
*expr
= NULL
;
8356 enum demangling_styles curr_style
;
8358 curr_style
= CURRENT_DEMANGLING_STYLE
;
8359 cplus_demangle_set_style (no_demangling
);
8360 c_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_NO_OPTS
);
8363 cplus_demangle_set_style (curr_style
);
8365 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8367 cxx_sym
= bfd_demangle (link_info
.output_bfd
, sym
,
8368 DMGL_PARAMS
| DMGL_ANSI
);
8372 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8374 java_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_JAVA
);
8379 if (head
->htab
&& (prev
== NULL
|| prev
->literal
))
8381 struct bfd_elf_version_expr e
;
8383 switch (prev
? prev
->mask
: 0)
8386 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
8389 expr
= (struct bfd_elf_version_expr
*)
8390 htab_find ((htab_t
) head
->htab
, &e
);
8391 while (expr
&& strcmp (expr
->pattern
, c_sym
) == 0)
8392 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
8398 case BFD_ELF_VERSION_C_TYPE
:
8399 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8401 e
.pattern
= cxx_sym
;
8402 expr
= (struct bfd_elf_version_expr
*)
8403 htab_find ((htab_t
) head
->htab
, &e
);
8404 while (expr
&& strcmp (expr
->pattern
, cxx_sym
) == 0)
8405 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
8411 case BFD_ELF_VERSION_CXX_TYPE
:
8412 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8414 e
.pattern
= java_sym
;
8415 expr
= (struct bfd_elf_version_expr
*)
8416 htab_find ((htab_t
) head
->htab
, &e
);
8417 while (expr
&& strcmp (expr
->pattern
, java_sym
) == 0)
8418 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8429 /* Finally, try the wildcards. */
8430 if (prev
== NULL
|| prev
->literal
)
8431 expr
= head
->remaining
;
8434 for (; expr
; expr
= expr
->next
)
8441 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
8444 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8446 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
8450 if (fnmatch (expr
->pattern
, s
, 0) == 0)
8456 free ((char *) c_sym
);
8458 free ((char *) cxx_sym
);
8459 if (java_sym
!= sym
)
8460 free ((char *) java_sym
);
8464 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
8465 return a pointer to the symbol name with any backslash quotes removed. */
8468 realsymbol (const char *pattern
)
8471 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
8472 char *s
, *symbol
= (char *) xmalloc (strlen (pattern
) + 1);
8474 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
8476 /* It is a glob pattern only if there is no preceding
8480 /* Remove the preceding backslash. */
8487 if (*p
== '?' || *p
== '*' || *p
== '[')
8494 backslash
= *p
== '\\';
8510 /* This is called for each variable name or match expression. NEW_NAME is
8511 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
8512 pattern to be matched against symbol names. */
8514 struct bfd_elf_version_expr
*
8515 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
8516 const char *new_name
,
8518 bfd_boolean literal_p
)
8520 struct bfd_elf_version_expr
*ret
;
8522 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
8526 ret
->literal
= TRUE
;
8527 ret
->pattern
= literal_p
? new_name
: realsymbol (new_name
);
8528 if (ret
->pattern
== NULL
)
8530 ret
->pattern
= new_name
;
8531 ret
->literal
= FALSE
;
8534 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
8535 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
8536 else if (strcasecmp (lang
, "C++") == 0)
8537 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
8538 else if (strcasecmp (lang
, "Java") == 0)
8539 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
8542 einfo (_("%X%P: unknown language `%s' in version information\n"),
8544 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
8547 return ldemul_new_vers_pattern (ret
);
8550 /* This is called for each set of variable names and match
8553 struct bfd_elf_version_tree
*
8554 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
8555 struct bfd_elf_version_expr
*locals
)
8557 struct bfd_elf_version_tree
*ret
;
8559 ret
= (struct bfd_elf_version_tree
*) xcalloc (1, sizeof *ret
);
8560 ret
->globals
.list
= globals
;
8561 ret
->locals
.list
= locals
;
8562 ret
->match
= lang_vers_match
;
8563 ret
->name_indx
= (unsigned int) -1;
8567 /* This static variable keeps track of version indices. */
8569 static int version_index
;
8572 version_expr_head_hash (const void *p
)
8574 const struct bfd_elf_version_expr
*e
=
8575 (const struct bfd_elf_version_expr
*) p
;
8577 return htab_hash_string (e
->pattern
);
8581 version_expr_head_eq (const void *p1
, const void *p2
)
8583 const struct bfd_elf_version_expr
*e1
=
8584 (const struct bfd_elf_version_expr
*) p1
;
8585 const struct bfd_elf_version_expr
*e2
=
8586 (const struct bfd_elf_version_expr
*) p2
;
8588 return strcmp (e1
->pattern
, e2
->pattern
) == 0;
8592 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
8595 struct bfd_elf_version_expr
*e
, *next
;
8596 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
8598 for (e
= head
->list
; e
; e
= e
->next
)
8602 head
->mask
|= e
->mask
;
8607 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
8608 version_expr_head_eq
, NULL
);
8609 list_loc
= &head
->list
;
8610 remaining_loc
= &head
->remaining
;
8611 for (e
= head
->list
; e
; e
= next
)
8617 remaining_loc
= &e
->next
;
8621 void **loc
= htab_find_slot ((htab_t
) head
->htab
, e
, INSERT
);
8625 struct bfd_elf_version_expr
*e1
, *last
;
8627 e1
= (struct bfd_elf_version_expr
*) *loc
;
8631 if (e1
->mask
== e
->mask
)
8639 while (e1
&& strcmp (e1
->pattern
, e
->pattern
) == 0);
8643 /* This is a duplicate. */
8644 /* FIXME: Memory leak. Sometimes pattern is not
8645 xmalloced alone, but in larger chunk of memory. */
8646 /* free (e->pattern); */
8651 e
->next
= last
->next
;
8659 list_loc
= &e
->next
;
8663 *remaining_loc
= NULL
;
8664 *list_loc
= head
->remaining
;
8667 head
->remaining
= head
->list
;
8670 /* This is called when we know the name and dependencies of the
8674 lang_register_vers_node (const char *name
,
8675 struct bfd_elf_version_tree
*version
,
8676 struct bfd_elf_version_deps
*deps
)
8678 struct bfd_elf_version_tree
*t
, **pp
;
8679 struct bfd_elf_version_expr
*e1
;
8684 if (link_info
.version_info
!= NULL
8685 && (name
[0] == '\0' || link_info
.version_info
->name
[0] == '\0'))
8687 einfo (_("%X%P: anonymous version tag cannot be combined"
8688 " with other version tags\n"));
8693 /* Make sure this node has a unique name. */
8694 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8695 if (strcmp (t
->name
, name
) == 0)
8696 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
8698 lang_finalize_version_expr_head (&version
->globals
);
8699 lang_finalize_version_expr_head (&version
->locals
);
8701 /* Check the global and local match names, and make sure there
8702 aren't any duplicates. */
8704 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
8706 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8708 struct bfd_elf_version_expr
*e2
;
8710 if (t
->locals
.htab
&& e1
->literal
)
8712 e2
= (struct bfd_elf_version_expr
*)
8713 htab_find ((htab_t
) t
->locals
.htab
, e1
);
8714 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
8716 if (e1
->mask
== e2
->mask
)
8717 einfo (_("%X%P: duplicate expression `%s'"
8718 " in version information\n"), e1
->pattern
);
8722 else if (!e1
->literal
)
8723 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
8724 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
8725 && e1
->mask
== e2
->mask
)
8726 einfo (_("%X%P: duplicate expression `%s'"
8727 " in version information\n"), e1
->pattern
);
8731 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
8733 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8735 struct bfd_elf_version_expr
*e2
;
8737 if (t
->globals
.htab
&& e1
->literal
)
8739 e2
= (struct bfd_elf_version_expr
*)
8740 htab_find ((htab_t
) t
->globals
.htab
, e1
);
8741 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
8743 if (e1
->mask
== e2
->mask
)
8744 einfo (_("%X%P: duplicate expression `%s'"
8745 " in version information\n"),
8750 else if (!e1
->literal
)
8751 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
8752 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
8753 && e1
->mask
== e2
->mask
)
8754 einfo (_("%X%P: duplicate expression `%s'"
8755 " in version information\n"), e1
->pattern
);
8759 version
->deps
= deps
;
8760 version
->name
= name
;
8761 if (name
[0] != '\0')
8764 version
->vernum
= version_index
;
8767 version
->vernum
= 0;
8769 for (pp
= &link_info
.version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
8774 /* This is called when we see a version dependency. */
8776 struct bfd_elf_version_deps
*
8777 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
8779 struct bfd_elf_version_deps
*ret
;
8780 struct bfd_elf_version_tree
*t
;
8782 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
8785 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8787 if (strcmp (t
->name
, name
) == 0)
8789 ret
->version_needed
= t
;
8794 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
8796 ret
->version_needed
= NULL
;
8801 lang_do_version_exports_section (void)
8803 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
8805 LANG_FOR_EACH_INPUT_STATEMENT (is
)
8807 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
8815 contents
= (char *) xmalloc (len
);
8816 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
8817 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
8820 while (p
< contents
+ len
)
8822 greg
= lang_new_vers_pattern (greg
, p
, NULL
, FALSE
);
8823 p
= strchr (p
, '\0') + 1;
8826 /* Do not free the contents, as we used them creating the regex. */
8828 /* Do not include this section in the link. */
8829 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
8832 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, FALSE
);
8833 lang_register_vers_node (command_line
.version_exports_section
,
8834 lang_new_vers_node (greg
, lreg
), NULL
);
8837 /* Evaluate LENGTH and ORIGIN parts of MEMORY spec */
8840 lang_do_memory_regions (void)
8842 lang_memory_region_type
*r
= lang_memory_region_list
;
8844 for (; r
!= NULL
; r
= r
->next
)
8848 exp_fold_tree_no_dot (r
->origin_exp
);
8849 if (expld
.result
.valid_p
)
8851 r
->origin
= expld
.result
.value
;
8852 r
->current
= r
->origin
;
8855 einfo (_("%F%P: invalid origin for memory region %s\n"),
8860 exp_fold_tree_no_dot (r
->length_exp
);
8861 if (expld
.result
.valid_p
)
8862 r
->length
= expld
.result
.value
;
8864 einfo (_("%F%P: invalid length for memory region %s\n"),
8871 lang_add_unique (const char *name
)
8873 struct unique_sections
*ent
;
8875 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
8876 if (strcmp (ent
->name
, name
) == 0)
8879 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
8880 ent
->name
= xstrdup (name
);
8881 ent
->next
= unique_section_list
;
8882 unique_section_list
= ent
;
8885 /* Append the list of dynamic symbols to the existing one. */
8888 lang_append_dynamic_list (struct bfd_elf_version_expr
*dynamic
)
8890 if (link_info
.dynamic_list
)
8892 struct bfd_elf_version_expr
*tail
;
8893 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
8895 tail
->next
= link_info
.dynamic_list
->head
.list
;
8896 link_info
.dynamic_list
->head
.list
= dynamic
;
8900 struct bfd_elf_dynamic_list
*d
;
8902 d
= (struct bfd_elf_dynamic_list
*) xcalloc (1, sizeof *d
);
8903 d
->head
.list
= dynamic
;
8904 d
->match
= lang_vers_match
;
8905 link_info
.dynamic_list
= d
;
8909 /* Append the list of C++ typeinfo dynamic symbols to the existing
8913 lang_append_dynamic_list_cpp_typeinfo (void)
8915 const char *symbols
[] =
8917 "typeinfo name for*",
8920 struct bfd_elf_version_expr
*dynamic
= NULL
;
8923 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
8924 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
8927 lang_append_dynamic_list (dynamic
);
8930 /* Append the list of C++ operator new and delete dynamic symbols to the
8934 lang_append_dynamic_list_cpp_new (void)
8936 const char *symbols
[] =
8941 struct bfd_elf_version_expr
*dynamic
= NULL
;
8944 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
8945 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
8948 lang_append_dynamic_list (dynamic
);
8951 /* Scan a space and/or comma separated string of features. */
8954 lang_ld_feature (char *str
)
8962 while (*p
== ',' || ISSPACE (*p
))
8967 while (*q
&& *q
!= ',' && !ISSPACE (*q
))
8971 if (strcasecmp (p
, "SANE_EXPR") == 0)
8972 config
.sane_expr
= TRUE
;
8974 einfo (_("%X%P: unknown feature `%s'\n"), p
);
8980 /* Pretty print memory amount. */
8983 lang_print_memory_size (bfd_vma sz
)
8985 if ((sz
& 0x3fffffff) == 0)
8986 printf ("%10" BFD_VMA_FMT
"u GB", sz
>> 30);
8987 else if ((sz
& 0xfffff) == 0)
8988 printf ("%10" BFD_VMA_FMT
"u MB", sz
>> 20);
8989 else if ((sz
& 0x3ff) == 0)
8990 printf ("%10" BFD_VMA_FMT
"u KB", sz
>> 10);
8992 printf (" %10" BFD_VMA_FMT
"u B", sz
);
8995 /* Implement --print-memory-usage: disply per region memory usage. */
8998 lang_print_memory_usage (void)
9000 lang_memory_region_type
*r
;
9002 printf ("Memory region Used Size Region Size %%age Used\n");
9003 for (r
= lang_memory_region_list
; r
->next
!= NULL
; r
= r
->next
)
9005 bfd_vma used_length
= r
->current
- r
->origin
;
9008 printf ("%16s: ",r
->name_list
.name
);
9009 lang_print_memory_size (used_length
);
9010 lang_print_memory_size ((bfd_vma
) r
->length
);
9012 percent
= used_length
* 100.0 / r
->length
;
9014 printf (" %6.2f%%\n", percent
);