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 lang_statement_append (lang_statement_list_type
*list
,
1034 *(list
->tail
) = element
;
1039 push_stat_ptr (lang_statement_list_type
*new_ptr
)
1041 if (stat_save_ptr
>= stat_save
+ sizeof (stat_save
) / sizeof (stat_save
[0]))
1043 *stat_save_ptr
++ = stat_ptr
;
1050 if (stat_save_ptr
<= stat_save
)
1052 stat_ptr
= *--stat_save_ptr
;
1055 /* Build a new statement node for the parse tree. */
1057 static lang_statement_union_type
*
1058 new_statement (enum statement_enum type
,
1060 lang_statement_list_type
*list
)
1062 lang_statement_union_type
*new_stmt
;
1064 new_stmt
= (lang_statement_union_type
*) stat_alloc (size
);
1065 new_stmt
->header
.type
= type
;
1066 new_stmt
->header
.next
= NULL
;
1067 lang_statement_append (list
, new_stmt
, &new_stmt
->header
.next
);
1071 /* Build a new input file node for the language. There are several
1072 ways in which we treat an input file, eg, we only look at symbols,
1073 or prefix it with a -l etc.
1075 We can be supplied with requests for input files more than once;
1076 they may, for example be split over several lines like foo.o(.text)
1077 foo.o(.data) etc, so when asked for a file we check that we haven't
1078 got it already so we don't duplicate the bfd. */
1080 static lang_input_statement_type
*
1081 new_afile (const char *name
,
1082 lang_input_file_enum_type file_type
,
1084 bfd_boolean add_to_list
)
1086 lang_input_statement_type
*p
;
1088 lang_has_input_file
= TRUE
;
1091 p
= (lang_input_statement_type
*) new_stat (lang_input_statement
, stat_ptr
);
1094 p
= (lang_input_statement_type
*)
1095 stat_alloc (sizeof (lang_input_statement_type
));
1096 p
->header
.type
= lang_input_statement_enum
;
1097 p
->header
.next
= NULL
;
1100 memset (&p
->the_bfd
, 0,
1101 sizeof (*p
) - offsetof (lang_input_statement_type
, the_bfd
));
1103 p
->flags
.dynamic
= input_flags
.dynamic
;
1104 p
->flags
.add_DT_NEEDED_for_dynamic
= input_flags
.add_DT_NEEDED_for_dynamic
;
1105 p
->flags
.add_DT_NEEDED_for_regular
= input_flags
.add_DT_NEEDED_for_regular
;
1106 p
->flags
.whole_archive
= input_flags
.whole_archive
;
1107 p
->flags
.sysrooted
= input_flags
.sysrooted
;
1111 case lang_input_file_is_symbols_only_enum
:
1113 p
->local_sym_name
= name
;
1114 p
->flags
.real
= TRUE
;
1115 p
->flags
.just_syms
= TRUE
;
1117 case lang_input_file_is_fake_enum
:
1119 p
->local_sym_name
= name
;
1121 case lang_input_file_is_l_enum
:
1122 if (name
[0] == ':' && name
[1] != '\0')
1124 p
->filename
= name
+ 1;
1125 p
->flags
.full_name_provided
= TRUE
;
1129 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
1130 p
->flags
.maybe_archive
= TRUE
;
1131 p
->flags
.real
= TRUE
;
1132 p
->flags
.search_dirs
= TRUE
;
1134 case lang_input_file_is_marker_enum
:
1136 p
->local_sym_name
= name
;
1137 p
->flags
.search_dirs
= TRUE
;
1139 case lang_input_file_is_search_file_enum
:
1141 p
->local_sym_name
= name
;
1142 p
->flags
.real
= TRUE
;
1143 p
->flags
.search_dirs
= TRUE
;
1145 case lang_input_file_is_file_enum
:
1147 p
->local_sym_name
= name
;
1148 p
->flags
.real
= TRUE
;
1154 lang_statement_append (&input_file_chain
, p
, &p
->next_real_file
);
1158 lang_input_statement_type
*
1159 lang_add_input_file (const char *name
,
1160 lang_input_file_enum_type file_type
,
1164 && (*name
== '=' || CONST_STRNEQ (name
, "$SYSROOT")))
1166 lang_input_statement_type
*ret
;
1167 char *sysrooted_name
1168 = concat (ld_sysroot
,
1169 name
+ (*name
== '=' ? 1 : strlen ("$SYSROOT")),
1170 (const char *) NULL
);
1172 /* We've now forcibly prepended the sysroot, making the input
1173 file independent of the context. Therefore, temporarily
1174 force a non-sysrooted context for this statement, so it won't
1175 get the sysroot prepended again when opened. (N.B. if it's a
1176 script, any child nodes with input files starting with "/"
1177 will be handled as "sysrooted" as they'll be found to be
1178 within the sysroot subdirectory.) */
1179 unsigned int outer_sysrooted
= input_flags
.sysrooted
;
1180 input_flags
.sysrooted
= 0;
1181 ret
= new_afile (sysrooted_name
, file_type
, target
, TRUE
);
1182 input_flags
.sysrooted
= outer_sysrooted
;
1186 return new_afile (name
, file_type
, target
, TRUE
);
1189 struct out_section_hash_entry
1191 struct bfd_hash_entry root
;
1192 lang_statement_union_type s
;
1195 /* The hash table. */
1197 static struct bfd_hash_table output_section_statement_table
;
1199 /* Support routines for the hash table used by lang_output_section_find,
1200 initialize the table, fill in an entry and remove the table. */
1202 static struct bfd_hash_entry
*
1203 output_section_statement_newfunc (struct bfd_hash_entry
*entry
,
1204 struct bfd_hash_table
*table
,
1207 lang_output_section_statement_type
**nextp
;
1208 struct out_section_hash_entry
*ret
;
1212 entry
= (struct bfd_hash_entry
*) bfd_hash_allocate (table
,
1218 entry
= bfd_hash_newfunc (entry
, table
, string
);
1222 ret
= (struct out_section_hash_entry
*) entry
;
1223 memset (&ret
->s
, 0, sizeof (ret
->s
));
1224 ret
->s
.header
.type
= lang_output_section_statement_enum
;
1225 ret
->s
.output_section_statement
.subsection_alignment
= NULL
;
1226 ret
->s
.output_section_statement
.section_alignment
= NULL
;
1227 ret
->s
.output_section_statement
.block_value
= 1;
1228 lang_list_init (&ret
->s
.output_section_statement
.children
);
1229 lang_statement_append (stat_ptr
, &ret
->s
, &ret
->s
.header
.next
);
1231 /* For every output section statement added to the list, except the
1232 first one, lang_os_list.tail points to the "next"
1233 field of the last element of the list. */
1234 if (lang_os_list
.head
!= NULL
)
1235 ret
->s
.output_section_statement
.prev
1236 = ((lang_output_section_statement_type
*)
1237 ((char *) lang_os_list
.tail
1238 - offsetof (lang_output_section_statement_type
, next
)));
1240 /* GCC's strict aliasing rules prevent us from just casting the
1241 address, so we store the pointer in a variable and cast that
1243 nextp
= &ret
->s
.output_section_statement
.next
;
1244 lang_statement_append (&lang_os_list
, &ret
->s
, nextp
);
1249 output_section_statement_table_init (void)
1251 if (!bfd_hash_table_init_n (&output_section_statement_table
,
1252 output_section_statement_newfunc
,
1253 sizeof (struct out_section_hash_entry
),
1255 einfo (_("%F%P: can not create hash table: %E\n"));
1259 output_section_statement_table_free (void)
1261 bfd_hash_table_free (&output_section_statement_table
);
1264 /* Build enough state so that the parser can build its tree. */
1269 obstack_begin (&stat_obstack
, 1000);
1271 stat_ptr
= &statement_list
;
1273 output_section_statement_table_init ();
1275 lang_list_init (stat_ptr
);
1277 lang_list_init (&input_file_chain
);
1278 lang_list_init (&lang_os_list
);
1279 lang_list_init (&file_chain
);
1280 first_file
= lang_add_input_file (NULL
, lang_input_file_is_marker_enum
,
1282 abs_output_section
=
1283 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
, 0, TRUE
);
1285 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
1287 asneeded_list_head
= NULL
;
1288 asneeded_list_tail
= &asneeded_list_head
;
1294 output_section_statement_table_free ();
1297 /*----------------------------------------------------------------------
1298 A region is an area of memory declared with the
1299 MEMORY { name:org=exp, len=exp ... }
1302 We maintain a list of all the regions here.
1304 If no regions are specified in the script, then the default is used
1305 which is created when looked up to be the entire data space.
1307 If create is true we are creating a region inside a MEMORY block.
1308 In this case it is probably an error to create a region that has
1309 already been created. If we are not inside a MEMORY block it is
1310 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1311 and so we issue a warning.
1313 Each region has at least one name. The first name is either
1314 DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add
1315 alias names to an existing region within a script with
1316 REGION_ALIAS (alias, region_name). Each name corresponds to at most one
1319 static lang_memory_region_type
*lang_memory_region_list
;
1320 static lang_memory_region_type
**lang_memory_region_list_tail
1321 = &lang_memory_region_list
;
1323 lang_memory_region_type
*
1324 lang_memory_region_lookup (const char *const name
, bfd_boolean create
)
1326 lang_memory_region_name
*n
;
1327 lang_memory_region_type
*r
;
1328 lang_memory_region_type
*new_region
;
1330 /* NAME is NULL for LMA memspecs if no region was specified. */
1334 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1335 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1336 if (strcmp (n
->name
, name
) == 0)
1339 einfo (_("%P:%pS: warning: redeclaration of memory region `%s'\n"),
1344 if (!create
&& strcmp (name
, DEFAULT_MEMORY_REGION
))
1345 einfo (_("%P:%pS: warning: memory region `%s' not declared\n"),
1348 new_region
= (lang_memory_region_type
*)
1349 stat_alloc (sizeof (lang_memory_region_type
));
1351 new_region
->name_list
.name
= xstrdup (name
);
1352 new_region
->name_list
.next
= NULL
;
1353 new_region
->next
= NULL
;
1354 new_region
->origin_exp
= NULL
;
1355 new_region
->origin
= 0;
1356 new_region
->length_exp
= NULL
;
1357 new_region
->length
= ~(bfd_size_type
) 0;
1358 new_region
->current
= 0;
1359 new_region
->last_os
= NULL
;
1360 new_region
->flags
= 0;
1361 new_region
->not_flags
= 0;
1362 new_region
->had_full_message
= FALSE
;
1364 *lang_memory_region_list_tail
= new_region
;
1365 lang_memory_region_list_tail
= &new_region
->next
;
1371 lang_memory_region_alias (const char *alias
, const char *region_name
)
1373 lang_memory_region_name
*n
;
1374 lang_memory_region_type
*r
;
1375 lang_memory_region_type
*region
;
1377 /* The default region must be unique. This ensures that it is not necessary
1378 to iterate through the name list if someone wants the check if a region is
1379 the default memory region. */
1380 if (strcmp (region_name
, DEFAULT_MEMORY_REGION
) == 0
1381 || strcmp (alias
, DEFAULT_MEMORY_REGION
) == 0)
1382 einfo (_("%F%P:%pS: error: alias for default memory region\n"), NULL
);
1384 /* Look for the target region and check if the alias is not already
1387 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1388 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1390 if (region
== NULL
&& strcmp (n
->name
, region_name
) == 0)
1392 if (strcmp (n
->name
, alias
) == 0)
1393 einfo (_("%F%P:%pS: error: redefinition of memory region "
1398 /* Check if the target region exists. */
1400 einfo (_("%F%P:%pS: error: memory region `%s' "
1401 "for alias `%s' does not exist\n"),
1402 NULL
, region_name
, alias
);
1404 /* Add alias to region name list. */
1405 n
= (lang_memory_region_name
*) stat_alloc (sizeof (lang_memory_region_name
));
1406 n
->name
= xstrdup (alias
);
1407 n
->next
= region
->name_list
.next
;
1408 region
->name_list
.next
= n
;
1411 static lang_memory_region_type
*
1412 lang_memory_default (asection
*section
)
1414 lang_memory_region_type
*p
;
1416 flagword sec_flags
= section
->flags
;
1418 /* Override SEC_DATA to mean a writable section. */
1419 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
1420 sec_flags
|= SEC_DATA
;
1422 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
1424 if ((p
->flags
& sec_flags
) != 0
1425 && (p
->not_flags
& sec_flags
) == 0)
1430 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
1433 /* Get the output section statement directly from the userdata. */
1435 lang_output_section_statement_type
*
1436 lang_output_section_get (const asection
*output_section
)
1438 return get_userdata (output_section
);
1441 /* Find or create an output_section_statement with the given NAME.
1442 If CONSTRAINT is non-zero match one with that constraint, otherwise
1443 match any non-negative constraint. If CREATE, always make a
1444 new output_section_statement for SPECIAL CONSTRAINT. */
1446 lang_output_section_statement_type
*
1447 lang_output_section_statement_lookup (const char *name
,
1451 struct out_section_hash_entry
*entry
;
1453 entry
= ((struct out_section_hash_entry
*)
1454 bfd_hash_lookup (&output_section_statement_table
, name
,
1459 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1463 if (entry
->s
.output_section_statement
.name
!= NULL
)
1465 /* We have a section of this name, but it might not have the correct
1467 struct out_section_hash_entry
*last_ent
;
1469 name
= entry
->s
.output_section_statement
.name
;
1470 if (create
&& constraint
== SPECIAL
)
1471 /* Not traversing to the end reverses the order of the second
1472 and subsequent SPECIAL sections in the hash table chain,
1473 but that shouldn't matter. */
1478 if (constraint
== entry
->s
.output_section_statement
.constraint
1480 && entry
->s
.output_section_statement
.constraint
>= 0))
1481 return &entry
->s
.output_section_statement
;
1483 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1485 while (entry
!= NULL
1486 && name
== entry
->s
.output_section_statement
.name
);
1492 = ((struct out_section_hash_entry
*)
1493 output_section_statement_newfunc (NULL
,
1494 &output_section_statement_table
,
1498 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1501 entry
->root
= last_ent
->root
;
1502 last_ent
->root
.next
= &entry
->root
;
1505 entry
->s
.output_section_statement
.name
= name
;
1506 entry
->s
.output_section_statement
.constraint
= constraint
;
1507 return &entry
->s
.output_section_statement
;
1510 /* Find the next output_section_statement with the same name as OS.
1511 If CONSTRAINT is non-zero, find one with that constraint otherwise
1512 match any non-negative constraint. */
1514 lang_output_section_statement_type
*
1515 next_matching_output_section_statement (lang_output_section_statement_type
*os
,
1518 /* All output_section_statements are actually part of a
1519 struct out_section_hash_entry. */
1520 struct out_section_hash_entry
*entry
= (struct out_section_hash_entry
*)
1522 - offsetof (struct out_section_hash_entry
, s
.output_section_statement
));
1523 const char *name
= os
->name
;
1525 ASSERT (name
== entry
->root
.string
);
1528 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1530 || name
!= entry
->s
.output_section_statement
.name
)
1533 while (constraint
!= entry
->s
.output_section_statement
.constraint
1535 || entry
->s
.output_section_statement
.constraint
< 0));
1537 return &entry
->s
.output_section_statement
;
1540 /* A variant of lang_output_section_find used by place_orphan.
1541 Returns the output statement that should precede a new output
1542 statement for SEC. If an exact match is found on certain flags,
1545 lang_output_section_statement_type
*
1546 lang_output_section_find_by_flags (const asection
*sec
,
1548 lang_output_section_statement_type
**exact
,
1549 lang_match_sec_type_func match_type
)
1551 lang_output_section_statement_type
*first
, *look
, *found
;
1552 flagword look_flags
, differ
;
1554 /* We know the first statement on this list is *ABS*. May as well
1556 first
= &lang_os_list
.head
->output_section_statement
;
1557 first
= first
->next
;
1559 /* First try for an exact match. */
1561 for (look
= first
; look
; look
= look
->next
)
1563 look_flags
= look
->flags
;
1564 if (look
->bfd_section
!= NULL
)
1566 look_flags
= look
->bfd_section
->flags
;
1567 if (match_type
&& !match_type (link_info
.output_bfd
,
1572 differ
= look_flags
^ sec_flags
;
1573 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1574 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1584 if ((sec_flags
& SEC_CODE
) != 0
1585 && (sec_flags
& SEC_ALLOC
) != 0)
1587 /* Try for a rw code section. */
1588 for (look
= first
; look
; look
= look
->next
)
1590 look_flags
= look
->flags
;
1591 if (look
->bfd_section
!= NULL
)
1593 look_flags
= look
->bfd_section
->flags
;
1594 if (match_type
&& !match_type (link_info
.output_bfd
,
1599 differ
= look_flags
^ sec_flags
;
1600 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1601 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1605 else if ((sec_flags
& SEC_READONLY
) != 0
1606 && (sec_flags
& SEC_ALLOC
) != 0)
1608 /* .rodata can go after .text, .sdata2 after .rodata. */
1609 for (look
= first
; look
; look
= look
->next
)
1611 look_flags
= look
->flags
;
1612 if (look
->bfd_section
!= NULL
)
1614 look_flags
= look
->bfd_section
->flags
;
1615 if (match_type
&& !match_type (link_info
.output_bfd
,
1620 differ
= look_flags
^ sec_flags
;
1621 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1622 | SEC_READONLY
| SEC_SMALL_DATA
))
1623 || (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1625 && !(look_flags
& SEC_SMALL_DATA
)))
1629 else if ((sec_flags
& SEC_THREAD_LOCAL
) != 0
1630 && (sec_flags
& SEC_ALLOC
) != 0)
1632 /* .tdata can go after .data, .tbss after .tdata. Treat .tbss
1633 as if it were a loaded section, and don't use match_type. */
1634 bfd_boolean seen_thread_local
= FALSE
;
1637 for (look
= first
; look
; look
= look
->next
)
1639 look_flags
= look
->flags
;
1640 if (look
->bfd_section
!= NULL
)
1641 look_flags
= look
->bfd_section
->flags
;
1643 differ
= look_flags
^ (sec_flags
| SEC_LOAD
| SEC_HAS_CONTENTS
);
1644 if (!(differ
& (SEC_THREAD_LOCAL
| SEC_ALLOC
)))
1646 /* .tdata and .tbss must be adjacent and in that order. */
1647 if (!(look_flags
& SEC_LOAD
)
1648 && (sec_flags
& SEC_LOAD
))
1649 /* ..so if we're at a .tbss section and we're placing
1650 a .tdata section stop looking and return the
1651 previous section. */
1654 seen_thread_local
= TRUE
;
1656 else if (seen_thread_local
)
1658 else if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
)))
1662 else if ((sec_flags
& SEC_SMALL_DATA
) != 0
1663 && (sec_flags
& SEC_ALLOC
) != 0)
1665 /* .sdata goes after .data, .sbss after .sdata. */
1666 for (look
= first
; look
; look
= look
->next
)
1668 look_flags
= look
->flags
;
1669 if (look
->bfd_section
!= NULL
)
1671 look_flags
= look
->bfd_section
->flags
;
1672 if (match_type
&& !match_type (link_info
.output_bfd
,
1677 differ
= look_flags
^ sec_flags
;
1678 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1679 | SEC_THREAD_LOCAL
))
1680 || ((look_flags
& SEC_SMALL_DATA
)
1681 && !(sec_flags
& SEC_HAS_CONTENTS
)))
1685 else if ((sec_flags
& SEC_HAS_CONTENTS
) != 0
1686 && (sec_flags
& SEC_ALLOC
) != 0)
1688 /* .data goes after .rodata. */
1689 for (look
= first
; look
; look
= look
->next
)
1691 look_flags
= look
->flags
;
1692 if (look
->bfd_section
!= NULL
)
1694 look_flags
= look
->bfd_section
->flags
;
1695 if (match_type
&& !match_type (link_info
.output_bfd
,
1700 differ
= look_flags
^ sec_flags
;
1701 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1702 | SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1706 else if ((sec_flags
& SEC_ALLOC
) != 0)
1708 /* .bss goes after any other alloc section. */
1709 for (look
= first
; look
; look
= look
->next
)
1711 look_flags
= look
->flags
;
1712 if (look
->bfd_section
!= NULL
)
1714 look_flags
= look
->bfd_section
->flags
;
1715 if (match_type
&& !match_type (link_info
.output_bfd
,
1720 differ
= look_flags
^ sec_flags
;
1721 if (!(differ
& SEC_ALLOC
))
1727 /* non-alloc go last. */
1728 for (look
= first
; look
; look
= look
->next
)
1730 look_flags
= look
->flags
;
1731 if (look
->bfd_section
!= NULL
)
1732 look_flags
= look
->bfd_section
->flags
;
1733 differ
= look_flags
^ sec_flags
;
1734 if (!(differ
& SEC_DEBUGGING
))
1740 if (found
|| !match_type
)
1743 return lang_output_section_find_by_flags (sec
, sec_flags
, NULL
, NULL
);
1746 /* Find the last output section before given output statement.
1747 Used by place_orphan. */
1750 output_prev_sec_find (lang_output_section_statement_type
*os
)
1752 lang_output_section_statement_type
*lookup
;
1754 for (lookup
= os
->prev
; lookup
!= NULL
; lookup
= lookup
->prev
)
1756 if (lookup
->constraint
< 0)
1759 if (lookup
->bfd_section
!= NULL
&& lookup
->bfd_section
->owner
!= NULL
)
1760 return lookup
->bfd_section
;
1766 /* Look for a suitable place for a new output section statement. The
1767 idea is to skip over anything that might be inside a SECTIONS {}
1768 statement in a script, before we find another output section
1769 statement. Assignments to "dot" before an output section statement
1770 are assumed to belong to it, except in two cases; The first
1771 assignment to dot, and assignments before non-alloc sections.
1772 Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
1773 similar assignments that set the initial address, or we might
1774 insert non-alloc note sections among assignments setting end of
1777 static lang_statement_union_type
**
1778 insert_os_after (lang_output_section_statement_type
*after
)
1780 lang_statement_union_type
**where
;
1781 lang_statement_union_type
**assign
= NULL
;
1782 bfd_boolean ignore_first
;
1784 ignore_first
= after
== &lang_os_list
.head
->output_section_statement
;
1786 for (where
= &after
->header
.next
;
1788 where
= &(*where
)->header
.next
)
1790 switch ((*where
)->header
.type
)
1792 case lang_assignment_statement_enum
:
1795 lang_assignment_statement_type
*ass
;
1797 ass
= &(*where
)->assignment_statement
;
1798 if (ass
->exp
->type
.node_class
!= etree_assert
1799 && ass
->exp
->assign
.dst
[0] == '.'
1800 && ass
->exp
->assign
.dst
[1] == 0)
1804 ignore_first
= FALSE
;
1808 case lang_wild_statement_enum
:
1809 case lang_input_section_enum
:
1810 case lang_object_symbols_statement_enum
:
1811 case lang_fill_statement_enum
:
1812 case lang_data_statement_enum
:
1813 case lang_reloc_statement_enum
:
1814 case lang_padding_statement_enum
:
1815 case lang_constructors_statement_enum
:
1817 ignore_first
= FALSE
;
1819 case lang_output_section_statement_enum
:
1822 asection
*s
= (*where
)->output_section_statement
.bfd_section
;
1825 || s
->map_head
.s
== NULL
1826 || (s
->flags
& SEC_ALLOC
) != 0)
1830 case lang_input_statement_enum
:
1831 case lang_address_statement_enum
:
1832 case lang_target_statement_enum
:
1833 case lang_output_statement_enum
:
1834 case lang_group_statement_enum
:
1835 case lang_insert_statement_enum
:
1844 lang_output_section_statement_type
*
1845 lang_insert_orphan (asection
*s
,
1846 const char *secname
,
1848 lang_output_section_statement_type
*after
,
1849 struct orphan_save
*place
,
1850 etree_type
*address
,
1851 lang_statement_list_type
*add_child
)
1853 lang_statement_list_type add
;
1854 lang_output_section_statement_type
*os
;
1855 lang_output_section_statement_type
**os_tail
;
1857 /* If we have found an appropriate place for the output section
1858 statements for this orphan, add them to our own private list,
1859 inserting them later into the global statement list. */
1862 lang_list_init (&add
);
1863 push_stat_ptr (&add
);
1866 if (bfd_link_relocatable (&link_info
)
1867 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
1868 address
= exp_intop (0);
1870 os_tail
= (lang_output_section_statement_type
**) lang_os_list
.tail
;
1871 os
= lang_enter_output_section_statement (secname
, address
, normal_section
,
1872 NULL
, NULL
, NULL
, constraint
, 0);
1874 if (add_child
== NULL
)
1875 add_child
= &os
->children
;
1876 lang_add_section (add_child
, s
, NULL
, os
);
1878 if (after
&& (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) != 0)
1880 const char *region
= (after
->region
1881 ? after
->region
->name_list
.name
1882 : DEFAULT_MEMORY_REGION
);
1883 const char *lma_region
= (after
->lma_region
1884 ? after
->lma_region
->name_list
.name
1886 lang_leave_output_section_statement (NULL
, region
, after
->phdrs
,
1890 lang_leave_output_section_statement (NULL
, DEFAULT_MEMORY_REGION
, NULL
,
1893 /* Restore the global list pointer. */
1897 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
1899 asection
*snew
, *as
;
1900 bfd_boolean place_after
= place
->stmt
== NULL
;
1901 bfd_boolean insert_after
= TRUE
;
1903 snew
= os
->bfd_section
;
1905 /* Shuffle the bfd section list to make the output file look
1906 neater. This is really only cosmetic. */
1907 if (place
->section
== NULL
1908 && after
!= &lang_os_list
.head
->output_section_statement
)
1910 asection
*bfd_section
= after
->bfd_section
;
1912 /* If the output statement hasn't been used to place any input
1913 sections (and thus doesn't have an output bfd_section),
1914 look for the closest prior output statement having an
1916 if (bfd_section
== NULL
)
1917 bfd_section
= output_prev_sec_find (after
);
1919 if (bfd_section
!= NULL
&& bfd_section
!= snew
)
1920 place
->section
= &bfd_section
->next
;
1923 if (place
->section
== NULL
)
1924 place
->section
= &link_info
.output_bfd
->sections
;
1926 as
= *place
->section
;
1930 /* Put the section at the end of the list. */
1932 /* Unlink the section. */
1933 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1935 /* Now tack it back on in the right place. */
1936 bfd_section_list_append (link_info
.output_bfd
, snew
);
1938 else if ((bfd_get_flavour (link_info
.output_bfd
)
1939 == bfd_target_elf_flavour
)
1940 && (bfd_get_flavour (s
->owner
)
1941 == bfd_target_elf_flavour
)
1942 && ((elf_section_type (s
) == SHT_NOTE
1943 && (s
->flags
& SEC_LOAD
) != 0)
1944 || (elf_section_type (as
) == SHT_NOTE
1945 && (as
->flags
& SEC_LOAD
) != 0)))
1947 /* Make sure that output note sections are grouped and sorted
1948 by alignments when inserting a note section or insert a
1949 section after a note section, */
1951 /* A specific section after which the output note section
1952 should be placed. */
1953 asection
*after_sec
;
1954 /* True if we need to insert the orphan section after a
1955 specific section to maintain output note section order. */
1956 bfd_boolean after_sec_note
= FALSE
;
1958 static asection
*first_orphan_note
= NULL
;
1960 /* Group and sort output note section by alignments in
1963 if (elf_section_type (s
) == SHT_NOTE
1964 && (s
->flags
& SEC_LOAD
) != 0)
1966 /* Search from the beginning for the last output note
1967 section with equal or larger alignments. NB: Don't
1968 place orphan note section after non-note sections. */
1970 first_orphan_note
= NULL
;
1971 for (sec
= link_info
.output_bfd
->sections
;
1973 && !bfd_is_abs_section (sec
));
1976 && elf_section_type (sec
) == SHT_NOTE
1977 && (sec
->flags
& SEC_LOAD
) != 0)
1979 if (!first_orphan_note
)
1980 first_orphan_note
= sec
;
1981 if (sec
->alignment_power
>= s
->alignment_power
)
1984 else if (first_orphan_note
)
1986 /* Stop if there is non-note section after the first
1987 orphan note section. */
1991 /* If this will be the first orphan note section, it can
1992 be placed at the default location. */
1993 after_sec_note
= first_orphan_note
!= NULL
;
1994 if (after_sec
== NULL
&& after_sec_note
)
1996 /* If all output note sections have smaller
1997 alignments, place the section before all
1998 output orphan note sections. */
1999 after_sec
= first_orphan_note
;
2000 insert_after
= FALSE
;
2003 else if (first_orphan_note
)
2005 /* Don't place non-note sections in the middle of orphan
2007 after_sec_note
= TRUE
;
2009 for (sec
= as
->next
;
2011 && !bfd_is_abs_section (sec
));
2013 if (elf_section_type (sec
) == SHT_NOTE
2014 && (sec
->flags
& SEC_LOAD
) != 0)
2022 /* Search forward to insert OS after AFTER_SEC output
2024 lang_output_section_statement_type
*stmt
, *next
;
2025 bfd_boolean found
= FALSE
;
2026 for (stmt
= after
; stmt
!= NULL
; stmt
= next
)
2031 if (stmt
->bfd_section
== after_sec
)
2041 /* If INSERT_AFTER is FALSE, place OS before
2042 AFTER_SEC output statement. */
2043 if (next
&& next
->bfd_section
== after_sec
)
2053 /* Search backward to insert OS after AFTER_SEC output
2056 for (stmt
= after
; stmt
!= NULL
; stmt
= stmt
->prev
)
2060 if (stmt
->bfd_section
== after_sec
)
2069 /* If INSERT_AFTER is FALSE, place OS before
2070 AFTER_SEC output statement. */
2071 if (stmt
->next
->bfd_section
== after_sec
)
2081 if (after_sec
== NULL
2082 || (insert_after
&& after_sec
->next
!= snew
)
2083 || (!insert_after
&& after_sec
->prev
!= snew
))
2085 /* Unlink the section. */
2086 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2088 /* Place SNEW after AFTER_SEC. If AFTER_SEC is NULL,
2093 bfd_section_list_insert_after (link_info
.output_bfd
,
2096 bfd_section_list_insert_before (link_info
.output_bfd
,
2100 bfd_section_list_prepend (link_info
.output_bfd
, snew
);
2103 else if (as
!= snew
&& as
->prev
!= snew
)
2105 /* Unlink the section. */
2106 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2108 /* Now tack it back on in the right place. */
2109 bfd_section_list_insert_before (link_info
.output_bfd
,
2113 else if (as
!= snew
&& as
->prev
!= snew
)
2115 /* Unlink the section. */
2116 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2118 /* Now tack it back on in the right place. */
2119 bfd_section_list_insert_before (link_info
.output_bfd
, as
, snew
);
2122 /* Save the end of this list. Further ophans of this type will
2123 follow the one we've just added. */
2124 place
->section
= &snew
->next
;
2126 /* The following is non-cosmetic. We try to put the output
2127 statements in some sort of reasonable order here, because they
2128 determine the final load addresses of the orphan sections.
2129 In addition, placing output statements in the wrong order may
2130 require extra segments. For instance, given a typical
2131 situation of all read-only sections placed in one segment and
2132 following that a segment containing all the read-write
2133 sections, we wouldn't want to place an orphan read/write
2134 section before or amongst the read-only ones. */
2135 if (add
.head
!= NULL
)
2137 lang_output_section_statement_type
*newly_added_os
;
2139 /* Place OS after AFTER if AFTER_NOTE is TRUE. */
2142 lang_statement_union_type
**where
= insert_os_after (after
);
2147 place
->os_tail
= &after
->next
;
2151 /* Put it after the last orphan statement we added. */
2152 *add
.tail
= *place
->stmt
;
2153 *place
->stmt
= add
.head
;
2156 /* Fix the global list pointer if we happened to tack our
2157 new list at the tail. */
2158 if (*stat_ptr
->tail
== add
.head
)
2159 stat_ptr
->tail
= add
.tail
;
2161 /* Save the end of this list. */
2162 place
->stmt
= add
.tail
;
2164 /* Do the same for the list of output section statements. */
2165 newly_added_os
= *os_tail
;
2167 newly_added_os
->prev
= (lang_output_section_statement_type
*)
2168 ((char *) place
->os_tail
2169 - offsetof (lang_output_section_statement_type
, next
));
2170 newly_added_os
->next
= *place
->os_tail
;
2171 if (newly_added_os
->next
!= NULL
)
2172 newly_added_os
->next
->prev
= newly_added_os
;
2173 *place
->os_tail
= newly_added_os
;
2174 place
->os_tail
= &newly_added_os
->next
;
2176 /* Fixing the global list pointer here is a little different.
2177 We added to the list in lang_enter_output_section_statement,
2178 trimmed off the new output_section_statment above when
2179 assigning *os_tail = NULL, but possibly added it back in
2180 the same place when assigning *place->os_tail. */
2181 if (*os_tail
== NULL
)
2182 lang_os_list
.tail
= (lang_statement_union_type
**) os_tail
;
2189 lang_print_asneeded (void)
2191 struct asneeded_minfo
*m
;
2193 if (asneeded_list_head
== NULL
)
2196 minfo (_("\nAs-needed library included to satisfy reference by file (symbol)\n\n"));
2198 for (m
= asneeded_list_head
; m
!= NULL
; m
= m
->next
)
2202 minfo ("%s", m
->soname
);
2203 len
= strlen (m
->soname
);
2217 minfo ("%pB ", m
->ref
);
2218 minfo ("(%pT)\n", m
->name
);
2223 lang_map_flags (flagword flag
)
2225 if (flag
& SEC_ALLOC
)
2228 if (flag
& SEC_CODE
)
2231 if (flag
& SEC_READONLY
)
2234 if (flag
& SEC_DATA
)
2237 if (flag
& SEC_LOAD
)
2244 lang_memory_region_type
*m
;
2245 bfd_boolean dis_header_printed
= FALSE
;
2247 LANG_FOR_EACH_INPUT_STATEMENT (file
)
2251 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
2252 || file
->flags
.just_syms
)
2255 if (config
.print_map_discarded
)
2256 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2257 if ((s
->output_section
== NULL
2258 || s
->output_section
->owner
!= link_info
.output_bfd
)
2259 && (s
->flags
& (SEC_LINKER_CREATED
| SEC_KEEP
)) == 0)
2261 if (! dis_header_printed
)
2263 fprintf (config
.map_file
, _("\nDiscarded input sections\n\n"));
2264 dis_header_printed
= TRUE
;
2267 print_input_section (s
, TRUE
);
2271 minfo (_("\nMemory Configuration\n\n"));
2272 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
2273 _("Name"), _("Origin"), _("Length"), _("Attributes"));
2275 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
2280 fprintf (config
.map_file
, "%-16s ", m
->name_list
.name
);
2282 sprintf_vma (buf
, m
->origin
);
2283 minfo ("0x%s ", buf
);
2291 minfo ("0x%V", m
->length
);
2292 if (m
->flags
|| m
->not_flags
)
2300 lang_map_flags (m
->flags
);
2306 lang_map_flags (m
->not_flags
);
2313 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
2315 if (!link_info
.reduce_memory_overheads
)
2317 obstack_begin (&map_obstack
, 1000);
2318 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
2320 expld
.phase
= lang_fixed_phase_enum
;
2321 lang_statement_iteration
++;
2322 print_statements ();
2324 ldemul_extra_map_file_text (link_info
.output_bfd
, &link_info
,
2329 sort_def_symbol (struct bfd_link_hash_entry
*hash_entry
,
2330 void *info ATTRIBUTE_UNUSED
)
2332 if ((hash_entry
->type
== bfd_link_hash_defined
2333 || hash_entry
->type
== bfd_link_hash_defweak
)
2334 && hash_entry
->u
.def
.section
->owner
!= link_info
.output_bfd
2335 && hash_entry
->u
.def
.section
->owner
!= NULL
)
2337 input_section_userdata_type
*ud
;
2338 struct map_symbol_def
*def
;
2340 ud
= ((input_section_userdata_type
*)
2341 get_userdata (hash_entry
->u
.def
.section
));
2344 ud
= (input_section_userdata_type
*) stat_alloc (sizeof (*ud
));
2345 get_userdata (hash_entry
->u
.def
.section
) = ud
;
2346 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2347 ud
->map_symbol_def_count
= 0;
2349 else if (!ud
->map_symbol_def_tail
)
2350 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2352 def
= (struct map_symbol_def
*) obstack_alloc (&map_obstack
, sizeof *def
);
2353 def
->entry
= hash_entry
;
2354 *(ud
->map_symbol_def_tail
) = def
;
2355 ud
->map_symbol_def_tail
= &def
->next
;
2356 ud
->map_symbol_def_count
++;
2361 /* Initialize an output section. */
2364 init_os (lang_output_section_statement_type
*s
, flagword flags
)
2366 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
2367 einfo (_("%F%P: illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
2369 if (s
->constraint
!= SPECIAL
)
2370 s
->bfd_section
= bfd_get_section_by_name (link_info
.output_bfd
, s
->name
);
2371 if (s
->bfd_section
== NULL
)
2372 s
->bfd_section
= bfd_make_section_anyway_with_flags (link_info
.output_bfd
,
2374 if (s
->bfd_section
== NULL
)
2376 einfo (_("%F%P: output format %s cannot represent section"
2377 " called %s: %E\n"),
2378 link_info
.output_bfd
->xvec
->name
, s
->name
);
2380 s
->bfd_section
->output_section
= s
->bfd_section
;
2381 s
->bfd_section
->output_offset
= 0;
2383 /* Set the userdata of the output section to the output section
2384 statement to avoid lookup. */
2385 get_userdata (s
->bfd_section
) = s
;
2387 /* If there is a base address, make sure that any sections it might
2388 mention are initialized. */
2389 if (s
->addr_tree
!= NULL
)
2390 exp_init_os (s
->addr_tree
);
2392 if (s
->load_base
!= NULL
)
2393 exp_init_os (s
->load_base
);
2395 /* If supplied an alignment, set it. */
2396 if (s
->section_alignment
!= NULL
)
2397 s
->bfd_section
->alignment_power
= exp_get_power (s
->section_alignment
,
2398 "section alignment");
2401 /* Make sure that all output sections mentioned in an expression are
2405 exp_init_os (etree_type
*exp
)
2407 switch (exp
->type
.node_class
)
2411 case etree_provided
:
2412 exp_init_os (exp
->assign
.src
);
2416 exp_init_os (exp
->binary
.lhs
);
2417 exp_init_os (exp
->binary
.rhs
);
2421 exp_init_os (exp
->trinary
.cond
);
2422 exp_init_os (exp
->trinary
.lhs
);
2423 exp_init_os (exp
->trinary
.rhs
);
2427 exp_init_os (exp
->assert_s
.child
);
2431 exp_init_os (exp
->unary
.child
);
2435 switch (exp
->type
.node_code
)
2441 lang_output_section_statement_type
*os
;
2443 os
= lang_output_section_find (exp
->name
.name
);
2444 if (os
!= NULL
&& os
->bfd_section
== NULL
)
2456 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
2458 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
2460 /* If we are only reading symbols from this object, then we want to
2461 discard all sections. */
2462 if (entry
->flags
.just_syms
)
2464 bfd_link_just_syms (abfd
, sec
, &link_info
);
2468 /* Deal with SHF_EXCLUDE ELF sections. */
2469 if (!bfd_link_relocatable (&link_info
)
2470 && (abfd
->flags
& BFD_PLUGIN
) == 0
2471 && (sec
->flags
& (SEC_GROUP
| SEC_KEEP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
2472 sec
->output_section
= bfd_abs_section_ptr
;
2474 if (!(abfd
->flags
& DYNAMIC
))
2475 bfd_section_already_linked (abfd
, sec
, &link_info
);
2479 /* Returns true if SECTION is one we know will be discarded based on its
2480 section flags, otherwise returns false. */
2483 lang_discard_section_p (asection
*section
)
2485 bfd_boolean discard
;
2486 flagword flags
= section
->flags
;
2488 /* Discard sections marked with SEC_EXCLUDE. */
2489 discard
= (flags
& SEC_EXCLUDE
) != 0;
2491 /* Discard the group descriptor sections when we're finally placing the
2492 sections from within the group. */
2493 if ((flags
& SEC_GROUP
) != 0
2494 && link_info
.resolve_section_groups
)
2497 /* Discard debugging sections if we are stripping debugging
2499 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
2500 && (flags
& SEC_DEBUGGING
) != 0)
2506 /* The wild routines.
2508 These expand statements like *(.text) and foo.o to a list of
2509 explicit actions, like foo.o(.text), bar.o(.text) and
2510 foo.o(.text, .data). */
2512 /* Add SECTION to the output section OUTPUT. Do this by creating a
2513 lang_input_section statement which is placed at PTR. */
2516 lang_add_section (lang_statement_list_type
*ptr
,
2518 struct flag_info
*sflag_info
,
2519 lang_output_section_statement_type
*output
)
2521 flagword flags
= section
->flags
;
2523 bfd_boolean discard
;
2524 lang_input_section_type
*new_section
;
2525 bfd
*abfd
= link_info
.output_bfd
;
2527 /* Is this section one we know should be discarded? */
2528 discard
= lang_discard_section_p (section
);
2530 /* Discard input sections which are assigned to a section named
2531 DISCARD_SECTION_NAME. */
2532 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
2537 if (section
->output_section
== NULL
)
2539 /* This prevents future calls from assigning this section. */
2540 section
->output_section
= bfd_abs_section_ptr
;
2549 keep
= bfd_lookup_section_flags (&link_info
, sflag_info
, section
);
2554 if (section
->output_section
!= NULL
)
2557 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2558 to an output section, because we want to be able to include a
2559 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2560 section (I don't know why we want to do this, but we do).
2561 build_link_order in ldwrite.c handles this case by turning
2562 the embedded SEC_NEVER_LOAD section into a fill. */
2563 flags
&= ~ SEC_NEVER_LOAD
;
2565 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2566 already been processed. One reason to do this is that on pe
2567 format targets, .text$foo sections go into .text and it's odd
2568 to see .text with SEC_LINK_ONCE set. */
2569 if ((flags
& (SEC_LINK_ONCE
| SEC_GROUP
)) == (SEC_LINK_ONCE
| SEC_GROUP
))
2571 if (link_info
.resolve_section_groups
)
2572 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2574 flags
&= ~(SEC_LINK_DUPLICATES
| SEC_RELOC
);
2576 else if (!bfd_link_relocatable (&link_info
))
2577 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2579 switch (output
->sectype
)
2581 case normal_section
:
2582 case overlay_section
:
2583 case first_overlay_section
:
2585 case noalloc_section
:
2586 flags
&= ~SEC_ALLOC
;
2588 case noload_section
:
2590 flags
|= SEC_NEVER_LOAD
;
2591 /* Unfortunately GNU ld has managed to evolve two different
2592 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2593 alloc, no contents section. All others get a noload, noalloc
2595 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
2596 flags
&= ~SEC_HAS_CONTENTS
;
2598 flags
&= ~SEC_ALLOC
;
2602 if (output
->bfd_section
== NULL
)
2603 init_os (output
, flags
);
2605 /* If SEC_READONLY is not set in the input section, then clear
2606 it from the output section. */
2607 output
->bfd_section
->flags
&= flags
| ~SEC_READONLY
;
2609 if (output
->bfd_section
->linker_has_input
)
2611 /* Only set SEC_READONLY flag on the first input section. */
2612 flags
&= ~ SEC_READONLY
;
2614 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2615 if ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2616 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2617 || ((flags
& SEC_MERGE
) != 0
2618 && output
->bfd_section
->entsize
!= section
->entsize
))
2620 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2621 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2624 output
->bfd_section
->flags
|= flags
;
2626 if (!output
->bfd_section
->linker_has_input
)
2628 output
->bfd_section
->linker_has_input
= 1;
2629 /* This must happen after flags have been updated. The output
2630 section may have been created before we saw its first input
2631 section, eg. for a data statement. */
2632 bfd_init_private_section_data (section
->owner
, section
,
2633 link_info
.output_bfd
,
2634 output
->bfd_section
,
2636 if ((flags
& SEC_MERGE
) != 0)
2637 output
->bfd_section
->entsize
= section
->entsize
;
2640 if ((flags
& SEC_TIC54X_BLOCK
) != 0
2641 && bfd_get_arch (section
->owner
) == bfd_arch_tic54x
)
2643 /* FIXME: This value should really be obtained from the bfd... */
2644 output
->block_value
= 128;
2647 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2648 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2650 section
->output_section
= output
->bfd_section
;
2652 if (!map_head_is_link_order
)
2654 asection
*s
= output
->bfd_section
->map_tail
.s
;
2655 output
->bfd_section
->map_tail
.s
= section
;
2656 section
->map_head
.s
= NULL
;
2657 section
->map_tail
.s
= s
;
2659 s
->map_head
.s
= section
;
2661 output
->bfd_section
->map_head
.s
= section
;
2664 /* Add a section reference to the list. */
2665 new_section
= new_stat (lang_input_section
, ptr
);
2666 new_section
->section
= section
;
2669 /* Handle wildcard sorting. This returns the lang_input_section which
2670 should follow the one we are going to create for SECTION and FILE,
2671 based on the sorting requirements of WILD. It returns NULL if the
2672 new section should just go at the end of the current list. */
2674 static lang_statement_union_type
*
2675 wild_sort (lang_wild_statement_type
*wild
,
2676 struct wildcard_list
*sec
,
2677 lang_input_statement_type
*file
,
2680 lang_statement_union_type
*l
;
2682 if (!wild
->filenames_sorted
2683 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
2686 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
2688 lang_input_section_type
*ls
;
2690 if (l
->header
.type
!= lang_input_section_enum
)
2692 ls
= &l
->input_section
;
2694 /* Sorting by filename takes precedence over sorting by section
2697 if (wild
->filenames_sorted
)
2699 const char *fn
, *ln
;
2703 /* The PE support for the .idata section as generated by
2704 dlltool assumes that files will be sorted by the name of
2705 the archive and then the name of the file within the
2708 if (file
->the_bfd
!= NULL
2709 && file
->the_bfd
->my_archive
!= NULL
)
2711 fn
= bfd_get_filename (file
->the_bfd
->my_archive
);
2716 fn
= file
->filename
;
2720 if (ls
->section
->owner
->my_archive
!= NULL
)
2722 ln
= bfd_get_filename (ls
->section
->owner
->my_archive
);
2727 ln
= ls
->section
->owner
->filename
;
2731 i
= filename_cmp (fn
, ln
);
2740 fn
= file
->filename
;
2742 ln
= ls
->section
->owner
->filename
;
2744 i
= filename_cmp (fn
, ln
);
2752 /* Here either the files are not sorted by name, or we are
2753 looking at the sections for this file. */
2756 && sec
->spec
.sorted
!= none
2757 && sec
->spec
.sorted
!= by_none
)
2758 if (compare_section (sec
->spec
.sorted
, section
, ls
->section
) < 0)
2765 /* Expand a wild statement for a particular FILE. SECTION may be
2766 NULL, in which case it is a wild card. */
2769 output_section_callback (lang_wild_statement_type
*ptr
,
2770 struct wildcard_list
*sec
,
2772 struct flag_info
*sflag_info
,
2773 lang_input_statement_type
*file
,
2776 lang_statement_union_type
*before
;
2777 lang_output_section_statement_type
*os
;
2779 os
= (lang_output_section_statement_type
*) output
;
2781 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2782 if (unique_section_p (section
, os
))
2785 before
= wild_sort (ptr
, sec
, file
, section
);
2787 /* Here BEFORE points to the lang_input_section which
2788 should follow the one we are about to add. If BEFORE
2789 is NULL, then the section should just go at the end
2790 of the current list. */
2793 lang_add_section (&ptr
->children
, section
, sflag_info
, os
);
2796 lang_statement_list_type list
;
2797 lang_statement_union_type
**pp
;
2799 lang_list_init (&list
);
2800 lang_add_section (&list
, section
, sflag_info
, os
);
2802 /* If we are discarding the section, LIST.HEAD will
2804 if (list
.head
!= NULL
)
2806 ASSERT (list
.head
->header
.next
== NULL
);
2808 for (pp
= &ptr
->children
.head
;
2810 pp
= &(*pp
)->header
.next
)
2811 ASSERT (*pp
!= NULL
);
2813 list
.head
->header
.next
= *pp
;
2819 /* Check if all sections in a wild statement for a particular FILE
2823 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2824 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2826 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
2827 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2830 lang_output_section_statement_type
*os
;
2832 os
= (lang_output_section_statement_type
*) output
;
2834 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2835 if (unique_section_p (section
, os
))
2838 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2839 os
->all_input_readonly
= FALSE
;
2842 /* This is passed a file name which must have been seen already and
2843 added to the statement tree. We will see if it has been opened
2844 already and had its symbols read. If not then we'll read it. */
2846 static lang_input_statement_type
*
2847 lookup_name (const char *name
)
2849 lang_input_statement_type
*search
;
2851 for (search
= &input_file_chain
.head
->input_statement
;
2853 search
= search
->next_real_file
)
2855 /* Use the local_sym_name as the name of the file that has
2856 already been loaded as filename might have been transformed
2857 via the search directory lookup mechanism. */
2858 const char *filename
= search
->local_sym_name
;
2860 if (filename
!= NULL
2861 && filename_cmp (filename
, name
) == 0)
2866 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2867 default_target
, FALSE
);
2869 /* If we have already added this file, or this file is not real
2870 don't add this file. */
2871 if (search
->flags
.loaded
|| !search
->flags
.real
)
2874 if (!load_symbols (search
, NULL
))
2880 /* Save LIST as a list of libraries whose symbols should not be exported. */
2885 struct excluded_lib
*next
;
2887 static struct excluded_lib
*excluded_libs
;
2890 add_excluded_libs (const char *list
)
2892 const char *p
= list
, *end
;
2896 struct excluded_lib
*entry
;
2897 end
= strpbrk (p
, ",:");
2899 end
= p
+ strlen (p
);
2900 entry
= (struct excluded_lib
*) xmalloc (sizeof (*entry
));
2901 entry
->next
= excluded_libs
;
2902 entry
->name
= (char *) xmalloc (end
- p
+ 1);
2903 memcpy (entry
->name
, p
, end
- p
);
2904 entry
->name
[end
- p
] = '\0';
2905 excluded_libs
= entry
;
2913 check_excluded_libs (bfd
*abfd
)
2915 struct excluded_lib
*lib
= excluded_libs
;
2919 int len
= strlen (lib
->name
);
2920 const char *filename
= lbasename (abfd
->filename
);
2922 if (strcmp (lib
->name
, "ALL") == 0)
2924 abfd
->no_export
= TRUE
;
2928 if (filename_ncmp (lib
->name
, filename
, len
) == 0
2929 && (filename
[len
] == '\0'
2930 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
2931 && filename
[len
+ 2] == '\0')))
2933 abfd
->no_export
= TRUE
;
2941 /* Get the symbols for an input file. */
2944 load_symbols (lang_input_statement_type
*entry
,
2945 lang_statement_list_type
*place
)
2949 if (entry
->flags
.loaded
)
2952 ldfile_open_file (entry
);
2954 /* Do not process further if the file was missing. */
2955 if (entry
->flags
.missing_file
)
2958 if (trace_files
|| verbose
)
2959 info_msg ("%pI\n", entry
);
2961 if (!bfd_check_format (entry
->the_bfd
, bfd_archive
)
2962 && !bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
2965 struct lang_input_statement_flags save_flags
;
2968 err
= bfd_get_error ();
2970 /* See if the emulation has some special knowledge. */
2971 if (ldemul_unrecognized_file (entry
))
2974 if (err
== bfd_error_file_ambiguously_recognized
)
2978 einfo (_("%P: %pB: file not recognized: %E;"
2979 " matching formats:"), entry
->the_bfd
);
2980 for (p
= matching
; *p
!= NULL
; p
++)
2984 else if (err
!= bfd_error_file_not_recognized
2986 einfo (_("%F%P: %pB: file not recognized: %E\n"), entry
->the_bfd
);
2988 bfd_close (entry
->the_bfd
);
2989 entry
->the_bfd
= NULL
;
2991 /* Try to interpret the file as a linker script. */
2992 save_flags
= input_flags
;
2993 ldfile_open_command_file (entry
->filename
);
2995 push_stat_ptr (place
);
2996 input_flags
.add_DT_NEEDED_for_regular
2997 = entry
->flags
.add_DT_NEEDED_for_regular
;
2998 input_flags
.add_DT_NEEDED_for_dynamic
2999 = entry
->flags
.add_DT_NEEDED_for_dynamic
;
3000 input_flags
.whole_archive
= entry
->flags
.whole_archive
;
3001 input_flags
.dynamic
= entry
->flags
.dynamic
;
3003 ldfile_assumed_script
= TRUE
;
3004 parser_input
= input_script
;
3006 ldfile_assumed_script
= FALSE
;
3008 /* missing_file is sticky. sysrooted will already have been
3009 restored when seeing EOF in yyparse, but no harm to restore
3011 save_flags
.missing_file
|= input_flags
.missing_file
;
3012 input_flags
= save_flags
;
3016 entry
->flags
.loaded
= TRUE
;
3021 if (ldemul_recognized_file (entry
))
3024 /* We don't call ldlang_add_file for an archive. Instead, the
3025 add_symbols entry point will call ldlang_add_file, via the
3026 add_archive_element callback, for each element of the archive
3028 switch (bfd_get_format (entry
->the_bfd
))
3034 if (!entry
->flags
.reload
)
3035 ldlang_add_file (entry
);
3039 check_excluded_libs (entry
->the_bfd
);
3041 entry
->the_bfd
->usrdata
= entry
;
3042 if (entry
->flags
.whole_archive
)
3045 bfd_boolean loaded
= TRUE
;
3050 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
3055 if (!bfd_check_format (member
, bfd_object
))
3057 einfo (_("%F%P: %pB: member %pB in archive is not an object\n"),
3058 entry
->the_bfd
, member
);
3063 if (!(*link_info
.callbacks
3064 ->add_archive_element
) (&link_info
, member
,
3065 "--whole-archive", &subsbfd
))
3068 /* Potentially, the add_archive_element hook may have set a
3069 substitute BFD for us. */
3070 if (!bfd_link_add_symbols (subsbfd
, &link_info
))
3072 einfo (_("%F%P: %pB: error adding symbols: %E\n"), member
);
3077 entry
->flags
.loaded
= loaded
;
3083 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
3084 entry
->flags
.loaded
= TRUE
;
3086 einfo (_("%F%P: %pB: error adding symbols: %E\n"), entry
->the_bfd
);
3088 return entry
->flags
.loaded
;
3091 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
3092 may be NULL, indicating that it is a wildcard. Separate
3093 lang_input_section statements are created for each part of the
3094 expansion; they are added after the wild statement S. OUTPUT is
3095 the output section. */
3098 wild (lang_wild_statement_type
*s
,
3099 const char *target ATTRIBUTE_UNUSED
,
3100 lang_output_section_statement_type
*output
)
3102 struct wildcard_list
*sec
;
3104 if (s
->handler_data
[0]
3105 && s
->handler_data
[0]->spec
.sorted
== by_name
3106 && !s
->filenames_sorted
)
3108 lang_section_bst_type
*tree
;
3110 walk_wild (s
, output_section_callback_fast
, output
);
3115 output_section_callback_tree_to_list (s
, tree
, output
);
3120 walk_wild (s
, output_section_callback
, output
);
3122 if (default_common_section
== NULL
)
3123 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
3124 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
3126 /* Remember the section that common is going to in case we
3127 later get something which doesn't know where to put it. */
3128 default_common_section
= output
;
3133 /* Return TRUE iff target is the sought target. */
3136 get_target (const bfd_target
*target
, void *data
)
3138 const char *sought
= (const char *) data
;
3140 return strcmp (target
->name
, sought
) == 0;
3143 /* Like strcpy() but convert to lower case as well. */
3146 stricpy (char *dest
, char *src
)
3150 while ((c
= *src
++) != 0)
3151 *dest
++ = TOLOWER (c
);
3156 /* Remove the first occurrence of needle (if any) in haystack
3160 strcut (char *haystack
, char *needle
)
3162 haystack
= strstr (haystack
, needle
);
3168 for (src
= haystack
+ strlen (needle
); *src
;)
3169 *haystack
++ = *src
++;
3175 /* Compare two target format name strings.
3176 Return a value indicating how "similar" they are. */
3179 name_compare (char *first
, char *second
)
3185 copy1
= (char *) xmalloc (strlen (first
) + 1);
3186 copy2
= (char *) xmalloc (strlen (second
) + 1);
3188 /* Convert the names to lower case. */
3189 stricpy (copy1
, first
);
3190 stricpy (copy2
, second
);
3192 /* Remove size and endian strings from the name. */
3193 strcut (copy1
, "big");
3194 strcut (copy1
, "little");
3195 strcut (copy2
, "big");
3196 strcut (copy2
, "little");
3198 /* Return a value based on how many characters match,
3199 starting from the beginning. If both strings are
3200 the same then return 10 * their length. */
3201 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
3202 if (copy1
[result
] == 0)
3214 /* Set by closest_target_match() below. */
3215 static const bfd_target
*winner
;
3217 /* Scan all the valid bfd targets looking for one that has the endianness
3218 requirement that was specified on the command line, and is the nearest
3219 match to the original output target. */
3222 closest_target_match (const bfd_target
*target
, void *data
)
3224 const bfd_target
*original
= (const bfd_target
*) data
;
3226 if (command_line
.endian
== ENDIAN_BIG
3227 && target
->byteorder
!= BFD_ENDIAN_BIG
)
3230 if (command_line
.endian
== ENDIAN_LITTLE
3231 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
3234 /* Must be the same flavour. */
3235 if (target
->flavour
!= original
->flavour
)
3238 /* Ignore generic big and little endian elf vectors. */
3239 if (strcmp (target
->name
, "elf32-big") == 0
3240 || strcmp (target
->name
, "elf64-big") == 0
3241 || strcmp (target
->name
, "elf32-little") == 0
3242 || strcmp (target
->name
, "elf64-little") == 0)
3245 /* If we have not found a potential winner yet, then record this one. */
3252 /* Oh dear, we now have two potential candidates for a successful match.
3253 Compare their names and choose the better one. */
3254 if (name_compare (target
->name
, original
->name
)
3255 > name_compare (winner
->name
, original
->name
))
3258 /* Keep on searching until wqe have checked them all. */
3262 /* Return the BFD target format of the first input file. */
3265 get_first_input_target (void)
3267 char *target
= NULL
;
3269 LANG_FOR_EACH_INPUT_STATEMENT (s
)
3271 if (s
->header
.type
== lang_input_statement_enum
3274 ldfile_open_file (s
);
3276 if (s
->the_bfd
!= NULL
3277 && bfd_check_format (s
->the_bfd
, bfd_object
))
3279 target
= bfd_get_target (s
->the_bfd
);
3291 lang_get_output_target (void)
3295 /* Has the user told us which output format to use? */
3296 if (output_target
!= NULL
)
3297 return output_target
;
3299 /* No - has the current target been set to something other than
3301 if (current_target
!= default_target
&& current_target
!= NULL
)
3302 return current_target
;
3304 /* No - can we determine the format of the first input file? */
3305 target
= get_first_input_target ();
3309 /* Failed - use the default output target. */
3310 return default_target
;
3313 /* Open the output file. */
3316 open_output (const char *name
)
3318 output_target
= lang_get_output_target ();
3320 /* Has the user requested a particular endianness on the command
3322 if (command_line
.endian
!= ENDIAN_UNSET
)
3324 /* Get the chosen target. */
3325 const bfd_target
*target
3326 = bfd_iterate_over_targets (get_target
, (void *) output_target
);
3328 /* If the target is not supported, we cannot do anything. */
3331 enum bfd_endian desired_endian
;
3333 if (command_line
.endian
== ENDIAN_BIG
)
3334 desired_endian
= BFD_ENDIAN_BIG
;
3336 desired_endian
= BFD_ENDIAN_LITTLE
;
3338 /* See if the target has the wrong endianness. This should
3339 not happen if the linker script has provided big and
3340 little endian alternatives, but some scrips don't do
3342 if (target
->byteorder
!= desired_endian
)
3344 /* If it does, then see if the target provides
3345 an alternative with the correct endianness. */
3346 if (target
->alternative_target
!= NULL
3347 && (target
->alternative_target
->byteorder
== desired_endian
))
3348 output_target
= target
->alternative_target
->name
;
3351 /* Try to find a target as similar as possible to
3352 the default target, but which has the desired
3353 endian characteristic. */
3354 bfd_iterate_over_targets (closest_target_match
,
3357 /* Oh dear - we could not find any targets that
3358 satisfy our requirements. */
3360 einfo (_("%P: warning: could not find any targets"
3361 " that match endianness requirement\n"));
3363 output_target
= winner
->name
;
3369 link_info
.output_bfd
= bfd_openw (name
, output_target
);
3371 if (link_info
.output_bfd
== NULL
)
3373 if (bfd_get_error () == bfd_error_invalid_target
)
3374 einfo (_("%F%P: target %s not found\n"), output_target
);
3376 einfo (_("%F%P: cannot open output file %s: %E\n"), name
);
3379 delete_output_file_on_failure
= TRUE
;
3381 if (!bfd_set_format (link_info
.output_bfd
, bfd_object
))
3382 einfo (_("%F%P: %s: can not make object file: %E\n"), name
);
3383 if (!bfd_set_arch_mach (link_info
.output_bfd
,
3384 ldfile_output_architecture
,
3385 ldfile_output_machine
))
3386 einfo (_("%F%P: %s: can not set architecture: %E\n"), name
);
3388 link_info
.hash
= bfd_link_hash_table_create (link_info
.output_bfd
);
3389 if (link_info
.hash
== NULL
)
3390 einfo (_("%F%P: can not create hash table: %E\n"));
3392 bfd_set_gp_size (link_info
.output_bfd
, g_switch_value
);
3396 ldlang_open_output (lang_statement_union_type
*statement
)
3398 switch (statement
->header
.type
)
3400 case lang_output_statement_enum
:
3401 ASSERT (link_info
.output_bfd
== NULL
);
3402 open_output (statement
->output_statement
.name
);
3403 ldemul_set_output_arch ();
3404 if (config
.magic_demand_paged
3405 && !bfd_link_relocatable (&link_info
))
3406 link_info
.output_bfd
->flags
|= D_PAGED
;
3408 link_info
.output_bfd
->flags
&= ~D_PAGED
;
3409 if (config
.text_read_only
)
3410 link_info
.output_bfd
->flags
|= WP_TEXT
;
3412 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
3413 if (link_info
.traditional_format
)
3414 link_info
.output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
3416 link_info
.output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
3419 case lang_target_statement_enum
:
3420 current_target
= statement
->target_statement
.target
;
3430 unsigned x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3431 ldfile_output_machine
);
3434 while ((x
& 1) == 0)
3442 /* Open all the input files. */
3446 OPEN_BFD_NORMAL
= 0,
3450 #ifdef ENABLE_PLUGINS
3451 static lang_input_statement_type
*plugin_insert
= NULL
;
3452 static struct bfd_link_hash_entry
*plugin_undefs
= NULL
;
3456 open_input_bfds (lang_statement_union_type
*s
, enum open_bfd_mode mode
)
3458 for (; s
!= NULL
; s
= s
->header
.next
)
3460 switch (s
->header
.type
)
3462 case lang_constructors_statement_enum
:
3463 open_input_bfds (constructor_list
.head
, mode
);
3465 case lang_output_section_statement_enum
:
3466 open_input_bfds (s
->output_section_statement
.children
.head
, mode
);
3468 case lang_wild_statement_enum
:
3469 /* Maybe we should load the file's symbols. */
3470 if ((mode
& OPEN_BFD_RESCAN
) == 0
3471 && s
->wild_statement
.filename
3472 && !wildcardp (s
->wild_statement
.filename
)
3473 && !archive_path (s
->wild_statement
.filename
))
3474 lookup_name (s
->wild_statement
.filename
);
3475 open_input_bfds (s
->wild_statement
.children
.head
, mode
);
3477 case lang_group_statement_enum
:
3479 struct bfd_link_hash_entry
*undefs
;
3480 #ifdef ENABLE_PLUGINS
3481 lang_input_statement_type
*plugin_insert_save
;
3484 /* We must continually search the entries in the group
3485 until no new symbols are added to the list of undefined
3490 #ifdef ENABLE_PLUGINS
3491 plugin_insert_save
= plugin_insert
;
3493 undefs
= link_info
.hash
->undefs_tail
;
3494 open_input_bfds (s
->group_statement
.children
.head
,
3495 mode
| OPEN_BFD_FORCE
);
3497 while (undefs
!= link_info
.hash
->undefs_tail
3498 #ifdef ENABLE_PLUGINS
3499 /* Objects inserted by a plugin, which are loaded
3500 before we hit this loop, may have added new
3502 || (plugin_insert
!= plugin_insert_save
&& plugin_undefs
)
3507 case lang_target_statement_enum
:
3508 current_target
= s
->target_statement
.target
;
3510 case lang_input_statement_enum
:
3511 if (s
->input_statement
.flags
.real
)
3513 lang_statement_union_type
**os_tail
;
3514 lang_statement_list_type add
;
3517 s
->input_statement
.target
= current_target
;
3519 /* If we are being called from within a group, and this
3520 is an archive which has already been searched, then
3521 force it to be researched unless the whole archive
3522 has been loaded already. Do the same for a rescan.
3523 Likewise reload --as-needed shared libs. */
3524 if (mode
!= OPEN_BFD_NORMAL
3525 #ifdef ENABLE_PLUGINS
3526 && ((mode
& OPEN_BFD_RESCAN
) == 0
3527 || plugin_insert
== NULL
)
3529 && s
->input_statement
.flags
.loaded
3530 && (abfd
= s
->input_statement
.the_bfd
) != NULL
3531 && ((bfd_get_format (abfd
) == bfd_archive
3532 && !s
->input_statement
.flags
.whole_archive
)
3533 || (bfd_get_format (abfd
) == bfd_object
3534 && ((abfd
->flags
) & DYNAMIC
) != 0
3535 && s
->input_statement
.flags
.add_DT_NEEDED_for_regular
3536 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3537 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)))
3539 s
->input_statement
.flags
.loaded
= FALSE
;
3540 s
->input_statement
.flags
.reload
= TRUE
;
3543 os_tail
= lang_os_list
.tail
;
3544 lang_list_init (&add
);
3546 if (!load_symbols (&s
->input_statement
, &add
))
3547 config
.make_executable
= FALSE
;
3549 if (add
.head
!= NULL
)
3551 /* If this was a script with output sections then
3552 tack any added statements on to the end of the
3553 list. This avoids having to reorder the output
3554 section statement list. Very likely the user
3555 forgot -T, and whatever we do here will not meet
3556 naive user expectations. */
3557 if (os_tail
!= lang_os_list
.tail
)
3559 einfo (_("%P: warning: %s contains output sections;"
3560 " did you forget -T?\n"),
3561 s
->input_statement
.filename
);
3562 *stat_ptr
->tail
= add
.head
;
3563 stat_ptr
->tail
= add
.tail
;
3567 *add
.tail
= s
->header
.next
;
3568 s
->header
.next
= add
.head
;
3572 #ifdef ENABLE_PLUGINS
3573 /* If we have found the point at which a plugin added new
3574 files, clear plugin_insert to enable archive rescan. */
3575 if (&s
->input_statement
== plugin_insert
)
3576 plugin_insert
= NULL
;
3579 case lang_assignment_statement_enum
:
3580 if (s
->assignment_statement
.exp
->type
.node_class
!= etree_assert
)
3581 exp_fold_tree_no_dot (s
->assignment_statement
.exp
);
3588 /* Exit if any of the files were missing. */
3589 if (input_flags
.missing_file
)
3593 /* Add the supplied name to the symbol table as an undefined reference.
3594 This is a two step process as the symbol table doesn't even exist at
3595 the time the ld command line is processed. First we put the name
3596 on a list, then, once the output file has been opened, transfer the
3597 name to the symbol table. */
3599 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3601 #define ldlang_undef_chain_list_head entry_symbol.next
3604 ldlang_add_undef (const char *const name
, bfd_boolean cmdline
)
3606 ldlang_undef_chain_list_type
*new_undef
;
3608 undef_from_cmdline
= undef_from_cmdline
|| cmdline
;
3609 new_undef
= (ldlang_undef_chain_list_type
*) stat_alloc (sizeof (*new_undef
));
3610 new_undef
->next
= ldlang_undef_chain_list_head
;
3611 ldlang_undef_chain_list_head
= new_undef
;
3613 new_undef
->name
= xstrdup (name
);
3615 if (link_info
.output_bfd
!= NULL
)
3616 insert_undefined (new_undef
->name
);
3619 /* Insert NAME as undefined in the symbol table. */
3622 insert_undefined (const char *name
)
3624 struct bfd_link_hash_entry
*h
;
3626 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
3628 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
3629 if (h
->type
== bfd_link_hash_new
)
3631 h
->type
= bfd_link_hash_undefined
;
3632 h
->u
.undef
.abfd
= NULL
;
3633 h
->non_ir_ref_regular
= TRUE
;
3634 if (is_elf_hash_table (link_info
.hash
))
3635 ((struct elf_link_hash_entry
*) h
)->mark
= 1;
3636 bfd_link_add_undef (link_info
.hash
, h
);
3640 /* Run through the list of undefineds created above and place them
3641 into the linker hash table as undefined symbols belonging to the
3645 lang_place_undefineds (void)
3647 ldlang_undef_chain_list_type
*ptr
;
3649 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3650 insert_undefined (ptr
->name
);
3653 /* Structure used to build the list of symbols that the user has required
3656 struct require_defined_symbol
3659 struct require_defined_symbol
*next
;
3662 /* The list of symbols that the user has required be defined. */
3664 static struct require_defined_symbol
*require_defined_symbol_list
;
3666 /* Add a new symbol NAME to the list of symbols that are required to be
3670 ldlang_add_require_defined (const char *const name
)
3672 struct require_defined_symbol
*ptr
;
3674 ldlang_add_undef (name
, TRUE
);
3675 ptr
= (struct require_defined_symbol
*) stat_alloc (sizeof (*ptr
));
3676 ptr
->next
= require_defined_symbol_list
;
3677 ptr
->name
= strdup (name
);
3678 require_defined_symbol_list
= ptr
;
3681 /* Check that all symbols the user required to be defined, are defined,
3682 raise an error if we find a symbol that is not defined. */
3685 ldlang_check_require_defined_symbols (void)
3687 struct require_defined_symbol
*ptr
;
3689 for (ptr
= require_defined_symbol_list
; ptr
!= NULL
; ptr
= ptr
->next
)
3691 struct bfd_link_hash_entry
*h
;
3693 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
,
3694 FALSE
, FALSE
, TRUE
);
3696 || (h
->type
!= bfd_link_hash_defined
3697 && h
->type
!= bfd_link_hash_defweak
))
3698 einfo(_("%X%P: required symbol `%s' not defined\n"), ptr
->name
);
3702 /* Check for all readonly or some readwrite sections. */
3705 check_input_sections
3706 (lang_statement_union_type
*s
,
3707 lang_output_section_statement_type
*output_section_statement
)
3709 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
3711 switch (s
->header
.type
)
3713 case lang_wild_statement_enum
:
3714 walk_wild (&s
->wild_statement
, check_section_callback
,
3715 output_section_statement
);
3716 if (!output_section_statement
->all_input_readonly
)
3719 case lang_constructors_statement_enum
:
3720 check_input_sections (constructor_list
.head
,
3721 output_section_statement
);
3722 if (!output_section_statement
->all_input_readonly
)
3725 case lang_group_statement_enum
:
3726 check_input_sections (s
->group_statement
.children
.head
,
3727 output_section_statement
);
3728 if (!output_section_statement
->all_input_readonly
)
3737 /* Update wildcard statements if needed. */
3740 update_wild_statements (lang_statement_union_type
*s
)
3742 struct wildcard_list
*sec
;
3744 switch (sort_section
)
3754 for (; s
!= NULL
; s
= s
->header
.next
)
3756 switch (s
->header
.type
)
3761 case lang_wild_statement_enum
:
3762 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
3764 /* Don't sort .init/.fini sections. */
3765 if (strcmp (sec
->spec
.name
, ".init") != 0
3766 && strcmp (sec
->spec
.name
, ".fini") != 0)
3767 switch (sec
->spec
.sorted
)
3770 sec
->spec
.sorted
= sort_section
;
3773 if (sort_section
== by_alignment
)
3774 sec
->spec
.sorted
= by_name_alignment
;
3777 if (sort_section
== by_name
)
3778 sec
->spec
.sorted
= by_alignment_name
;
3785 case lang_constructors_statement_enum
:
3786 update_wild_statements (constructor_list
.head
);
3789 case lang_output_section_statement_enum
:
3790 update_wild_statements
3791 (s
->output_section_statement
.children
.head
);
3794 case lang_group_statement_enum
:
3795 update_wild_statements (s
->group_statement
.children
.head
);
3803 /* Open input files and attach to output sections. */
3806 map_input_to_output_sections
3807 (lang_statement_union_type
*s
, const char *target
,
3808 lang_output_section_statement_type
*os
)
3810 for (; s
!= NULL
; s
= s
->header
.next
)
3812 lang_output_section_statement_type
*tos
;
3815 switch (s
->header
.type
)
3817 case lang_wild_statement_enum
:
3818 wild (&s
->wild_statement
, target
, os
);
3820 case lang_constructors_statement_enum
:
3821 map_input_to_output_sections (constructor_list
.head
,
3825 case lang_output_section_statement_enum
:
3826 tos
= &s
->output_section_statement
;
3827 if (tos
->constraint
!= 0)
3829 if (tos
->constraint
!= ONLY_IF_RW
3830 && tos
->constraint
!= ONLY_IF_RO
)
3832 tos
->all_input_readonly
= TRUE
;
3833 check_input_sections (tos
->children
.head
, tos
);
3834 if (tos
->all_input_readonly
!= (tos
->constraint
== ONLY_IF_RO
))
3836 tos
->constraint
= -1;
3840 map_input_to_output_sections (tos
->children
.head
,
3844 case lang_output_statement_enum
:
3846 case lang_target_statement_enum
:
3847 target
= s
->target_statement
.target
;
3849 case lang_group_statement_enum
:
3850 map_input_to_output_sections (s
->group_statement
.children
.head
,
3854 case lang_data_statement_enum
:
3855 /* Make sure that any sections mentioned in the expression
3857 exp_init_os (s
->data_statement
.exp
);
3858 /* The output section gets CONTENTS, ALLOC and LOAD, but
3859 these may be overridden by the script. */
3860 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
;
3861 switch (os
->sectype
)
3863 case normal_section
:
3864 case overlay_section
:
3865 case first_overlay_section
:
3867 case noalloc_section
:
3868 flags
= SEC_HAS_CONTENTS
;
3870 case noload_section
:
3871 if (bfd_get_flavour (link_info
.output_bfd
)
3872 == bfd_target_elf_flavour
)
3873 flags
= SEC_NEVER_LOAD
| SEC_ALLOC
;
3875 flags
= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
;
3878 if (os
->bfd_section
== NULL
)
3879 init_os (os
, flags
);
3881 os
->bfd_section
->flags
|= flags
;
3883 case lang_input_section_enum
:
3885 case lang_fill_statement_enum
:
3886 case lang_object_symbols_statement_enum
:
3887 case lang_reloc_statement_enum
:
3888 case lang_padding_statement_enum
:
3889 case lang_input_statement_enum
:
3890 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3893 case lang_assignment_statement_enum
:
3894 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3897 /* Make sure that any sections mentioned in the assignment
3899 exp_init_os (s
->assignment_statement
.exp
);
3901 case lang_address_statement_enum
:
3902 /* Mark the specified section with the supplied address.
3903 If this section was actually a segment marker, then the
3904 directive is ignored if the linker script explicitly
3905 processed the segment marker. Originally, the linker
3906 treated segment directives (like -Ttext on the
3907 command-line) as section directives. We honor the
3908 section directive semantics for backwards compatibility;
3909 linker scripts that do not specifically check for
3910 SEGMENT_START automatically get the old semantics. */
3911 if (!s
->address_statement
.segment
3912 || !s
->address_statement
.segment
->used
)
3914 const char *name
= s
->address_statement
.section_name
;
3916 /* Create the output section statement here so that
3917 orphans with a set address will be placed after other
3918 script sections. If we let the orphan placement code
3919 place them in amongst other sections then the address
3920 will affect following script sections, which is
3921 likely to surprise naive users. */
3922 tos
= lang_output_section_statement_lookup (name
, 0, TRUE
);
3923 tos
->addr_tree
= s
->address_statement
.address
;
3924 if (tos
->bfd_section
== NULL
)
3928 case lang_insert_statement_enum
:
3934 /* An insert statement snips out all the linker statements from the
3935 start of the list and places them after the output section
3936 statement specified by the insert. This operation is complicated
3937 by the fact that we keep a doubly linked list of output section
3938 statements as well as the singly linked list of all statements.
3939 FIXME someday: Twiddling with the list not only moves statements
3940 from the user's script but also input and group statements that are
3941 built from command line object files and --start-group. We only
3942 get away with this because the list pointers used by file_chain
3943 and input_file_chain are not reordered, and processing via
3944 statement_list after this point mostly ignores input statements.
3945 One exception is the map file, where LOAD and START GROUP/END GROUP
3946 can end up looking odd. */
3949 process_insert_statements (lang_statement_union_type
**start
)
3951 lang_statement_union_type
**s
;
3952 lang_output_section_statement_type
*first_os
= NULL
;
3953 lang_output_section_statement_type
*last_os
= NULL
;
3954 lang_output_section_statement_type
*os
;
3959 if ((*s
)->header
.type
== lang_output_section_statement_enum
)
3961 /* Keep pointers to the first and last output section
3962 statement in the sequence we may be about to move. */
3963 os
= &(*s
)->output_section_statement
;
3965 ASSERT (last_os
== NULL
|| last_os
->next
== os
);
3968 /* Set constraint negative so that lang_output_section_find
3969 won't match this output section statement. At this
3970 stage in linking constraint has values in the range
3971 [-1, ONLY_IN_RW]. */
3972 last_os
->constraint
= -2 - last_os
->constraint
;
3973 if (first_os
== NULL
)
3976 else if ((*s
)->header
.type
== lang_group_statement_enum
)
3978 /* A user might put -T between --start-group and
3979 --end-group. One way this odd construct might arise is
3980 from a wrapper around ld to change library search
3981 behaviour. For example:
3983 exec real_ld --start-group "$@" --end-group
3984 This isn't completely unreasonable so go looking inside a
3985 group statement for insert statements. */
3986 process_insert_statements (&(*s
)->group_statement
.children
.head
);
3988 else if ((*s
)->header
.type
== lang_insert_statement_enum
)
3990 lang_insert_statement_type
*i
= &(*s
)->insert_statement
;
3991 lang_output_section_statement_type
*where
;
3992 lang_statement_union_type
**ptr
;
3993 lang_statement_union_type
*first
;
3995 where
= lang_output_section_find (i
->where
);
3996 if (where
!= NULL
&& i
->is_before
)
3999 where
= where
->prev
;
4000 while (where
!= NULL
&& where
->constraint
< 0);
4004 einfo (_("%F%P: %s not found for insert\n"), i
->where
);
4008 /* Deal with reordering the output section statement list. */
4009 if (last_os
!= NULL
)
4011 asection
*first_sec
, *last_sec
;
4012 struct lang_output_section_statement_struct
**next
;
4014 /* Snip out the output sections we are moving. */
4015 first_os
->prev
->next
= last_os
->next
;
4016 if (last_os
->next
== NULL
)
4018 next
= &first_os
->prev
->next
;
4019 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4022 last_os
->next
->prev
= first_os
->prev
;
4023 /* Add them in at the new position. */
4024 last_os
->next
= where
->next
;
4025 if (where
->next
== NULL
)
4027 next
= &last_os
->next
;
4028 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4031 where
->next
->prev
= last_os
;
4032 first_os
->prev
= where
;
4033 where
->next
= first_os
;
4035 /* Move the bfd sections in the same way. */
4038 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4040 os
->constraint
= -2 - os
->constraint
;
4041 if (os
->bfd_section
!= NULL
4042 && os
->bfd_section
->owner
!= NULL
)
4044 last_sec
= os
->bfd_section
;
4045 if (first_sec
== NULL
)
4046 first_sec
= last_sec
;
4051 if (last_sec
!= NULL
)
4053 asection
*sec
= where
->bfd_section
;
4055 sec
= output_prev_sec_find (where
);
4057 /* The place we want to insert must come after the
4058 sections we are moving. So if we find no
4059 section or if the section is the same as our
4060 last section, then no move is needed. */
4061 if (sec
!= NULL
&& sec
!= last_sec
)
4063 /* Trim them off. */
4064 if (first_sec
->prev
!= NULL
)
4065 first_sec
->prev
->next
= last_sec
->next
;
4067 link_info
.output_bfd
->sections
= last_sec
->next
;
4068 if (last_sec
->next
!= NULL
)
4069 last_sec
->next
->prev
= first_sec
->prev
;
4071 link_info
.output_bfd
->section_last
= first_sec
->prev
;
4073 last_sec
->next
= sec
->next
;
4074 if (sec
->next
!= NULL
)
4075 sec
->next
->prev
= last_sec
;
4077 link_info
.output_bfd
->section_last
= last_sec
;
4078 first_sec
->prev
= sec
;
4079 sec
->next
= first_sec
;
4087 ptr
= insert_os_after (where
);
4088 /* Snip everything from the start of the list, up to and
4089 including the insert statement we are currently processing. */
4091 *start
= (*s
)->header
.next
;
4092 /* Add them back where they belong, minus the insert. */
4095 statement_list
.tail
= s
;
4100 s
= &(*s
)->header
.next
;
4103 /* Undo constraint twiddling. */
4104 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4106 os
->constraint
= -2 - os
->constraint
;
4112 /* An output section might have been removed after its statement was
4113 added. For example, ldemul_before_allocation can remove dynamic
4114 sections if they turn out to be not needed. Clean them up here. */
4117 strip_excluded_output_sections (void)
4119 lang_output_section_statement_type
*os
;
4121 /* Run lang_size_sections (if not already done). */
4122 if (expld
.phase
!= lang_mark_phase_enum
)
4124 expld
.phase
= lang_mark_phase_enum
;
4125 expld
.dataseg
.phase
= exp_seg_none
;
4126 one_lang_size_sections_pass (NULL
, FALSE
);
4127 lang_reset_memory_regions ();
4130 for (os
= &lang_os_list
.head
->output_section_statement
;
4134 asection
*output_section
;
4135 bfd_boolean exclude
;
4137 if (os
->constraint
< 0)
4140 output_section
= os
->bfd_section
;
4141 if (output_section
== NULL
)
4144 exclude
= (output_section
->rawsize
== 0
4145 && (output_section
->flags
& SEC_KEEP
) == 0
4146 && !bfd_section_removed_from_list (link_info
.output_bfd
,
4149 /* Some sections have not yet been sized, notably .gnu.version,
4150 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
4151 input sections, so don't drop output sections that have such
4152 input sections unless they are also marked SEC_EXCLUDE. */
4153 if (exclude
&& output_section
->map_head
.s
!= NULL
)
4157 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
4158 if ((s
->flags
& SEC_EXCLUDE
) == 0
4159 && ((s
->flags
& SEC_LINKER_CREATED
) != 0
4160 || link_info
.emitrelocations
))
4169 /* We don't set bfd_section to NULL since bfd_section of the
4170 removed output section statement may still be used. */
4171 if (!os
->update_dot
)
4173 output_section
->flags
|= SEC_EXCLUDE
;
4174 bfd_section_list_remove (link_info
.output_bfd
, output_section
);
4175 link_info
.output_bfd
->section_count
--;
4180 /* Called from ldwrite to clear out asection.map_head and
4181 asection.map_tail for use as link_orders in ldwrite. */
4184 lang_clear_os_map (void)
4186 lang_output_section_statement_type
*os
;
4188 if (map_head_is_link_order
)
4191 for (os
= &lang_os_list
.head
->output_section_statement
;
4195 asection
*output_section
;
4197 if (os
->constraint
< 0)
4200 output_section
= os
->bfd_section
;
4201 if (output_section
== NULL
)
4204 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
4205 output_section
->map_head
.link_order
= NULL
;
4206 output_section
->map_tail
.link_order
= NULL
;
4209 /* Stop future calls to lang_add_section from messing with map_head
4210 and map_tail link_order fields. */
4211 map_head_is_link_order
= TRUE
;
4215 print_output_section_statement
4216 (lang_output_section_statement_type
*output_section_statement
)
4218 asection
*section
= output_section_statement
->bfd_section
;
4221 if (output_section_statement
!= abs_output_section
)
4223 minfo ("\n%s", output_section_statement
->name
);
4225 if (section
!= NULL
)
4227 print_dot
= section
->vma
;
4229 len
= strlen (output_section_statement
->name
);
4230 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4235 while (len
< SECTION_NAME_MAP_LENGTH
)
4241 minfo ("0x%V %W", section
->vma
, TO_ADDR (section
->size
));
4243 if (section
->vma
!= section
->lma
)
4244 minfo (_(" load address 0x%V"), section
->lma
);
4246 if (output_section_statement
->update_dot_tree
!= NULL
)
4247 exp_fold_tree (output_section_statement
->update_dot_tree
,
4248 bfd_abs_section_ptr
, &print_dot
);
4254 print_statement_list (output_section_statement
->children
.head
,
4255 output_section_statement
);
4259 print_assignment (lang_assignment_statement_type
*assignment
,
4260 lang_output_section_statement_type
*output_section
)
4267 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4270 if (assignment
->exp
->type
.node_class
== etree_assert
)
4273 tree
= assignment
->exp
->assert_s
.child
;
4277 const char *dst
= assignment
->exp
->assign
.dst
;
4279 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
4280 tree
= assignment
->exp
;
4283 osec
= output_section
->bfd_section
;
4285 osec
= bfd_abs_section_ptr
;
4287 if (assignment
->exp
->type
.node_class
!= etree_provide
)
4288 exp_fold_tree (tree
, osec
, &print_dot
);
4290 expld
.result
.valid_p
= FALSE
;
4292 if (expld
.result
.valid_p
)
4296 if (assignment
->exp
->type
.node_class
== etree_assert
4298 || expld
.assign_name
!= NULL
)
4300 value
= expld
.result
.value
;
4302 if (expld
.result
.section
!= NULL
)
4303 value
+= expld
.result
.section
->vma
;
4305 minfo ("0x%V", value
);
4311 struct bfd_link_hash_entry
*h
;
4313 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
4314 FALSE
, FALSE
, TRUE
);
4316 && (h
->type
== bfd_link_hash_defined
4317 || h
->type
== bfd_link_hash_defweak
))
4319 value
= h
->u
.def
.value
;
4320 value
+= h
->u
.def
.section
->output_section
->vma
;
4321 value
+= h
->u
.def
.section
->output_offset
;
4323 minfo ("[0x%V]", value
);
4326 minfo ("[unresolved]");
4331 if (assignment
->exp
->type
.node_class
== etree_provide
)
4332 minfo ("[!provide]");
4339 expld
.assign_name
= NULL
;
4342 exp_print_tree (assignment
->exp
);
4347 print_input_statement (lang_input_statement_type
*statm
)
4349 if (statm
->filename
!= NULL
4350 && (statm
->the_bfd
== NULL
4351 || (statm
->the_bfd
->flags
& BFD_LINKER_CREATED
) == 0))
4352 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
4355 /* Print all symbols defined in a particular section. This is called
4356 via bfd_link_hash_traverse, or by print_all_symbols. */
4359 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
4361 asection
*sec
= (asection
*) ptr
;
4363 if ((hash_entry
->type
== bfd_link_hash_defined
4364 || hash_entry
->type
== bfd_link_hash_defweak
)
4365 && sec
== hash_entry
->u
.def
.section
)
4369 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4372 (hash_entry
->u
.def
.value
4373 + hash_entry
->u
.def
.section
->output_offset
4374 + hash_entry
->u
.def
.section
->output_section
->vma
));
4376 minfo (" %pT\n", hash_entry
->root
.string
);
4383 hash_entry_addr_cmp (const void *a
, const void *b
)
4385 const struct bfd_link_hash_entry
*l
= *(const struct bfd_link_hash_entry
**)a
;
4386 const struct bfd_link_hash_entry
*r
= *(const struct bfd_link_hash_entry
**)b
;
4388 if (l
->u
.def
.value
< r
->u
.def
.value
)
4390 else if (l
->u
.def
.value
> r
->u
.def
.value
)
4397 print_all_symbols (asection
*sec
)
4399 input_section_userdata_type
*ud
4400 = (input_section_userdata_type
*) get_userdata (sec
);
4401 struct map_symbol_def
*def
;
4402 struct bfd_link_hash_entry
**entries
;
4408 *ud
->map_symbol_def_tail
= 0;
4410 /* Sort the symbols by address. */
4411 entries
= (struct bfd_link_hash_entry
**)
4412 obstack_alloc (&map_obstack
,
4413 ud
->map_symbol_def_count
* sizeof (*entries
));
4415 for (i
= 0, def
= ud
->map_symbol_def_head
; def
; def
= def
->next
, i
++)
4416 entries
[i
] = def
->entry
;
4418 qsort (entries
, ud
->map_symbol_def_count
, sizeof (*entries
),
4419 hash_entry_addr_cmp
);
4421 /* Print the symbols. */
4422 for (i
= 0; i
< ud
->map_symbol_def_count
; i
++)
4423 print_one_symbol (entries
[i
], sec
);
4425 obstack_free (&map_obstack
, entries
);
4428 /* Print information about an input section to the map file. */
4431 print_input_section (asection
*i
, bfd_boolean is_discarded
)
4433 bfd_size_type size
= i
->size
;
4440 minfo ("%s", i
->name
);
4442 len
= 1 + strlen (i
->name
);
4443 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4448 while (len
< SECTION_NAME_MAP_LENGTH
)
4454 if (i
->output_section
!= NULL
4455 && i
->output_section
->owner
== link_info
.output_bfd
)
4456 addr
= i
->output_section
->vma
+ i
->output_offset
;
4464 minfo ("0x%V %W %pB\n", addr
, size
, i
->owner
);
4466 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
4468 len
= SECTION_NAME_MAP_LENGTH
+ 3;
4480 minfo (_("%W (size before relaxing)\n"), i
->rawsize
);
4483 if (i
->output_section
!= NULL
4484 && i
->output_section
->owner
== link_info
.output_bfd
)
4486 if (link_info
.reduce_memory_overheads
)
4487 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, i
);
4489 print_all_symbols (i
);
4491 /* Update print_dot, but make sure that we do not move it
4492 backwards - this could happen if we have overlays and a
4493 later overlay is shorter than an earier one. */
4494 if (addr
+ TO_ADDR (size
) > print_dot
)
4495 print_dot
= addr
+ TO_ADDR (size
);
4500 print_fill_statement (lang_fill_statement_type
*fill
)
4504 fputs (" FILL mask 0x", config
.map_file
);
4505 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
4506 fprintf (config
.map_file
, "%02x", *p
);
4507 fputs ("\n", config
.map_file
);
4511 print_data_statement (lang_data_statement_type
*data
)
4519 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4522 addr
= data
->output_offset
;
4523 if (data
->output_section
!= NULL
)
4524 addr
+= data
->output_section
->vma
;
4552 if (size
< TO_SIZE ((unsigned) 1))
4553 size
= TO_SIZE ((unsigned) 1);
4554 minfo ("0x%V %W %s 0x%v", addr
, TO_ADDR (size
), name
, data
->value
);
4556 if (data
->exp
->type
.node_class
!= etree_value
)
4559 exp_print_tree (data
->exp
);
4564 print_dot
= addr
+ TO_ADDR (size
);
4567 /* Print an address statement. These are generated by options like
4571 print_address_statement (lang_address_statement_type
*address
)
4573 minfo (_("Address of section %s set to "), address
->section_name
);
4574 exp_print_tree (address
->address
);
4578 /* Print a reloc statement. */
4581 print_reloc_statement (lang_reloc_statement_type
*reloc
)
4588 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4591 addr
= reloc
->output_offset
;
4592 if (reloc
->output_section
!= NULL
)
4593 addr
+= reloc
->output_section
->vma
;
4595 size
= bfd_get_reloc_size (reloc
->howto
);
4597 minfo ("0x%V %W RELOC %s ", addr
, TO_ADDR (size
), reloc
->howto
->name
);
4599 if (reloc
->name
!= NULL
)
4600 minfo ("%s+", reloc
->name
);
4602 minfo ("%s+", reloc
->section
->name
);
4604 exp_print_tree (reloc
->addend_exp
);
4608 print_dot
= addr
+ TO_ADDR (size
);
4612 print_padding_statement (lang_padding_statement_type
*s
)
4620 len
= sizeof " *fill*" - 1;
4621 while (len
< SECTION_NAME_MAP_LENGTH
)
4627 addr
= s
->output_offset
;
4628 if (s
->output_section
!= NULL
)
4629 addr
+= s
->output_section
->vma
;
4630 minfo ("0x%V %W ", addr
, TO_ADDR (s
->size
));
4632 if (s
->fill
->size
!= 0)
4636 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
4637 fprintf (config
.map_file
, "%02x", *p
);
4642 print_dot
= addr
+ TO_ADDR (s
->size
);
4646 print_wild_statement (lang_wild_statement_type
*w
,
4647 lang_output_section_statement_type
*os
)
4649 struct wildcard_list
*sec
;
4653 if (w
->exclude_name_list
)
4656 minfo ("EXCLUDE_FILE(%s", w
->exclude_name_list
->name
);
4657 for (tmp
= w
->exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4658 minfo (" %s", tmp
->name
);
4662 if (w
->filenames_sorted
)
4663 minfo ("SORT_BY_NAME(");
4664 if (w
->filename
!= NULL
)
4665 minfo ("%s", w
->filename
);
4668 if (w
->filenames_sorted
)
4672 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
4674 int closing_paren
= 0;
4676 switch (sec
->spec
.sorted
)
4682 minfo ("SORT_BY_NAME(");
4687 minfo ("SORT_BY_ALIGNMENT(");
4691 case by_name_alignment
:
4692 minfo ("SORT_BY_NAME(SORT_BY_ALIGNMENT(");
4696 case by_alignment_name
:
4697 minfo ("SORT_BY_ALIGNMENT(SORT_BY_NAME(");
4702 minfo ("SORT_NONE(");
4706 case by_init_priority
:
4707 minfo ("SORT_BY_INIT_PRIORITY(");
4712 if (sec
->spec
.exclude_name_list
!= NULL
)
4715 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
4716 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4717 minfo (" %s", tmp
->name
);
4720 if (sec
->spec
.name
!= NULL
)
4721 minfo ("%s", sec
->spec
.name
);
4724 for (;closing_paren
> 0; closing_paren
--)
4733 print_statement_list (w
->children
.head
, os
);
4736 /* Print a group statement. */
4739 print_group (lang_group_statement_type
*s
,
4740 lang_output_section_statement_type
*os
)
4742 fprintf (config
.map_file
, "START GROUP\n");
4743 print_statement_list (s
->children
.head
, os
);
4744 fprintf (config
.map_file
, "END GROUP\n");
4747 /* Print the list of statements in S.
4748 This can be called for any statement type. */
4751 print_statement_list (lang_statement_union_type
*s
,
4752 lang_output_section_statement_type
*os
)
4756 print_statement (s
, os
);
4761 /* Print the first statement in statement list S.
4762 This can be called for any statement type. */
4765 print_statement (lang_statement_union_type
*s
,
4766 lang_output_section_statement_type
*os
)
4768 switch (s
->header
.type
)
4771 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
4774 case lang_constructors_statement_enum
:
4775 if (constructor_list
.head
!= NULL
)
4777 if (constructors_sorted
)
4778 minfo (" SORT (CONSTRUCTORS)\n");
4780 minfo (" CONSTRUCTORS\n");
4781 print_statement_list (constructor_list
.head
, os
);
4784 case lang_wild_statement_enum
:
4785 print_wild_statement (&s
->wild_statement
, os
);
4787 case lang_address_statement_enum
:
4788 print_address_statement (&s
->address_statement
);
4790 case lang_object_symbols_statement_enum
:
4791 minfo (" CREATE_OBJECT_SYMBOLS\n");
4793 case lang_fill_statement_enum
:
4794 print_fill_statement (&s
->fill_statement
);
4796 case lang_data_statement_enum
:
4797 print_data_statement (&s
->data_statement
);
4799 case lang_reloc_statement_enum
:
4800 print_reloc_statement (&s
->reloc_statement
);
4802 case lang_input_section_enum
:
4803 print_input_section (s
->input_section
.section
, FALSE
);
4805 case lang_padding_statement_enum
:
4806 print_padding_statement (&s
->padding_statement
);
4808 case lang_output_section_statement_enum
:
4809 print_output_section_statement (&s
->output_section_statement
);
4811 case lang_assignment_statement_enum
:
4812 print_assignment (&s
->assignment_statement
, os
);
4814 case lang_target_statement_enum
:
4815 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
4817 case lang_output_statement_enum
:
4818 minfo ("OUTPUT(%s", s
->output_statement
.name
);
4819 if (output_target
!= NULL
)
4820 minfo (" %s", output_target
);
4823 case lang_input_statement_enum
:
4824 print_input_statement (&s
->input_statement
);
4826 case lang_group_statement_enum
:
4827 print_group (&s
->group_statement
, os
);
4829 case lang_insert_statement_enum
:
4830 minfo ("INSERT %s %s\n",
4831 s
->insert_statement
.is_before
? "BEFORE" : "AFTER",
4832 s
->insert_statement
.where
);
4838 print_statements (void)
4840 print_statement_list (statement_list
.head
, abs_output_section
);
4843 /* Print the first N statements in statement list S to STDERR.
4844 If N == 0, nothing is printed.
4845 If N < 0, the entire list is printed.
4846 Intended to be called from GDB. */
4849 dprint_statement (lang_statement_union_type
*s
, int n
)
4851 FILE *map_save
= config
.map_file
;
4853 config
.map_file
= stderr
;
4856 print_statement_list (s
, abs_output_section
);
4859 while (s
&& --n
>= 0)
4861 print_statement (s
, abs_output_section
);
4866 config
.map_file
= map_save
;
4870 insert_pad (lang_statement_union_type
**ptr
,
4872 bfd_size_type alignment_needed
,
4873 asection
*output_section
,
4876 static fill_type zero_fill
;
4877 lang_statement_union_type
*pad
= NULL
;
4879 if (ptr
!= &statement_list
.head
)
4880 pad
= ((lang_statement_union_type
*)
4881 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
4883 && pad
->header
.type
== lang_padding_statement_enum
4884 && pad
->padding_statement
.output_section
== output_section
)
4886 /* Use the existing pad statement. */
4888 else if ((pad
= *ptr
) != NULL
4889 && pad
->header
.type
== lang_padding_statement_enum
4890 && pad
->padding_statement
.output_section
== output_section
)
4892 /* Use the existing pad statement. */
4896 /* Make a new padding statement, linked into existing chain. */
4897 pad
= (lang_statement_union_type
*)
4898 stat_alloc (sizeof (lang_padding_statement_type
));
4899 pad
->header
.next
= *ptr
;
4901 pad
->header
.type
= lang_padding_statement_enum
;
4902 pad
->padding_statement
.output_section
= output_section
;
4905 pad
->padding_statement
.fill
= fill
;
4907 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
4908 pad
->padding_statement
.size
= alignment_needed
;
4909 if (!(output_section
->flags
& SEC_FIXED_SIZE
))
4910 output_section
->size
= TO_SIZE (dot
+ TO_ADDR (alignment_needed
)
4911 - output_section
->vma
);
4914 /* Work out how much this section will move the dot point. */
4918 (lang_statement_union_type
**this_ptr
,
4919 lang_output_section_statement_type
*output_section_statement
,
4923 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
4924 asection
*i
= is
->section
;
4925 asection
*o
= output_section_statement
->bfd_section
;
4927 if (i
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
4928 i
->output_offset
= i
->vma
- o
->vma
;
4929 else if (((i
->flags
& SEC_EXCLUDE
) != 0)
4930 || output_section_statement
->ignored
)
4931 i
->output_offset
= dot
- o
->vma
;
4934 bfd_size_type alignment_needed
;
4936 /* Align this section first to the input sections requirement,
4937 then to the output section's requirement. If this alignment
4938 is greater than any seen before, then record it too. Perform
4939 the alignment by inserting a magic 'padding' statement. */
4941 if (output_section_statement
->subsection_alignment
!= NULL
)
4943 = exp_get_power (output_section_statement
->subsection_alignment
,
4944 "subsection alignment");
4946 if (o
->alignment_power
< i
->alignment_power
)
4947 o
->alignment_power
= i
->alignment_power
;
4949 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
4951 if (alignment_needed
!= 0)
4953 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
4954 dot
+= alignment_needed
;
4957 /* Remember where in the output section this input section goes. */
4958 i
->output_offset
= dot
- o
->vma
;
4960 /* Mark how big the output section must be to contain this now. */
4961 dot
+= TO_ADDR (i
->size
);
4962 if (!(o
->flags
& SEC_FIXED_SIZE
))
4963 o
->size
= TO_SIZE (dot
- o
->vma
);
4976 sort_sections_by_lma (const void *arg1
, const void *arg2
)
4978 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
4979 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
4981 if (sec1
->lma
< sec2
->lma
)
4983 else if (sec1
->lma
> sec2
->lma
)
4985 else if (sec1
->id
< sec2
->id
)
4987 else if (sec1
->id
> sec2
->id
)
4994 sort_sections_by_vma (const void *arg1
, const void *arg2
)
4996 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
4997 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
4999 if (sec1
->vma
< sec2
->vma
)
5001 else if (sec1
->vma
> sec2
->vma
)
5003 else if (sec1
->id
< sec2
->id
)
5005 else if (sec1
->id
> sec2
->id
)
5011 #define IS_TBSS(s) \
5012 ((s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == SEC_THREAD_LOCAL)
5014 #define IGNORE_SECTION(s) \
5015 ((s->flags & SEC_ALLOC) == 0 || IS_TBSS (s))
5017 /* Check to see if any allocated sections overlap with other allocated
5018 sections. This can happen if a linker script specifies the output
5019 section addresses of the two sections. Also check whether any memory
5020 region has overflowed. */
5023 lang_check_section_addresses (void)
5026 struct check_sec
*sections
;
5031 bfd_vma p_start
= 0;
5033 lang_memory_region_type
*m
;
5034 bfd_boolean overlays
;
5036 /* Detect address space overflow on allocated sections. */
5037 addr_mask
= ((bfd_vma
) 1 <<
5038 (bfd_arch_bits_per_address (link_info
.output_bfd
) - 1)) - 1;
5039 addr_mask
= (addr_mask
<< 1) + 1;
5040 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5041 if ((s
->flags
& SEC_ALLOC
) != 0)
5043 s_end
= (s
->vma
+ s
->size
) & addr_mask
;
5044 if (s_end
!= 0 && s_end
< (s
->vma
& addr_mask
))
5045 einfo (_("%X%P: section %s VMA wraps around address space\n"),
5049 s_end
= (s
->lma
+ s
->size
) & addr_mask
;
5050 if (s_end
!= 0 && s_end
< (s
->lma
& addr_mask
))
5051 einfo (_("%X%P: section %s LMA wraps around address space\n"),
5056 if (bfd_count_sections (link_info
.output_bfd
) <= 1)
5059 count
= bfd_count_sections (link_info
.output_bfd
);
5060 sections
= XNEWVEC (struct check_sec
, count
);
5062 /* Scan all sections in the output list. */
5064 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5066 if (IGNORE_SECTION (s
)
5070 sections
[count
].sec
= s
;
5071 sections
[count
].warned
= FALSE
;
5081 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_lma
);
5083 /* First check section LMAs. There should be no overlap of LMAs on
5084 loadable sections, even with overlays. */
5085 for (p
= NULL
, i
= 0; i
< count
; i
++)
5087 s
= sections
[i
].sec
;
5088 if ((s
->flags
& SEC_LOAD
) != 0)
5091 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5093 /* Look for an overlap. We have sorted sections by lma, so
5094 we know that s_start >= p_start. Besides the obvious
5095 case of overlap when the current section starts before
5096 the previous one ends, we also must have overlap if the
5097 previous section wraps around the address space. */
5099 && (s_start
<= p_end
5100 || p_end
< p_start
))
5102 einfo (_("%X%P: section %s LMA [%V,%V]"
5103 " overlaps section %s LMA [%V,%V]\n"),
5104 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5105 sections
[i
].warned
= TRUE
;
5113 /* If any non-zero size allocated section (excluding tbss) starts at
5114 exactly the same VMA as another such section, then we have
5115 overlays. Overlays generated by the OVERLAY keyword will have
5116 this property. It is possible to intentionally generate overlays
5117 that fail this test, but it would be unusual. */
5118 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_vma
);
5120 p_start
= sections
[0].sec
->vma
;
5121 for (i
= 1; i
< count
; i
++)
5123 s_start
= sections
[i
].sec
->vma
;
5124 if (p_start
== s_start
)
5132 /* Now check section VMAs if no overlays were detected. */
5135 for (p
= NULL
, i
= 0; i
< count
; i
++)
5137 s
= sections
[i
].sec
;
5139 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5142 && !sections
[i
].warned
5143 && (s_start
<= p_end
5144 || p_end
< p_start
))
5145 einfo (_("%X%P: section %s VMA [%V,%V]"
5146 " overlaps section %s VMA [%V,%V]\n"),
5147 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5156 /* If any memory region has overflowed, report by how much.
5157 We do not issue this diagnostic for regions that had sections
5158 explicitly placed outside their bounds; os_region_check's
5159 diagnostics are adequate for that case.
5161 FIXME: It is conceivable that m->current - (m->origin + m->length)
5162 might overflow a 32-bit integer. There is, alas, no way to print
5163 a bfd_vma quantity in decimal. */
5164 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
5165 if (m
->had_full_message
)
5167 unsigned long over
= m
->current
- (m
->origin
+ m
->length
);
5168 einfo (ngettext ("%X%P: region `%s' overflowed by %lu byte\n",
5169 "%X%P: region `%s' overflowed by %lu bytes\n",
5171 m
->name_list
.name
, over
);
5175 /* Make sure the new address is within the region. We explicitly permit the
5176 current address to be at the exact end of the region when the address is
5177 non-zero, in case the region is at the end of addressable memory and the
5178 calculation wraps around. */
5181 os_region_check (lang_output_section_statement_type
*os
,
5182 lang_memory_region_type
*region
,
5186 if ((region
->current
< region
->origin
5187 || (region
->current
- region
->origin
> region
->length
))
5188 && ((region
->current
!= region
->origin
+ region
->length
)
5193 einfo (_("%X%P: address 0x%v of %pB section `%s'"
5194 " is not within region `%s'\n"),
5196 os
->bfd_section
->owner
,
5197 os
->bfd_section
->name
,
5198 region
->name_list
.name
);
5200 else if (!region
->had_full_message
)
5202 region
->had_full_message
= TRUE
;
5204 einfo (_("%X%P: %pB section `%s' will not fit in region `%s'\n"),
5205 os
->bfd_section
->owner
,
5206 os
->bfd_section
->name
,
5207 region
->name_list
.name
);
5213 ldlang_check_relro_region (lang_statement_union_type
*s
,
5214 seg_align_type
*seg
)
5216 if (seg
->relro
== exp_seg_relro_start
)
5218 if (!seg
->relro_start_stat
)
5219 seg
->relro_start_stat
= s
;
5222 ASSERT (seg
->relro_start_stat
== s
);
5225 else if (seg
->relro
== exp_seg_relro_end
)
5227 if (!seg
->relro_end_stat
)
5228 seg
->relro_end_stat
= s
;
5231 ASSERT (seg
->relro_end_stat
== s
);
5236 /* Set the sizes for all the output sections. */
5239 lang_size_sections_1
5240 (lang_statement_union_type
**prev
,
5241 lang_output_section_statement_type
*output_section_statement
,
5245 bfd_boolean check_regions
)
5247 lang_statement_union_type
*s
;
5249 /* Size up the sections from their constituent parts. */
5250 for (s
= *prev
; s
!= NULL
; s
= s
->header
.next
)
5252 switch (s
->header
.type
)
5254 case lang_output_section_statement_enum
:
5256 bfd_vma newdot
, after
, dotdelta
;
5257 lang_output_section_statement_type
*os
;
5258 lang_memory_region_type
*r
;
5259 int section_alignment
= 0;
5261 os
= &s
->output_section_statement
;
5262 if (os
->constraint
== -1)
5265 /* FIXME: We shouldn't need to zero section vmas for ld -r
5266 here, in lang_insert_orphan, or in the default linker scripts.
5267 This is covering for coff backend linker bugs. See PR6945. */
5268 if (os
->addr_tree
== NULL
5269 && bfd_link_relocatable (&link_info
)
5270 && (bfd_get_flavour (link_info
.output_bfd
)
5271 == bfd_target_coff_flavour
))
5272 os
->addr_tree
= exp_intop (0);
5273 if (os
->addr_tree
!= NULL
)
5275 os
->processed_vma
= FALSE
;
5276 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
5278 if (expld
.result
.valid_p
)
5280 dot
= expld
.result
.value
;
5281 if (expld
.result
.section
!= NULL
)
5282 dot
+= expld
.result
.section
->vma
;
5284 else if (expld
.phase
!= lang_mark_phase_enum
)
5285 einfo (_("%F%P:%pS: non constant or forward reference"
5286 " address expression for section %s\n"),
5287 os
->addr_tree
, os
->name
);
5290 if (os
->bfd_section
== NULL
)
5291 /* This section was removed or never actually created. */
5294 /* If this is a COFF shared library section, use the size and
5295 address from the input section. FIXME: This is COFF
5296 specific; it would be cleaner if there were some other way
5297 to do this, but nothing simple comes to mind. */
5298 if (((bfd_get_flavour (link_info
.output_bfd
)
5299 == bfd_target_ecoff_flavour
)
5300 || (bfd_get_flavour (link_info
.output_bfd
)
5301 == bfd_target_coff_flavour
))
5302 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
5306 if (os
->children
.head
== NULL
5307 || os
->children
.head
->header
.next
!= NULL
5308 || (os
->children
.head
->header
.type
5309 != lang_input_section_enum
))
5310 einfo (_("%X%P: internal error on COFF shared library"
5311 " section %s\n"), os
->name
);
5313 input
= os
->children
.head
->input_section
.section
;
5314 bfd_set_section_vma (os
->bfd_section
->owner
,
5316 bfd_section_vma (input
->owner
, input
));
5317 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5318 os
->bfd_section
->size
= input
->size
;
5324 if (bfd_is_abs_section (os
->bfd_section
))
5326 /* No matter what happens, an abs section starts at zero. */
5327 ASSERT (os
->bfd_section
->vma
== 0);
5331 if (os
->addr_tree
== NULL
)
5333 /* No address specified for this section, get one
5334 from the region specification. */
5335 if (os
->region
== NULL
5336 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
5337 && os
->region
->name_list
.name
[0] == '*'
5338 && strcmp (os
->region
->name_list
.name
,
5339 DEFAULT_MEMORY_REGION
) == 0))
5341 os
->region
= lang_memory_default (os
->bfd_section
);
5344 /* If a loadable section is using the default memory
5345 region, and some non default memory regions were
5346 defined, issue an error message. */
5348 && !IGNORE_SECTION (os
->bfd_section
)
5349 && !bfd_link_relocatable (&link_info
)
5351 && strcmp (os
->region
->name_list
.name
,
5352 DEFAULT_MEMORY_REGION
) == 0
5353 && lang_memory_region_list
!= NULL
5354 && (strcmp (lang_memory_region_list
->name_list
.name
,
5355 DEFAULT_MEMORY_REGION
) != 0
5356 || lang_memory_region_list
->next
!= NULL
)
5357 && expld
.phase
!= lang_mark_phase_enum
)
5359 /* By default this is an error rather than just a
5360 warning because if we allocate the section to the
5361 default memory region we can end up creating an
5362 excessively large binary, or even seg faulting when
5363 attempting to perform a negative seek. See
5364 sources.redhat.com/ml/binutils/2003-04/msg00423.html
5365 for an example of this. This behaviour can be
5366 overridden by the using the --no-check-sections
5368 if (command_line
.check_section_addresses
)
5369 einfo (_("%F%P: error: no memory region specified"
5370 " for loadable section `%s'\n"),
5371 bfd_get_section_name (link_info
.output_bfd
,
5374 einfo (_("%P: warning: no memory region specified"
5375 " for loadable section `%s'\n"),
5376 bfd_get_section_name (link_info
.output_bfd
,
5380 newdot
= os
->region
->current
;
5381 section_alignment
= os
->bfd_section
->alignment_power
;
5384 section_alignment
= exp_get_power (os
->section_alignment
,
5385 "section alignment");
5387 /* Align to what the section needs. */
5388 if (section_alignment
> 0)
5390 bfd_vma savedot
= newdot
;
5391 newdot
= align_power (newdot
, section_alignment
);
5393 dotdelta
= newdot
- savedot
;
5395 && (config
.warn_section_align
5396 || os
->addr_tree
!= NULL
)
5397 && expld
.phase
!= lang_mark_phase_enum
)
5398 einfo (ngettext ("%P: warning: changing start of "
5399 "section %s by %lu byte\n",
5400 "%P: warning: changing start of "
5401 "section %s by %lu bytes\n",
5402 (unsigned long) dotdelta
),
5403 os
->name
, (unsigned long) dotdelta
);
5406 bfd_set_section_vma (0, os
->bfd_section
, newdot
);
5408 os
->bfd_section
->output_offset
= 0;
5411 lang_size_sections_1 (&os
->children
.head
, os
,
5412 os
->fill
, newdot
, relax
, check_regions
);
5414 os
->processed_vma
= TRUE
;
5416 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5417 /* Except for some special linker created sections,
5418 no output section should change from zero size
5419 after strip_excluded_output_sections. A non-zero
5420 size on an ignored section indicates that some
5421 input section was not sized early enough. */
5422 ASSERT (os
->bfd_section
->size
== 0);
5425 dot
= os
->bfd_section
->vma
;
5427 /* Put the section within the requested block size, or
5428 align at the block boundary. */
5430 + TO_ADDR (os
->bfd_section
->size
)
5431 + os
->block_value
- 1)
5432 & - (bfd_vma
) os
->block_value
);
5434 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5435 os
->bfd_section
->size
= TO_SIZE (after
5436 - os
->bfd_section
->vma
);
5439 /* Set section lma. */
5442 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
5446 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
5447 os
->bfd_section
->lma
= lma
;
5449 else if (os
->lma_region
!= NULL
)
5451 bfd_vma lma
= os
->lma_region
->current
;
5453 if (os
->align_lma_with_input
)
5457 /* When LMA_REGION is the same as REGION, align the LMA
5458 as we did for the VMA, possibly including alignment
5459 from the bfd section. If a different region, then
5460 only align according to the value in the output
5462 if (os
->lma_region
!= os
->region
)
5463 section_alignment
= exp_get_power (os
->section_alignment
,
5464 "section alignment");
5465 if (section_alignment
> 0)
5466 lma
= align_power (lma
, section_alignment
);
5468 os
->bfd_section
->lma
= lma
;
5470 else if (r
->last_os
!= NULL
5471 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5476 last
= r
->last_os
->output_section_statement
.bfd_section
;
5478 /* A backwards move of dot should be accompanied by
5479 an explicit assignment to the section LMA (ie.
5480 os->load_base set) because backwards moves can
5481 create overlapping LMAs. */
5483 && os
->bfd_section
->size
!= 0
5484 && dot
+ TO_ADDR (os
->bfd_section
->size
) <= last
->vma
)
5486 /* If dot moved backwards then leave lma equal to
5487 vma. This is the old default lma, which might
5488 just happen to work when the backwards move is
5489 sufficiently large. Nag if this changes anything,
5490 so people can fix their linker scripts. */
5492 if (last
->vma
!= last
->lma
)
5493 einfo (_("%P: warning: dot moved backwards "
5494 "before `%s'\n"), os
->name
);
5498 /* If this is an overlay, set the current lma to that
5499 at the end of the previous section. */
5500 if (os
->sectype
== overlay_section
)
5501 lma
= last
->lma
+ TO_ADDR (last
->size
);
5503 /* Otherwise, keep the same lma to vma relationship
5504 as the previous section. */
5506 lma
= dot
+ last
->lma
- last
->vma
;
5508 if (section_alignment
> 0)
5509 lma
= align_power (lma
, section_alignment
);
5510 os
->bfd_section
->lma
= lma
;
5513 os
->processed_lma
= TRUE
;
5515 /* Keep track of normal sections using the default
5516 lma region. We use this to set the lma for
5517 following sections. Overlays or other linker
5518 script assignment to lma might mean that the
5519 default lma == vma is incorrect.
5520 To avoid warnings about dot moving backwards when using
5521 -Ttext, don't start tracking sections until we find one
5522 of non-zero size or with lma set differently to vma.
5523 Do this tracking before we short-cut the loop so that we
5524 track changes for the case where the section size is zero,
5525 but the lma is set differently to the vma. This is
5526 important, if an orphan section is placed after an
5527 otherwise empty output section that has an explicit lma
5528 set, we want that lma reflected in the orphans lma. */
5529 if (((!IGNORE_SECTION (os
->bfd_section
)
5530 && (os
->bfd_section
->size
!= 0
5531 || (r
->last_os
== NULL
5532 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
5533 || (r
->last_os
!= NULL
5534 && dot
>= (r
->last_os
->output_section_statement
5535 .bfd_section
->vma
))))
5536 || os
->sectype
== first_overlay_section
)
5537 && os
->lma_region
== NULL
5538 && !bfd_link_relocatable (&link_info
))
5541 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5544 /* .tbss sections effectively have zero size. */
5545 if (!IS_TBSS (os
->bfd_section
)
5546 || bfd_link_relocatable (&link_info
))
5547 dotdelta
= TO_ADDR (os
->bfd_section
->size
);
5552 if (os
->update_dot_tree
!= 0)
5553 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5555 /* Update dot in the region ?
5556 We only do this if the section is going to be allocated,
5557 since unallocated sections do not contribute to the region's
5558 overall size in memory. */
5559 if (os
->region
!= NULL
5560 && (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)))
5562 os
->region
->current
= dot
;
5565 /* Make sure the new address is within the region. */
5566 os_region_check (os
, os
->region
, os
->addr_tree
,
5567 os
->bfd_section
->vma
);
5569 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
5570 && ((os
->bfd_section
->flags
& SEC_LOAD
)
5571 || os
->align_lma_with_input
))
5573 os
->lma_region
->current
= os
->bfd_section
->lma
+ dotdelta
;
5576 os_region_check (os
, os
->lma_region
, NULL
,
5577 os
->bfd_section
->lma
);
5583 case lang_constructors_statement_enum
:
5584 dot
= lang_size_sections_1 (&constructor_list
.head
,
5585 output_section_statement
,
5586 fill
, dot
, relax
, check_regions
);
5589 case lang_data_statement_enum
:
5591 unsigned int size
= 0;
5593 s
->data_statement
.output_offset
=
5594 dot
- output_section_statement
->bfd_section
->vma
;
5595 s
->data_statement
.output_section
=
5596 output_section_statement
->bfd_section
;
5598 /* We might refer to provided symbols in the expression, and
5599 need to mark them as needed. */
5600 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5602 switch (s
->data_statement
.type
)
5620 if (size
< TO_SIZE ((unsigned) 1))
5621 size
= TO_SIZE ((unsigned) 1);
5622 dot
+= TO_ADDR (size
);
5623 if (!(output_section_statement
->bfd_section
->flags
5625 output_section_statement
->bfd_section
->size
5626 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5631 case lang_reloc_statement_enum
:
5635 s
->reloc_statement
.output_offset
=
5636 dot
- output_section_statement
->bfd_section
->vma
;
5637 s
->reloc_statement
.output_section
=
5638 output_section_statement
->bfd_section
;
5639 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
5640 dot
+= TO_ADDR (size
);
5641 if (!(output_section_statement
->bfd_section
->flags
5643 output_section_statement
->bfd_section
->size
5644 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5648 case lang_wild_statement_enum
:
5649 dot
= lang_size_sections_1 (&s
->wild_statement
.children
.head
,
5650 output_section_statement
,
5651 fill
, dot
, relax
, check_regions
);
5654 case lang_object_symbols_statement_enum
:
5655 link_info
.create_object_symbols_section
5656 = output_section_statement
->bfd_section
;
5657 output_section_statement
->bfd_section
->flags
|= SEC_KEEP
;
5660 case lang_output_statement_enum
:
5661 case lang_target_statement_enum
:
5664 case lang_input_section_enum
:
5668 i
= s
->input_section
.section
;
5673 if (!bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
5674 einfo (_("%F%P: can't relax section: %E\n"));
5678 dot
= size_input_section (prev
, output_section_statement
,
5683 case lang_input_statement_enum
:
5686 case lang_fill_statement_enum
:
5687 s
->fill_statement
.output_section
=
5688 output_section_statement
->bfd_section
;
5690 fill
= s
->fill_statement
.fill
;
5693 case lang_assignment_statement_enum
:
5695 bfd_vma newdot
= dot
;
5696 etree_type
*tree
= s
->assignment_statement
.exp
;
5698 expld
.dataseg
.relro
= exp_seg_relro_none
;
5700 exp_fold_tree (tree
,
5701 output_section_statement
->bfd_section
,
5704 ldlang_check_relro_region (s
, &expld
.dataseg
);
5706 expld
.dataseg
.relro
= exp_seg_relro_none
;
5708 /* This symbol may be relative to this section. */
5709 if ((tree
->type
.node_class
== etree_provided
5710 || tree
->type
.node_class
== etree_assign
)
5711 && (tree
->assign
.dst
[0] != '.'
5712 || tree
->assign
.dst
[1] != '\0'))
5713 output_section_statement
->update_dot
= 1;
5715 if (!output_section_statement
->ignored
)
5717 if (output_section_statement
== abs_output_section
)
5719 /* If we don't have an output section, then just adjust
5720 the default memory address. */
5721 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
5722 FALSE
)->current
= newdot
;
5724 else if (newdot
!= dot
)
5726 /* Insert a pad after this statement. We can't
5727 put the pad before when relaxing, in case the
5728 assignment references dot. */
5729 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
5730 output_section_statement
->bfd_section
, dot
);
5732 /* Don't neuter the pad below when relaxing. */
5735 /* If dot is advanced, this implies that the section
5736 should have space allocated to it, unless the
5737 user has explicitly stated that the section
5738 should not be allocated. */
5739 if (output_section_statement
->sectype
!= noalloc_section
5740 && (output_section_statement
->sectype
!= noload_section
5741 || (bfd_get_flavour (link_info
.output_bfd
)
5742 == bfd_target_elf_flavour
)))
5743 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
5750 case lang_padding_statement_enum
:
5751 /* If this is the first time lang_size_sections is called,
5752 we won't have any padding statements. If this is the
5753 second or later passes when relaxing, we should allow
5754 padding to shrink. If padding is needed on this pass, it
5755 will be added back in. */
5756 s
->padding_statement
.size
= 0;
5758 /* Make sure output_offset is valid. If relaxation shrinks
5759 the section and this pad isn't needed, it's possible to
5760 have output_offset larger than the final size of the
5761 section. bfd_set_section_contents will complain even for
5762 a pad size of zero. */
5763 s
->padding_statement
.output_offset
5764 = dot
- output_section_statement
->bfd_section
->vma
;
5767 case lang_group_statement_enum
:
5768 dot
= lang_size_sections_1 (&s
->group_statement
.children
.head
,
5769 output_section_statement
,
5770 fill
, dot
, relax
, check_regions
);
5773 case lang_insert_statement_enum
:
5776 /* We can only get here when relaxing is turned on. */
5777 case lang_address_statement_enum
:
5784 prev
= &s
->header
.next
;
5789 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
5790 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
5791 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
5792 segments. We are allowed an opportunity to override this decision. */
5795 ldlang_override_segment_assignment (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5796 bfd
*abfd ATTRIBUTE_UNUSED
,
5797 asection
*current_section
,
5798 asection
*previous_section
,
5799 bfd_boolean new_segment
)
5801 lang_output_section_statement_type
*cur
;
5802 lang_output_section_statement_type
*prev
;
5804 /* The checks below are only necessary when the BFD library has decided
5805 that the two sections ought to be placed into the same segment. */
5809 /* Paranoia checks. */
5810 if (current_section
== NULL
|| previous_section
== NULL
)
5813 /* If this flag is set, the target never wants code and non-code
5814 sections comingled in the same segment. */
5815 if (config
.separate_code
5816 && ((current_section
->flags
^ previous_section
->flags
) & SEC_CODE
))
5819 /* Find the memory regions associated with the two sections.
5820 We call lang_output_section_find() here rather than scanning the list
5821 of output sections looking for a matching section pointer because if
5822 we have a large number of sections then a hash lookup is faster. */
5823 cur
= lang_output_section_find (current_section
->name
);
5824 prev
= lang_output_section_find (previous_section
->name
);
5826 /* More paranoia. */
5827 if (cur
== NULL
|| prev
== NULL
)
5830 /* If the regions are different then force the sections to live in
5831 different segments. See the email thread starting at the following
5832 URL for the reasons why this is necessary:
5833 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
5834 return cur
->region
!= prev
->region
;
5838 one_lang_size_sections_pass (bfd_boolean
*relax
, bfd_boolean check_regions
)
5840 lang_statement_iteration
++;
5841 lang_size_sections_1 (&statement_list
.head
, abs_output_section
,
5842 0, 0, relax
, check_regions
);
5846 lang_size_segment (seg_align_type
*seg
)
5848 /* If XXX_SEGMENT_ALIGN XXX_SEGMENT_END pair was seen, check whether
5849 a page could be saved in the data segment. */
5850 bfd_vma first
, last
;
5852 first
= -seg
->base
& (seg
->pagesize
- 1);
5853 last
= seg
->end
& (seg
->pagesize
- 1);
5855 && ((seg
->base
& ~(seg
->pagesize
- 1))
5856 != (seg
->end
& ~(seg
->pagesize
- 1)))
5857 && first
+ last
<= seg
->pagesize
)
5859 seg
->phase
= exp_seg_adjust
;
5863 seg
->phase
= exp_seg_done
;
5868 lang_size_relro_segment_1 (seg_align_type
*seg
)
5870 bfd_vma relro_end
, desired_end
;
5873 /* Compute the expected PT_GNU_RELRO/PT_LOAD segment end. */
5874 relro_end
= ((seg
->relro_end
+ seg
->pagesize
- 1)
5875 & ~(seg
->pagesize
- 1));
5877 /* Adjust by the offset arg of XXX_SEGMENT_RELRO_END. */
5878 desired_end
= relro_end
- seg
->relro_offset
;
5880 /* For sections in the relro segment.. */
5881 for (sec
= link_info
.output_bfd
->section_last
; sec
; sec
= sec
->prev
)
5882 if ((sec
->flags
& SEC_ALLOC
) != 0
5883 && sec
->vma
>= seg
->base
5884 && sec
->vma
< seg
->relro_end
- seg
->relro_offset
)
5886 /* Where do we want to put this section so that it ends as
5888 bfd_vma start
, end
, bump
;
5890 end
= start
= sec
->vma
;
5892 end
+= TO_ADDR (sec
->size
);
5893 bump
= desired_end
- end
;
5894 /* We'd like to increase START by BUMP, but we must heed
5895 alignment so the increase might be less than optimum. */
5897 start
&= ~(((bfd_vma
) 1 << sec
->alignment_power
) - 1);
5898 /* This is now the desired end for the previous section. */
5899 desired_end
= start
;
5902 seg
->phase
= exp_seg_relro_adjust
;
5903 ASSERT (desired_end
>= seg
->base
);
5904 seg
->base
= desired_end
;
5909 lang_size_relro_segment (bfd_boolean
*relax
, bfd_boolean check_regions
)
5911 bfd_boolean do_reset
= FALSE
;
5912 bfd_boolean do_data_relro
;
5913 bfd_vma data_initial_base
, data_relro_end
;
5915 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
5917 do_data_relro
= TRUE
;
5918 data_initial_base
= expld
.dataseg
.base
;
5919 data_relro_end
= lang_size_relro_segment_1 (&expld
.dataseg
);
5923 do_data_relro
= FALSE
;
5924 data_initial_base
= data_relro_end
= 0;
5929 lang_reset_memory_regions ();
5930 one_lang_size_sections_pass (relax
, check_regions
);
5932 /* Assignments to dot, or to output section address in a user
5933 script have increased padding over the original. Revert. */
5934 if (do_data_relro
&& expld
.dataseg
.relro_end
> data_relro_end
)
5936 expld
.dataseg
.base
= data_initial_base
;;
5941 if (!do_data_relro
&& lang_size_segment (&expld
.dataseg
))
5948 lang_size_sections (bfd_boolean
*relax
, bfd_boolean check_regions
)
5950 expld
.phase
= lang_allocating_phase_enum
;
5951 expld
.dataseg
.phase
= exp_seg_none
;
5953 one_lang_size_sections_pass (relax
, check_regions
);
5955 if (expld
.dataseg
.phase
!= exp_seg_end_seen
)
5956 expld
.dataseg
.phase
= exp_seg_done
;
5958 if (expld
.dataseg
.phase
== exp_seg_end_seen
)
5960 bfd_boolean do_reset
5961 = lang_size_relro_segment (relax
, check_regions
);
5965 lang_reset_memory_regions ();
5966 one_lang_size_sections_pass (relax
, check_regions
);
5969 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
5971 link_info
.relro_start
= expld
.dataseg
.base
;
5972 link_info
.relro_end
= expld
.dataseg
.relro_end
;
5977 static lang_output_section_statement_type
*current_section
;
5978 static lang_assignment_statement_type
*current_assign
;
5979 static bfd_boolean prefer_next_section
;
5981 /* Worker function for lang_do_assignments. Recursiveness goes here. */
5984 lang_do_assignments_1 (lang_statement_union_type
*s
,
5985 lang_output_section_statement_type
*current_os
,
5988 bfd_boolean
*found_end
)
5990 for (; s
!= NULL
; s
= s
->header
.next
)
5992 switch (s
->header
.type
)
5994 case lang_constructors_statement_enum
:
5995 dot
= lang_do_assignments_1 (constructor_list
.head
,
5996 current_os
, fill
, dot
, found_end
);
5999 case lang_output_section_statement_enum
:
6001 lang_output_section_statement_type
*os
;
6004 os
= &(s
->output_section_statement
);
6005 os
->after_end
= *found_end
;
6006 if (os
->bfd_section
!= NULL
&& !os
->ignored
)
6008 if ((os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
6010 current_section
= os
;
6011 prefer_next_section
= FALSE
;
6013 dot
= os
->bfd_section
->vma
;
6015 newdot
= lang_do_assignments_1 (os
->children
.head
,
6016 os
, os
->fill
, dot
, found_end
);
6019 if (os
->bfd_section
!= NULL
)
6021 /* .tbss sections effectively have zero size. */
6022 if (!IS_TBSS (os
->bfd_section
)
6023 || bfd_link_relocatable (&link_info
))
6024 dot
+= TO_ADDR (os
->bfd_section
->size
);
6026 if (os
->update_dot_tree
!= NULL
)
6027 exp_fold_tree (os
->update_dot_tree
,
6028 bfd_abs_section_ptr
, &dot
);
6036 case lang_wild_statement_enum
:
6038 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
6039 current_os
, fill
, dot
, found_end
);
6042 case lang_object_symbols_statement_enum
:
6043 case lang_output_statement_enum
:
6044 case lang_target_statement_enum
:
6047 case lang_data_statement_enum
:
6048 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
6049 if (expld
.result
.valid_p
)
6051 s
->data_statement
.value
= expld
.result
.value
;
6052 if (expld
.result
.section
!= NULL
)
6053 s
->data_statement
.value
+= expld
.result
.section
->vma
;
6055 else if (expld
.phase
== lang_final_phase_enum
)
6056 einfo (_("%F%P: invalid data statement\n"));
6059 switch (s
->data_statement
.type
)
6077 if (size
< TO_SIZE ((unsigned) 1))
6078 size
= TO_SIZE ((unsigned) 1);
6079 dot
+= TO_ADDR (size
);
6083 case lang_reloc_statement_enum
:
6084 exp_fold_tree (s
->reloc_statement
.addend_exp
,
6085 bfd_abs_section_ptr
, &dot
);
6086 if (expld
.result
.valid_p
)
6087 s
->reloc_statement
.addend_value
= expld
.result
.value
;
6088 else if (expld
.phase
== lang_final_phase_enum
)
6089 einfo (_("%F%P: invalid reloc statement\n"));
6090 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
6093 case lang_input_section_enum
:
6095 asection
*in
= s
->input_section
.section
;
6097 if ((in
->flags
& SEC_EXCLUDE
) == 0)
6098 dot
+= TO_ADDR (in
->size
);
6102 case lang_input_statement_enum
:
6105 case lang_fill_statement_enum
:
6106 fill
= s
->fill_statement
.fill
;
6109 case lang_assignment_statement_enum
:
6110 current_assign
= &s
->assignment_statement
;
6111 if (current_assign
->exp
->type
.node_class
!= etree_assert
)
6113 const char *p
= current_assign
->exp
->assign
.dst
;
6115 if (current_os
== abs_output_section
&& p
[0] == '.' && p
[1] == 0)
6116 prefer_next_section
= TRUE
;
6120 if (strcmp (p
, "end") == 0)
6123 exp_fold_tree (s
->assignment_statement
.exp
,
6124 (current_os
->bfd_section
!= NULL
6125 ? current_os
->bfd_section
: bfd_und_section_ptr
),
6129 case lang_padding_statement_enum
:
6130 dot
+= TO_ADDR (s
->padding_statement
.size
);
6133 case lang_group_statement_enum
:
6134 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
6135 current_os
, fill
, dot
, found_end
);
6138 case lang_insert_statement_enum
:
6141 case lang_address_statement_enum
:
6153 lang_do_assignments (lang_phase_type phase
)
6155 bfd_boolean found_end
= FALSE
;
6157 current_section
= NULL
;
6158 prefer_next_section
= FALSE
;
6159 expld
.phase
= phase
;
6160 lang_statement_iteration
++;
6161 lang_do_assignments_1 (statement_list
.head
,
6162 abs_output_section
, NULL
, 0, &found_end
);
6165 /* For an assignment statement outside of an output section statement,
6166 choose the best of neighbouring output sections to use for values
6170 section_for_dot (void)
6174 /* Assignments belong to the previous output section, unless there
6175 has been an assignment to "dot", in which case following
6176 assignments belong to the next output section. (The assumption
6177 is that an assignment to "dot" is setting up the address for the
6178 next output section.) Except that past the assignment to "_end"
6179 we always associate with the previous section. This exception is
6180 for targets like SH that define an alloc .stack or other
6181 weirdness after non-alloc sections. */
6182 if (current_section
== NULL
|| prefer_next_section
)
6184 lang_statement_union_type
*stmt
;
6185 lang_output_section_statement_type
*os
;
6187 for (stmt
= (lang_statement_union_type
*) current_assign
;
6189 stmt
= stmt
->header
.next
)
6190 if (stmt
->header
.type
== lang_output_section_statement_enum
)
6193 os
= &stmt
->output_section_statement
;
6196 && (os
->bfd_section
== NULL
6197 || (os
->bfd_section
->flags
& SEC_EXCLUDE
) != 0
6198 || bfd_section_removed_from_list (link_info
.output_bfd
,
6202 if (current_section
== NULL
|| os
== NULL
|| !os
->after_end
)
6205 s
= os
->bfd_section
;
6207 s
= link_info
.output_bfd
->section_last
;
6209 && ((s
->flags
& SEC_ALLOC
) == 0
6210 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6215 return bfd_abs_section_ptr
;
6219 s
= current_section
->bfd_section
;
6221 /* The section may have been stripped. */
6223 && ((s
->flags
& SEC_EXCLUDE
) != 0
6224 || (s
->flags
& SEC_ALLOC
) == 0
6225 || (s
->flags
& SEC_THREAD_LOCAL
) != 0
6226 || bfd_section_removed_from_list (link_info
.output_bfd
, s
)))
6229 s
= link_info
.output_bfd
->sections
;
6231 && ((s
->flags
& SEC_ALLOC
) == 0
6232 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6237 return bfd_abs_section_ptr
;
6240 /* Array of __start/__stop/.startof./.sizeof/ symbols. */
6242 static struct bfd_link_hash_entry
**start_stop_syms
;
6243 static size_t start_stop_count
= 0;
6244 static size_t start_stop_alloc
= 0;
6246 /* Give start/stop SYMBOL for SEC a preliminary definition, and add it
6247 to start_stop_syms. */
6250 lang_define_start_stop (const char *symbol
, asection
*sec
)
6252 struct bfd_link_hash_entry
*h
;
6254 h
= bfd_define_start_stop (link_info
.output_bfd
, &link_info
, symbol
, sec
);
6257 if (start_stop_count
== start_stop_alloc
)
6259 start_stop_alloc
= 2 * start_stop_alloc
+ 10;
6261 = xrealloc (start_stop_syms
,
6262 start_stop_alloc
* sizeof (*start_stop_syms
));
6264 start_stop_syms
[start_stop_count
++] = h
;
6268 /* Check for input sections whose names match references to
6269 __start_SECNAME or __stop_SECNAME symbols. Give the symbols
6270 preliminary definitions. */
6273 lang_init_start_stop (void)
6277 char leading_char
= bfd_get_symbol_leading_char (link_info
.output_bfd
);
6279 for (abfd
= link_info
.input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6280 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6283 const char *secname
= s
->name
;
6285 for (ps
= secname
; *ps
!= '\0'; ps
++)
6286 if (!ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
6290 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6292 symbol
[0] = leading_char
;
6293 sprintf (symbol
+ (leading_char
!= 0), "__start_%s", secname
);
6294 lang_define_start_stop (symbol
, s
);
6296 symbol
[1] = leading_char
;
6297 memcpy (symbol
+ 1 + (leading_char
!= 0), "__stop", 6);
6298 lang_define_start_stop (symbol
+ 1, s
);
6305 /* Iterate over start_stop_syms. */
6308 foreach_start_stop (void (*func
) (struct bfd_link_hash_entry
*))
6312 for (i
= 0; i
< start_stop_count
; ++i
)
6313 func (start_stop_syms
[i
]);
6316 /* __start and __stop symbols are only supposed to be defined by the
6317 linker for orphan sections, but we now extend that to sections that
6318 map to an output section of the same name. The symbols were
6319 defined early for --gc-sections, before we mapped input to output
6320 sections, so undo those that don't satisfy this rule. */
6323 undef_start_stop (struct bfd_link_hash_entry
*h
)
6325 if (h
->ldscript_def
)
6328 if (h
->u
.def
.section
->output_section
== NULL
6329 || h
->u
.def
.section
->output_section
->owner
!= link_info
.output_bfd
6330 || strcmp (h
->u
.def
.section
->name
,
6331 h
->u
.def
.section
->output_section
->name
) != 0)
6333 asection
*sec
= bfd_get_section_by_name (link_info
.output_bfd
,
6334 h
->u
.def
.section
->name
);
6337 /* When there are more than one input sections with the same
6338 section name, SECNAME, linker picks the first one to define
6339 __start_SECNAME and __stop_SECNAME symbols. When the first
6340 input section is removed by comdat group, we need to check
6341 if there is still an output section with section name
6344 for (i
= sec
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
6345 if (strcmp (h
->u
.def
.section
->name
, i
->name
) == 0)
6347 h
->u
.def
.section
= i
;
6351 h
->type
= bfd_link_hash_undefined
;
6352 h
->u
.undef
.abfd
= NULL
;
6357 lang_undef_start_stop (void)
6359 foreach_start_stop (undef_start_stop
);
6362 /* Check for output sections whose names match references to
6363 .startof.SECNAME or .sizeof.SECNAME symbols. Give the symbols
6364 preliminary definitions. */
6367 lang_init_startof_sizeof (void)
6371 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6373 const char *secname
= s
->name
;
6374 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6376 sprintf (symbol
, ".startof.%s", secname
);
6377 lang_define_start_stop (symbol
, s
);
6379 memcpy (symbol
+ 1, ".size", 5);
6380 lang_define_start_stop (symbol
+ 1, s
);
6385 /* Set .startof., .sizeof., __start and __stop symbols final values. */
6388 set_start_stop (struct bfd_link_hash_entry
*h
)
6391 || h
->type
!= bfd_link_hash_defined
)
6394 if (h
->root
.string
[0] == '.')
6396 /* .startof. or .sizeof. symbol.
6397 .startof. already has final value. */
6398 if (h
->root
.string
[2] == 'i')
6401 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6402 h
->u
.def
.section
= bfd_abs_section_ptr
;
6407 /* __start or __stop symbol. */
6408 int has_lead
= bfd_get_symbol_leading_char (link_info
.output_bfd
) != 0;
6410 h
->u
.def
.section
= h
->u
.def
.section
->output_section
;
6411 if (h
->root
.string
[4 + has_lead
] == 'o')
6414 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6420 lang_finalize_start_stop (void)
6422 foreach_start_stop (set_start_stop
);
6428 struct bfd_link_hash_entry
*h
;
6431 if ((bfd_link_relocatable (&link_info
) && !link_info
.gc_sections
)
6432 || bfd_link_dll (&link_info
))
6433 warn
= entry_from_cmdline
;
6437 /* Force the user to specify a root when generating a relocatable with
6438 --gc-sections, unless --gc-keep-exported was also given. */
6439 if (bfd_link_relocatable (&link_info
)
6440 && link_info
.gc_sections
6441 && !link_info
.gc_keep_exported
6442 && !(entry_from_cmdline
|| undef_from_cmdline
))
6443 einfo (_("%F%P: gc-sections requires either an entry or "
6444 "an undefined symbol\n"));
6446 if (entry_symbol
.name
== NULL
)
6448 /* No entry has been specified. Look for the default entry, but
6449 don't warn if we don't find it. */
6450 entry_symbol
.name
= entry_symbol_default
;
6454 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
6455 FALSE
, FALSE
, TRUE
);
6457 && (h
->type
== bfd_link_hash_defined
6458 || h
->type
== bfd_link_hash_defweak
)
6459 && h
->u
.def
.section
->output_section
!= NULL
)
6463 val
= (h
->u
.def
.value
6464 + bfd_get_section_vma (link_info
.output_bfd
,
6465 h
->u
.def
.section
->output_section
)
6466 + h
->u
.def
.section
->output_offset
);
6467 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6468 einfo (_("%F%P: %s: can't set start address\n"), entry_symbol
.name
);
6475 /* We couldn't find the entry symbol. Try parsing it as a
6477 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
6480 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6481 einfo (_("%F%P: can't set start address\n"));
6487 /* Can't find the entry symbol, and it's not a number. Use
6488 the first address in the text section. */
6489 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
6493 einfo (_("%P: warning: cannot find entry symbol %s;"
6494 " defaulting to %V\n"),
6496 bfd_get_section_vma (link_info
.output_bfd
, ts
));
6497 if (!(bfd_set_start_address
6498 (link_info
.output_bfd
,
6499 bfd_get_section_vma (link_info
.output_bfd
, ts
))))
6500 einfo (_("%F%P: can't set start address\n"));
6505 einfo (_("%P: warning: cannot find entry symbol %s;"
6506 " not setting start address\n"),
6513 /* This is a small function used when we want to ignore errors from
6517 ignore_bfd_errors (const char *fmt ATTRIBUTE_UNUSED
,
6518 va_list ap ATTRIBUTE_UNUSED
)
6520 /* Don't do anything. */
6523 /* Check that the architecture of all the input files is compatible
6524 with the output file. Also call the backend to let it do any
6525 other checking that is needed. */
6530 lang_input_statement_type
*file
;
6532 const bfd_arch_info_type
*compatible
;
6534 for (file
= &file_chain
.head
->input_statement
;
6538 #ifdef ENABLE_PLUGINS
6539 /* Don't check format of files claimed by plugin. */
6540 if (file
->flags
.claimed
)
6542 #endif /* ENABLE_PLUGINS */
6543 input_bfd
= file
->the_bfd
;
6545 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
6546 command_line
.accept_unknown_input_arch
);
6548 /* In general it is not possible to perform a relocatable
6549 link between differing object formats when the input
6550 file has relocations, because the relocations in the
6551 input format may not have equivalent representations in
6552 the output format (and besides BFD does not translate
6553 relocs for other link purposes than a final link). */
6554 if ((bfd_link_relocatable (&link_info
)
6555 || link_info
.emitrelocations
)
6556 && (compatible
== NULL
6557 || (bfd_get_flavour (input_bfd
)
6558 != bfd_get_flavour (link_info
.output_bfd
)))
6559 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
6561 einfo (_("%F%P: relocatable linking with relocations from"
6562 " format %s (%pB) to format %s (%pB) is not supported\n"),
6563 bfd_get_target (input_bfd
), input_bfd
,
6564 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
6565 /* einfo with %F exits. */
6568 if (compatible
== NULL
)
6570 if (command_line
.warn_mismatch
)
6571 einfo (_("%X%P: %s architecture of input file `%pB'"
6572 " is incompatible with %s output\n"),
6573 bfd_printable_name (input_bfd
), input_bfd
,
6574 bfd_printable_name (link_info
.output_bfd
));
6576 else if (bfd_count_sections (input_bfd
))
6578 /* If the input bfd has no contents, it shouldn't set the
6579 private data of the output bfd. */
6581 bfd_error_handler_type pfn
= NULL
;
6583 /* If we aren't supposed to warn about mismatched input
6584 files, temporarily set the BFD error handler to a
6585 function which will do nothing. We still want to call
6586 bfd_merge_private_bfd_data, since it may set up
6587 information which is needed in the output file. */
6588 if (!command_line
.warn_mismatch
)
6589 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
6590 if (!bfd_merge_private_bfd_data (input_bfd
, &link_info
))
6592 if (command_line
.warn_mismatch
)
6593 einfo (_("%X%P: failed to merge target specific data"
6594 " of file %pB\n"), input_bfd
);
6596 if (!command_line
.warn_mismatch
)
6597 bfd_set_error_handler (pfn
);
6602 /* Look through all the global common symbols and attach them to the
6603 correct section. The -sort-common command line switch may be used
6604 to roughly sort the entries by alignment. */
6609 if (link_info
.inhibit_common_definition
)
6611 if (bfd_link_relocatable (&link_info
)
6612 && !command_line
.force_common_definition
)
6615 if (!config
.sort_common
)
6616 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
6621 if (config
.sort_common
== sort_descending
)
6623 for (power
= 4; power
> 0; power
--)
6624 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6627 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6631 for (power
= 0; power
<= 4; power
++)
6632 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6634 power
= (unsigned int) -1;
6635 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6640 /* Place one common symbol in the correct section. */
6643 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
6645 unsigned int power_of_two
;
6649 if (h
->type
!= bfd_link_hash_common
)
6653 power_of_two
= h
->u
.c
.p
->alignment_power
;
6655 if (config
.sort_common
== sort_descending
6656 && power_of_two
< *(unsigned int *) info
)
6658 else if (config
.sort_common
== sort_ascending
6659 && power_of_two
> *(unsigned int *) info
)
6662 section
= h
->u
.c
.p
->section
;
6663 if (!bfd_define_common_symbol (link_info
.output_bfd
, &link_info
, h
))
6664 einfo (_("%F%P: could not define common symbol `%pT': %E\n"),
6667 if (config
.map_file
!= NULL
)
6669 static bfd_boolean header_printed
;
6674 if (!header_printed
)
6676 minfo (_("\nAllocating common symbols\n"));
6677 minfo (_("Common symbol size file\n\n"));
6678 header_printed
= TRUE
;
6681 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
6682 DMGL_ANSI
| DMGL_PARAMS
);
6685 minfo ("%s", h
->root
.string
);
6686 len
= strlen (h
->root
.string
);
6691 len
= strlen (name
);
6707 if (size
<= 0xffffffff)
6708 sprintf (buf
, "%lx", (unsigned long) size
);
6710 sprintf_vma (buf
, size
);
6720 minfo ("%pB\n", section
->owner
);
6726 /* Handle a single orphan section S, placing the orphan into an appropriate
6727 output section. The effects of the --orphan-handling command line
6728 option are handled here. */
6731 ldlang_place_orphan (asection
*s
)
6733 if (config
.orphan_handling
== orphan_handling_discard
)
6735 lang_output_section_statement_type
*os
;
6736 os
= lang_output_section_statement_lookup (DISCARD_SECTION_NAME
, 0,
6738 if (os
->addr_tree
== NULL
6739 && (bfd_link_relocatable (&link_info
)
6740 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6741 os
->addr_tree
= exp_intop (0);
6742 lang_add_section (&os
->children
, s
, NULL
, os
);
6746 lang_output_section_statement_type
*os
;
6747 const char *name
= s
->name
;
6750 if (config
.orphan_handling
== orphan_handling_error
)
6751 einfo (_("%X%P: error: unplaced orphan section `%pA' from `%pB'\n"),
6754 if (config
.unique_orphan_sections
|| unique_section_p (s
, NULL
))
6755 constraint
= SPECIAL
;
6757 os
= ldemul_place_orphan (s
, name
, constraint
);
6760 os
= lang_output_section_statement_lookup (name
, constraint
, TRUE
);
6761 if (os
->addr_tree
== NULL
6762 && (bfd_link_relocatable (&link_info
)
6763 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6764 os
->addr_tree
= exp_intop (0);
6765 lang_add_section (&os
->children
, s
, NULL
, os
);
6768 if (config
.orphan_handling
== orphan_handling_warn
)
6769 einfo (_("%P: warning: orphan section `%pA' from `%pB' being "
6770 "placed in section `%s'\n"),
6771 s
, s
->owner
, os
->name
);
6775 /* Run through the input files and ensure that every input section has
6776 somewhere to go. If one is found without a destination then create
6777 an input request and place it into the statement tree. */
6780 lang_place_orphans (void)
6782 LANG_FOR_EACH_INPUT_STATEMENT (file
)
6786 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6788 if (s
->output_section
== NULL
)
6790 /* This section of the file is not attached, root
6791 around for a sensible place for it to go. */
6793 if (file
->flags
.just_syms
)
6794 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
6795 else if (lang_discard_section_p (s
))
6796 s
->output_section
= bfd_abs_section_ptr
;
6797 else if (strcmp (s
->name
, "COMMON") == 0)
6799 /* This is a lonely common section which must have
6800 come from an archive. We attach to the section
6801 with the wildcard. */
6802 if (!bfd_link_relocatable (&link_info
)
6803 || command_line
.force_common_definition
)
6805 if (default_common_section
== NULL
)
6806 default_common_section
6807 = lang_output_section_statement_lookup (".bss", 0,
6809 lang_add_section (&default_common_section
->children
, s
,
6810 NULL
, default_common_section
);
6814 ldlang_place_orphan (s
);
6821 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
6823 flagword
*ptr_flags
;
6825 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
6831 /* PR 17900: An exclamation mark in the attributes reverses
6832 the sense of any of the attributes that follow. */
6835 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
6839 *ptr_flags
|= SEC_ALLOC
;
6843 *ptr_flags
|= SEC_READONLY
;
6847 *ptr_flags
|= SEC_DATA
;
6851 *ptr_flags
|= SEC_CODE
;
6856 *ptr_flags
|= SEC_LOAD
;
6860 einfo (_("%F%P: invalid character %c (%d) in flags\n"),
6868 /* Call a function on each input file. This function will be called
6869 on an archive, but not on the elements. */
6872 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
6874 lang_input_statement_type
*f
;
6876 for (f
= &input_file_chain
.head
->input_statement
;
6878 f
= f
->next_real_file
)
6882 /* Call a function on each file. The function will be called on all
6883 the elements of an archive which are included in the link, but will
6884 not be called on the archive file itself. */
6887 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
6889 LANG_FOR_EACH_INPUT_STATEMENT (f
)
6896 ldlang_add_file (lang_input_statement_type
*entry
)
6898 lang_statement_append (&file_chain
, entry
, &entry
->next
);
6900 /* The BFD linker needs to have a list of all input BFDs involved in
6902 ASSERT (entry
->the_bfd
->link
.next
== NULL
);
6903 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
6905 *link_info
.input_bfds_tail
= entry
->the_bfd
;
6906 link_info
.input_bfds_tail
= &entry
->the_bfd
->link
.next
;
6907 entry
->the_bfd
->usrdata
= entry
;
6908 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
6910 /* Look through the sections and check for any which should not be
6911 included in the link. We need to do this now, so that we can
6912 notice when the backend linker tries to report multiple
6913 definition errors for symbols which are in sections we aren't
6914 going to link. FIXME: It might be better to entirely ignore
6915 symbols which are defined in sections which are going to be
6916 discarded. This would require modifying the backend linker for
6917 each backend which might set the SEC_LINK_ONCE flag. If we do
6918 this, we should probably handle SEC_EXCLUDE in the same way. */
6920 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
6924 lang_add_output (const char *name
, int from_script
)
6926 /* Make -o on command line override OUTPUT in script. */
6927 if (!had_output_filename
|| !from_script
)
6929 output_filename
= name
;
6930 had_output_filename
= TRUE
;
6934 lang_output_section_statement_type
*
6935 lang_enter_output_section_statement (const char *output_section_statement_name
,
6936 etree_type
*address_exp
,
6937 enum section_type sectype
,
6939 etree_type
*subalign
,
6942 int align_with_input
)
6944 lang_output_section_statement_type
*os
;
6946 os
= lang_output_section_statement_lookup (output_section_statement_name
,
6948 current_section
= os
;
6950 if (os
->addr_tree
== NULL
)
6952 os
->addr_tree
= address_exp
;
6954 os
->sectype
= sectype
;
6955 if (sectype
!= noload_section
)
6956 os
->flags
= SEC_NO_FLAGS
;
6958 os
->flags
= SEC_NEVER_LOAD
;
6959 os
->block_value
= 1;
6961 /* Make next things chain into subchain of this. */
6962 push_stat_ptr (&os
->children
);
6964 os
->align_lma_with_input
= align_with_input
== ALIGN_WITH_INPUT
;
6965 if (os
->align_lma_with_input
&& align
!= NULL
)
6966 einfo (_("%F%P:%pS: error: align with input and explicit align specified\n"),
6969 os
->subsection_alignment
= subalign
;
6970 os
->section_alignment
= align
;
6972 os
->load_base
= ebase
;
6979 lang_output_statement_type
*new_stmt
;
6981 new_stmt
= new_stat (lang_output_statement
, stat_ptr
);
6982 new_stmt
->name
= output_filename
;
6985 /* Reset the current counters in the regions. */
6988 lang_reset_memory_regions (void)
6990 lang_memory_region_type
*p
= lang_memory_region_list
;
6992 lang_output_section_statement_type
*os
;
6994 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
6996 p
->current
= p
->origin
;
7000 for (os
= &lang_os_list
.head
->output_section_statement
;
7004 os
->processed_vma
= FALSE
;
7005 os
->processed_lma
= FALSE
;
7008 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
7010 /* Save the last size for possible use by bfd_relax_section. */
7011 o
->rawsize
= o
->size
;
7012 if (!(o
->flags
& SEC_FIXED_SIZE
))
7017 /* Worker for lang_gc_sections_1. */
7020 gc_section_callback (lang_wild_statement_type
*ptr
,
7021 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7023 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
7024 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7025 void *data ATTRIBUTE_UNUSED
)
7027 /* If the wild pattern was marked KEEP, the member sections
7028 should be as well. */
7029 if (ptr
->keep_sections
)
7030 section
->flags
|= SEC_KEEP
;
7033 /* Iterate over sections marking them against GC. */
7036 lang_gc_sections_1 (lang_statement_union_type
*s
)
7038 for (; s
!= NULL
; s
= s
->header
.next
)
7040 switch (s
->header
.type
)
7042 case lang_wild_statement_enum
:
7043 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
7045 case lang_constructors_statement_enum
:
7046 lang_gc_sections_1 (constructor_list
.head
);
7048 case lang_output_section_statement_enum
:
7049 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
7051 case lang_group_statement_enum
:
7052 lang_gc_sections_1 (s
->group_statement
.children
.head
);
7061 lang_gc_sections (void)
7063 /* Keep all sections so marked in the link script. */
7064 lang_gc_sections_1 (statement_list
.head
);
7066 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
7067 the special case of debug info. (See bfd/stabs.c)
7068 Twiddle the flag here, to simplify later linker code. */
7069 if (bfd_link_relocatable (&link_info
))
7071 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7074 #ifdef ENABLE_PLUGINS
7075 if (f
->flags
.claimed
)
7078 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7079 if ((sec
->flags
& SEC_DEBUGGING
) == 0)
7080 sec
->flags
&= ~SEC_EXCLUDE
;
7084 if (link_info
.gc_sections
)
7085 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
7088 /* Worker for lang_find_relro_sections_1. */
7091 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
7092 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7094 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
7095 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7098 /* Discarded, excluded and ignored sections effectively have zero
7100 if (section
->output_section
!= NULL
7101 && section
->output_section
->owner
== link_info
.output_bfd
7102 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
7103 && !IGNORE_SECTION (section
)
7104 && section
->size
!= 0)
7106 bfd_boolean
*has_relro_section
= (bfd_boolean
*) data
;
7107 *has_relro_section
= TRUE
;
7111 /* Iterate over sections for relro sections. */
7114 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
7115 seg_align_type
*seg
,
7116 bfd_boolean
*has_relro_section
)
7118 if (*has_relro_section
)
7121 for (; s
!= NULL
; s
= s
->header
.next
)
7123 if (s
== seg
->relro_end_stat
)
7126 switch (s
->header
.type
)
7128 case lang_wild_statement_enum
:
7129 walk_wild (&s
->wild_statement
,
7130 find_relro_section_callback
,
7133 case lang_constructors_statement_enum
:
7134 lang_find_relro_sections_1 (constructor_list
.head
,
7135 seg
, has_relro_section
);
7137 case lang_output_section_statement_enum
:
7138 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
7139 seg
, has_relro_section
);
7141 case lang_group_statement_enum
:
7142 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
7143 seg
, has_relro_section
);
7152 lang_find_relro_sections (void)
7154 bfd_boolean has_relro_section
= FALSE
;
7156 /* Check all sections in the link script. */
7158 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
7159 &expld
.dataseg
, &has_relro_section
);
7161 if (!has_relro_section
)
7162 link_info
.relro
= FALSE
;
7165 /* Relax all sections until bfd_relax_section gives up. */
7168 lang_relax_sections (bfd_boolean need_layout
)
7170 if (RELAXATION_ENABLED
)
7172 /* We may need more than one relaxation pass. */
7173 int i
= link_info
.relax_pass
;
7175 /* The backend can use it to determine the current pass. */
7176 link_info
.relax_pass
= 0;
7180 /* Keep relaxing until bfd_relax_section gives up. */
7181 bfd_boolean relax_again
;
7183 link_info
.relax_trip
= -1;
7186 link_info
.relax_trip
++;
7188 /* Note: pe-dll.c does something like this also. If you find
7189 you need to change this code, you probably need to change
7190 pe-dll.c also. DJ */
7192 /* Do all the assignments with our current guesses as to
7194 lang_do_assignments (lang_assigning_phase_enum
);
7196 /* We must do this after lang_do_assignments, because it uses
7198 lang_reset_memory_regions ();
7200 /* Perform another relax pass - this time we know where the
7201 globals are, so can make a better guess. */
7202 relax_again
= FALSE
;
7203 lang_size_sections (&relax_again
, FALSE
);
7205 while (relax_again
);
7207 link_info
.relax_pass
++;
7214 /* Final extra sizing to report errors. */
7215 lang_do_assignments (lang_assigning_phase_enum
);
7216 lang_reset_memory_regions ();
7217 lang_size_sections (NULL
, TRUE
);
7221 #ifdef ENABLE_PLUGINS
7222 /* Find the insert point for the plugin's replacement files. We
7223 place them after the first claimed real object file, or if the
7224 first claimed object is an archive member, after the last real
7225 object file immediately preceding the archive. In the event
7226 no objects have been claimed at all, we return the first dummy
7227 object file on the list as the insert point; that works, but
7228 the callee must be careful when relinking the file_chain as it
7229 is not actually on that chain, only the statement_list and the
7230 input_file list; in that case, the replacement files must be
7231 inserted at the head of the file_chain. */
7233 static lang_input_statement_type
*
7234 find_replacements_insert_point (bfd_boolean
*before
)
7236 lang_input_statement_type
*claim1
, *lastobject
;
7237 lastobject
= &input_file_chain
.head
->input_statement
;
7238 for (claim1
= &file_chain
.head
->input_statement
;
7240 claim1
= claim1
->next
)
7242 if (claim1
->flags
.claimed
)
7244 *before
= claim1
->flags
.claim_archive
;
7245 return claim1
->flags
.claim_archive
? lastobject
: claim1
;
7247 /* Update lastobject if this is a real object file. */
7248 if (claim1
->the_bfd
!= NULL
&& claim1
->the_bfd
->my_archive
== NULL
)
7249 lastobject
= claim1
;
7251 /* No files were claimed by the plugin. Choose the last object
7252 file found on the list (maybe the first, dummy entry) as the
7258 /* Find where to insert ADD, an archive element or shared library
7259 added during a rescan. */
7261 static lang_input_statement_type
**
7262 find_rescan_insertion (lang_input_statement_type
*add
)
7264 bfd
*add_bfd
= add
->the_bfd
;
7265 lang_input_statement_type
*f
;
7266 lang_input_statement_type
*last_loaded
= NULL
;
7267 lang_input_statement_type
*before
= NULL
;
7268 lang_input_statement_type
**iter
= NULL
;
7270 if (add_bfd
->my_archive
!= NULL
)
7271 add_bfd
= add_bfd
->my_archive
;
7273 /* First look through the input file chain, to find an object file
7274 before the one we've rescanned. Normal object files always
7275 appear on both the input file chain and the file chain, so this
7276 lets us get quickly to somewhere near the correct place on the
7277 file chain if it is full of archive elements. Archives don't
7278 appear on the file chain, but if an element has been extracted
7279 then their input_statement->next points at it. */
7280 for (f
= &input_file_chain
.head
->input_statement
;
7282 f
= f
->next_real_file
)
7284 if (f
->the_bfd
== add_bfd
)
7286 before
= last_loaded
;
7287 if (f
->next
!= NULL
)
7288 return &f
->next
->next
;
7290 if (f
->the_bfd
!= NULL
&& f
->next
!= NULL
)
7294 for (iter
= before
? &before
->next
: &file_chain
.head
->input_statement
.next
;
7296 iter
= &(*iter
)->next
)
7297 if (!(*iter
)->flags
.claim_archive
7298 && (*iter
)->the_bfd
->my_archive
== NULL
)
7304 /* Insert SRCLIST into DESTLIST after given element by chaining
7305 on FIELD as the next-pointer. (Counterintuitively does not need
7306 a pointer to the actual after-node itself, just its chain field.) */
7309 lang_list_insert_after (lang_statement_list_type
*destlist
,
7310 lang_statement_list_type
*srclist
,
7311 lang_statement_union_type
**field
)
7313 *(srclist
->tail
) = *field
;
7314 *field
= srclist
->head
;
7315 if (destlist
->tail
== field
)
7316 destlist
->tail
= srclist
->tail
;
7319 /* Detach new nodes added to DESTLIST since the time ORIGLIST
7320 was taken as a copy of it and leave them in ORIGLIST. */
7323 lang_list_remove_tail (lang_statement_list_type
*destlist
,
7324 lang_statement_list_type
*origlist
)
7326 union lang_statement_union
**savetail
;
7327 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
7328 ASSERT (origlist
->head
== destlist
->head
);
7329 savetail
= origlist
->tail
;
7330 origlist
->head
= *(savetail
);
7331 origlist
->tail
= destlist
->tail
;
7332 destlist
->tail
= savetail
;
7336 static lang_statement_union_type
**
7337 find_next_input_statement (lang_statement_union_type
**s
)
7339 for ( ; *s
; s
= &(*s
)->header
.next
)
7341 lang_statement_union_type
**t
;
7342 switch ((*s
)->header
.type
)
7344 case lang_input_statement_enum
:
7346 case lang_wild_statement_enum
:
7347 t
= &(*s
)->wild_statement
.children
.head
;
7349 case lang_group_statement_enum
:
7350 t
= &(*s
)->group_statement
.children
.head
;
7352 case lang_output_section_statement_enum
:
7353 t
= &(*s
)->output_section_statement
.children
.head
;
7358 t
= find_next_input_statement (t
);
7364 #endif /* ENABLE_PLUGINS */
7366 /* Add NAME to the list of garbage collection entry points. */
7369 lang_add_gc_name (const char *name
)
7371 struct bfd_sym_chain
*sym
;
7376 sym
= (struct bfd_sym_chain
*) stat_alloc (sizeof (*sym
));
7378 sym
->next
= link_info
.gc_sym_list
;
7380 link_info
.gc_sym_list
= sym
;
7383 /* Check relocations. */
7386 lang_check_relocs (void)
7388 if (link_info
.check_relocs_after_open_input
)
7392 for (abfd
= link_info
.input_bfds
;
7393 abfd
!= (bfd
*) NULL
; abfd
= abfd
->link
.next
)
7394 if (!bfd_link_check_relocs (abfd
, &link_info
))
7396 /* No object output, fail return. */
7397 config
.make_executable
= FALSE
;
7398 /* Note: we do not abort the loop, but rather
7399 continue the scan in case there are other
7400 bad relocations to report. */
7405 /* Look through all output sections looking for places where we can
7406 propagate forward the lma region. */
7409 lang_propagate_lma_regions (void)
7411 lang_output_section_statement_type
*os
;
7413 for (os
= &lang_os_list
.head
->output_section_statement
;
7417 if (os
->prev
!= NULL
7418 && os
->lma_region
== NULL
7419 && os
->load_base
== NULL
7420 && os
->addr_tree
== NULL
7421 && os
->region
== os
->prev
->region
)
7422 os
->lma_region
= os
->prev
->lma_region
;
7429 /* Finalize dynamic list. */
7430 if (link_info
.dynamic_list
)
7431 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
7433 current_target
= default_target
;
7435 /* Open the output file. */
7436 lang_for_each_statement (ldlang_open_output
);
7439 ldemul_create_output_section_statements ();
7441 /* Add to the hash table all undefineds on the command line. */
7442 lang_place_undefineds ();
7444 if (!bfd_section_already_linked_table_init ())
7445 einfo (_("%F%P: can not create hash table: %E\n"));
7447 /* Create a bfd for each input file. */
7448 current_target
= default_target
;
7449 lang_statement_iteration
++;
7450 open_input_bfds (statement_list
.head
, OPEN_BFD_NORMAL
);
7451 /* open_input_bfds also handles assignments, so we can give values
7452 to symbolic origin/length now. */
7453 lang_do_memory_regions ();
7455 #ifdef ENABLE_PLUGINS
7456 if (link_info
.lto_plugin_active
)
7458 lang_statement_list_type added
;
7459 lang_statement_list_type files
, inputfiles
;
7461 /* Now all files are read, let the plugin(s) decide if there
7462 are any more to be added to the link before we call the
7463 emulation's after_open hook. We create a private list of
7464 input statements for this purpose, which we will eventually
7465 insert into the global statement list after the first claimed
7468 /* We need to manipulate all three chains in synchrony. */
7470 inputfiles
= input_file_chain
;
7471 if (plugin_call_all_symbols_read ())
7472 einfo (_("%F%P: %s: plugin reported error after all symbols read\n"),
7473 plugin_error_plugin ());
7474 /* Open any newly added files, updating the file chains. */
7475 plugin_undefs
= link_info
.hash
->undefs_tail
;
7476 open_input_bfds (*added
.tail
, OPEN_BFD_NORMAL
);
7477 if (plugin_undefs
== link_info
.hash
->undefs_tail
)
7478 plugin_undefs
= NULL
;
7479 /* Restore the global list pointer now they have all been added. */
7480 lang_list_remove_tail (stat_ptr
, &added
);
7481 /* And detach the fresh ends of the file lists. */
7482 lang_list_remove_tail (&file_chain
, &files
);
7483 lang_list_remove_tail (&input_file_chain
, &inputfiles
);
7484 /* Were any new files added? */
7485 if (added
.head
!= NULL
)
7487 /* If so, we will insert them into the statement list immediately
7488 after the first input file that was claimed by the plugin,
7489 unless that file was an archive in which case it is inserted
7490 immediately before. */
7492 lang_statement_union_type
**prev
;
7493 plugin_insert
= find_replacements_insert_point (&before
);
7494 /* If a plugin adds input files without having claimed any, we
7495 don't really have a good idea where to place them. Just putting
7496 them at the start or end of the list is liable to leave them
7497 outside the crtbegin...crtend range. */
7498 ASSERT (plugin_insert
!= NULL
);
7499 /* Splice the new statement list into the old one. */
7500 prev
= &plugin_insert
->header
.next
;
7503 prev
= find_next_input_statement (prev
);
7504 if (*prev
!= (void *) plugin_insert
->next_real_file
)
7506 /* Huh? We didn't find the expected input statement. */
7508 prev
= &plugin_insert
->header
.next
;
7511 lang_list_insert_after (stat_ptr
, &added
, prev
);
7512 /* Likewise for the file chains. */
7513 lang_list_insert_after (&input_file_chain
, &inputfiles
,
7514 (void *) &plugin_insert
->next_real_file
);
7515 /* We must be careful when relinking file_chain; we may need to
7516 insert the new files at the head of the list if the insert
7517 point chosen is the dummy first input file. */
7518 if (plugin_insert
->filename
)
7519 lang_list_insert_after (&file_chain
, &files
,
7520 (void *) &plugin_insert
->next
);
7522 lang_list_insert_after (&file_chain
, &files
, &file_chain
.head
);
7524 /* Rescan archives in case new undefined symbols have appeared. */
7526 lang_statement_iteration
++;
7527 open_input_bfds (statement_list
.head
, OPEN_BFD_RESCAN
);
7528 lang_list_remove_tail (&file_chain
, &files
);
7529 while (files
.head
!= NULL
)
7531 lang_input_statement_type
**insert
;
7532 lang_input_statement_type
**iter
, *temp
;
7535 insert
= find_rescan_insertion (&files
.head
->input_statement
);
7536 /* All elements from an archive can be added at once. */
7537 iter
= &files
.head
->input_statement
.next
;
7538 my_arch
= files
.head
->input_statement
.the_bfd
->my_archive
;
7539 if (my_arch
!= NULL
)
7540 for (; *iter
!= NULL
; iter
= &(*iter
)->next
)
7541 if ((*iter
)->the_bfd
->my_archive
!= my_arch
)
7544 *insert
= &files
.head
->input_statement
;
7545 files
.head
= (lang_statement_union_type
*) *iter
;
7547 if (my_arch
!= NULL
)
7549 lang_input_statement_type
*parent
= my_arch
->usrdata
;
7551 parent
->next
= (lang_input_statement_type
*)
7553 - offsetof (lang_input_statement_type
, next
));
7558 #endif /* ENABLE_PLUGINS */
7560 /* Make sure that nobody has tried to add a symbol to this list
7562 ASSERT (link_info
.gc_sym_list
== NULL
);
7564 link_info
.gc_sym_list
= &entry_symbol
;
7566 if (entry_symbol
.name
== NULL
)
7568 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
7570 /* entry_symbol is normally initialied by a ENTRY definition in the
7571 linker script or the -e command line option. But if neither of
7572 these have been used, the target specific backend may still have
7573 provided an entry symbol via a call to lang_default_entry().
7574 Unfortunately this value will not be processed until lang_end()
7575 is called, long after this function has finished. So detect this
7576 case here and add the target's entry symbol to the list of starting
7577 points for garbage collection resolution. */
7578 lang_add_gc_name (entry_symbol_default
);
7581 lang_add_gc_name (link_info
.init_function
);
7582 lang_add_gc_name (link_info
.fini_function
);
7584 ldemul_after_open ();
7585 if (config
.map_file
!= NULL
)
7586 lang_print_asneeded ();
7588 bfd_section_already_linked_table_free ();
7590 /* Make sure that we're not mixing architectures. We call this
7591 after all the input files have been opened, but before we do any
7592 other processing, so that any operations merge_private_bfd_data
7593 does on the output file will be known during the rest of the
7597 /* Handle .exports instead of a version script if we're told to do so. */
7598 if (command_line
.version_exports_section
)
7599 lang_do_version_exports_section ();
7601 /* Build all sets based on the information gathered from the input
7603 ldctor_build_sets ();
7605 /* Give initial values for __start and __stop symbols, so that ELF
7606 gc_sections will keep sections referenced by these symbols. Must
7607 be done before lang_do_assignments below. */
7608 if (config
.build_constructors
)
7609 lang_init_start_stop ();
7611 /* PR 13683: We must rerun the assignments prior to running garbage
7612 collection in order to make sure that all symbol aliases are resolved. */
7613 lang_do_assignments (lang_mark_phase_enum
);
7614 expld
.phase
= lang_first_phase_enum
;
7616 /* Size up the common data. */
7619 /* Remove unreferenced sections if asked to. */
7620 lang_gc_sections ();
7622 /* Check relocations. */
7623 lang_check_relocs ();
7625 ldemul_after_check_relocs ();
7627 /* Update wild statements. */
7628 update_wild_statements (statement_list
.head
);
7630 /* Run through the contours of the script and attach input sections
7631 to the correct output sections. */
7632 lang_statement_iteration
++;
7633 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
7635 /* Start at the statement immediately after the special abs_section
7636 output statement, so that it isn't reordered. */
7637 process_insert_statements (&lang_os_list
.head
->header
.next
);
7639 /* Find any sections not attached explicitly and handle them. */
7640 lang_place_orphans ();
7642 if (!bfd_link_relocatable (&link_info
))
7646 /* Merge SEC_MERGE sections. This has to be done after GC of
7647 sections, so that GCed sections are not merged, but before
7648 assigning dynamic symbols, since removing whole input sections
7650 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
7652 /* Look for a text section and set the readonly attribute in it. */
7653 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
7657 if (config
.text_read_only
)
7658 found
->flags
|= SEC_READONLY
;
7660 found
->flags
&= ~SEC_READONLY
;
7664 /* Copy forward lma regions for output sections in same lma region. */
7665 lang_propagate_lma_regions ();
7667 /* Defining __start/__stop symbols early for --gc-sections to work
7668 around a glibc build problem can result in these symbols being
7669 defined when they should not be. Fix them now. */
7670 if (config
.build_constructors
)
7671 lang_undef_start_stop ();
7673 /* Define .startof./.sizeof. symbols with preliminary values before
7674 dynamic symbols are created. */
7675 if (!bfd_link_relocatable (&link_info
))
7676 lang_init_startof_sizeof ();
7678 /* Do anything special before sizing sections. This is where ELF
7679 and other back-ends size dynamic sections. */
7680 ldemul_before_allocation ();
7682 /* We must record the program headers before we try to fix the
7683 section positions, since they will affect SIZEOF_HEADERS. */
7684 lang_record_phdrs ();
7686 /* Check relro sections. */
7687 if (link_info
.relro
&& !bfd_link_relocatable (&link_info
))
7688 lang_find_relro_sections ();
7690 /* Size up the sections. */
7691 lang_size_sections (NULL
, !RELAXATION_ENABLED
);
7693 /* See if anything special should be done now we know how big
7694 everything is. This is where relaxation is done. */
7695 ldemul_after_allocation ();
7697 /* Fix any __start, __stop, .startof. or .sizeof. symbols. */
7698 lang_finalize_start_stop ();
7700 /* Do all the assignments again, to report errors. Assignment
7701 statements are processed multiple times, updating symbols; In
7702 open_input_bfds, lang_do_assignments, and lang_size_sections.
7703 Since lang_relax_sections calls lang_do_assignments, symbols are
7704 also updated in ldemul_after_allocation. */
7705 lang_do_assignments (lang_final_phase_enum
);
7709 /* Convert absolute symbols to section relative. */
7710 ldexp_finalize_syms ();
7712 /* Make sure that the section addresses make sense. */
7713 if (command_line
.check_section_addresses
)
7714 lang_check_section_addresses ();
7716 /* Check any required symbols are known. */
7717 ldlang_check_require_defined_symbols ();
7722 /* EXPORTED TO YACC */
7725 lang_add_wild (struct wildcard_spec
*filespec
,
7726 struct wildcard_list
*section_list
,
7727 bfd_boolean keep_sections
)
7729 struct wildcard_list
*curr
, *next
;
7730 lang_wild_statement_type
*new_stmt
;
7732 /* Reverse the list as the parser puts it back to front. */
7733 for (curr
= section_list
, section_list
= NULL
;
7735 section_list
= curr
, curr
= next
)
7738 curr
->next
= section_list
;
7741 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
7743 if (strcmp (filespec
->name
, "*") == 0)
7744 filespec
->name
= NULL
;
7745 else if (!wildcardp (filespec
->name
))
7746 lang_has_input_file
= TRUE
;
7749 new_stmt
= new_stat (lang_wild_statement
, stat_ptr
);
7750 new_stmt
->filename
= NULL
;
7751 new_stmt
->filenames_sorted
= FALSE
;
7752 new_stmt
->section_flag_list
= NULL
;
7753 new_stmt
->exclude_name_list
= NULL
;
7754 if (filespec
!= NULL
)
7756 new_stmt
->filename
= filespec
->name
;
7757 new_stmt
->filenames_sorted
= filespec
->sorted
== by_name
;
7758 new_stmt
->section_flag_list
= filespec
->section_flag_list
;
7759 new_stmt
->exclude_name_list
= filespec
->exclude_name_list
;
7761 new_stmt
->section_list
= section_list
;
7762 new_stmt
->keep_sections
= keep_sections
;
7763 lang_list_init (&new_stmt
->children
);
7764 analyze_walk_wild_section_handler (new_stmt
);
7768 lang_section_start (const char *name
, etree_type
*address
,
7769 const segment_type
*segment
)
7771 lang_address_statement_type
*ad
;
7773 ad
= new_stat (lang_address_statement
, stat_ptr
);
7774 ad
->section_name
= name
;
7775 ad
->address
= address
;
7776 ad
->segment
= segment
;
7779 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
7780 because of a -e argument on the command line, or zero if this is
7781 called by ENTRY in a linker script. Command line arguments take
7785 lang_add_entry (const char *name
, bfd_boolean cmdline
)
7787 if (entry_symbol
.name
== NULL
7789 || !entry_from_cmdline
)
7791 entry_symbol
.name
= name
;
7792 entry_from_cmdline
= cmdline
;
7796 /* Set the default start symbol to NAME. .em files should use this,
7797 not lang_add_entry, to override the use of "start" if neither the
7798 linker script nor the command line specifies an entry point. NAME
7799 must be permanently allocated. */
7801 lang_default_entry (const char *name
)
7803 entry_symbol_default
= name
;
7807 lang_add_target (const char *name
)
7809 lang_target_statement_type
*new_stmt
;
7811 new_stmt
= new_stat (lang_target_statement
, stat_ptr
);
7812 new_stmt
->target
= name
;
7816 lang_add_map (const char *name
)
7823 map_option_f
= TRUE
;
7831 lang_add_fill (fill_type
*fill
)
7833 lang_fill_statement_type
*new_stmt
;
7835 new_stmt
= new_stat (lang_fill_statement
, stat_ptr
);
7836 new_stmt
->fill
= fill
;
7840 lang_add_data (int type
, union etree_union
*exp
)
7842 lang_data_statement_type
*new_stmt
;
7844 new_stmt
= new_stat (lang_data_statement
, stat_ptr
);
7845 new_stmt
->exp
= exp
;
7846 new_stmt
->type
= type
;
7849 /* Create a new reloc statement. RELOC is the BFD relocation type to
7850 generate. HOWTO is the corresponding howto structure (we could
7851 look this up, but the caller has already done so). SECTION is the
7852 section to generate a reloc against, or NAME is the name of the
7853 symbol to generate a reloc against. Exactly one of SECTION and
7854 NAME must be NULL. ADDEND is an expression for the addend. */
7857 lang_add_reloc (bfd_reloc_code_real_type reloc
,
7858 reloc_howto_type
*howto
,
7861 union etree_union
*addend
)
7863 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
7867 p
->section
= section
;
7869 p
->addend_exp
= addend
;
7871 p
->addend_value
= 0;
7872 p
->output_section
= NULL
;
7873 p
->output_offset
= 0;
7876 lang_assignment_statement_type
*
7877 lang_add_assignment (etree_type
*exp
)
7879 lang_assignment_statement_type
*new_stmt
;
7881 new_stmt
= new_stat (lang_assignment_statement
, stat_ptr
);
7882 new_stmt
->exp
= exp
;
7887 lang_add_attribute (enum statement_enum attribute
)
7889 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
7893 lang_startup (const char *name
)
7895 if (first_file
->filename
!= NULL
)
7897 einfo (_("%F%P: multiple STARTUP files\n"));
7899 first_file
->filename
= name
;
7900 first_file
->local_sym_name
= name
;
7901 first_file
->flags
.real
= TRUE
;
7905 lang_float (bfd_boolean maybe
)
7907 lang_float_flag
= maybe
;
7911 /* Work out the load- and run-time regions from a script statement, and
7912 store them in *LMA_REGION and *REGION respectively.
7914 MEMSPEC is the name of the run-time region, or the value of
7915 DEFAULT_MEMORY_REGION if the statement didn't specify one.
7916 LMA_MEMSPEC is the name of the load-time region, or null if the
7917 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
7918 had an explicit load address.
7920 It is an error to specify both a load region and a load address. */
7923 lang_get_regions (lang_memory_region_type
**region
,
7924 lang_memory_region_type
**lma_region
,
7925 const char *memspec
,
7926 const char *lma_memspec
,
7927 bfd_boolean have_lma
,
7928 bfd_boolean have_vma
)
7930 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
7932 /* If no runtime region or VMA has been specified, but the load region
7933 has been specified, then use the load region for the runtime region
7935 if (lma_memspec
!= NULL
7937 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
7938 *region
= *lma_region
;
7940 *region
= lang_memory_region_lookup (memspec
, FALSE
);
7942 if (have_lma
&& lma_memspec
!= 0)
7943 einfo (_("%X%P:%pS: section has both a load address and a load region\n"),
7948 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
7949 lang_output_section_phdr_list
*phdrs
,
7950 const char *lma_memspec
)
7952 lang_get_regions (¤t_section
->region
,
7953 ¤t_section
->lma_region
,
7954 memspec
, lma_memspec
,
7955 current_section
->load_base
!= NULL
,
7956 current_section
->addr_tree
!= NULL
);
7958 current_section
->fill
= fill
;
7959 current_section
->phdrs
= phdrs
;
7963 /* Set the output format type. -oformat overrides scripts. */
7966 lang_add_output_format (const char *format
,
7971 if (output_target
== NULL
|| !from_script
)
7973 if (command_line
.endian
== ENDIAN_BIG
7976 else if (command_line
.endian
== ENDIAN_LITTLE
7980 output_target
= format
;
7985 lang_add_insert (const char *where
, int is_before
)
7987 lang_insert_statement_type
*new_stmt
;
7989 new_stmt
= new_stat (lang_insert_statement
, stat_ptr
);
7990 new_stmt
->where
= where
;
7991 new_stmt
->is_before
= is_before
;
7992 saved_script_handle
= previous_script_handle
;
7995 /* Enter a group. This creates a new lang_group_statement, and sets
7996 stat_ptr to build new statements within the group. */
7999 lang_enter_group (void)
8001 lang_group_statement_type
*g
;
8003 g
= new_stat (lang_group_statement
, stat_ptr
);
8004 lang_list_init (&g
->children
);
8005 push_stat_ptr (&g
->children
);
8008 /* Leave a group. This just resets stat_ptr to start writing to the
8009 regular list of statements again. Note that this will not work if
8010 groups can occur inside anything else which can adjust stat_ptr,
8011 but currently they can't. */
8014 lang_leave_group (void)
8019 /* Add a new program header. This is called for each entry in a PHDRS
8020 command in a linker script. */
8023 lang_new_phdr (const char *name
,
8025 bfd_boolean filehdr
,
8030 struct lang_phdr
*n
, **pp
;
8033 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
8036 n
->type
= exp_get_vma (type
, 0, "program header type");
8037 n
->filehdr
= filehdr
;
8042 hdrs
= n
->type
== 1 && (phdrs
|| filehdr
);
8044 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
8047 && !((*pp
)->filehdr
|| (*pp
)->phdrs
))
8049 einfo (_("%X%P:%pS: PHDRS and FILEHDR are not supported"
8050 " when prior PT_LOAD headers lack them\n"), NULL
);
8057 /* Record the program header information in the output BFD. FIXME: We
8058 should not be calling an ELF specific function here. */
8061 lang_record_phdrs (void)
8065 lang_output_section_phdr_list
*last
;
8066 struct lang_phdr
*l
;
8067 lang_output_section_statement_type
*os
;
8070 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
8073 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
8080 for (os
= &lang_os_list
.head
->output_section_statement
;
8084 lang_output_section_phdr_list
*pl
;
8086 if (os
->constraint
< 0)
8094 if (os
->sectype
== noload_section
8095 || os
->bfd_section
== NULL
8096 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
8099 /* Don't add orphans to PT_INTERP header. */
8105 lang_output_section_statement_type
*tmp_os
;
8107 /* If we have not run across a section with a program
8108 header assigned to it yet, then scan forwards to find
8109 one. This prevents inconsistencies in the linker's
8110 behaviour when a script has specified just a single
8111 header and there are sections in that script which are
8112 not assigned to it, and which occur before the first
8113 use of that header. See here for more details:
8114 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
8115 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
8118 last
= tmp_os
->phdrs
;
8122 einfo (_("%F%P: no sections assigned to phdrs\n"));
8127 if (os
->bfd_section
== NULL
)
8130 for (; pl
!= NULL
; pl
= pl
->next
)
8132 if (strcmp (pl
->name
, l
->name
) == 0)
8137 secs
= (asection
**) xrealloc (secs
,
8138 alc
* sizeof (asection
*));
8140 secs
[c
] = os
->bfd_section
;
8147 if (l
->flags
== NULL
)
8150 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
8155 at
= exp_get_vma (l
->at
, 0, "phdr load address");
8157 if (!bfd_record_phdr (link_info
.output_bfd
, l
->type
,
8158 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
8159 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
8160 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
8165 /* Make sure all the phdr assignments succeeded. */
8166 for (os
= &lang_os_list
.head
->output_section_statement
;
8170 lang_output_section_phdr_list
*pl
;
8172 if (os
->constraint
< 0
8173 || os
->bfd_section
== NULL
)
8176 for (pl
= os
->phdrs
;
8179 if (!pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
8180 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
8181 os
->name
, pl
->name
);
8185 /* Record a list of sections which may not be cross referenced. */
8188 lang_add_nocrossref (lang_nocrossref_type
*l
)
8190 struct lang_nocrossrefs
*n
;
8192 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
8193 n
->next
= nocrossref_list
;
8195 n
->onlyfirst
= FALSE
;
8196 nocrossref_list
= n
;
8198 /* Set notice_all so that we get informed about all symbols. */
8199 link_info
.notice_all
= TRUE
;
8202 /* Record a section that cannot be referenced from a list of sections. */
8205 lang_add_nocrossref_to (lang_nocrossref_type
*l
)
8207 lang_add_nocrossref (l
);
8208 nocrossref_list
->onlyfirst
= TRUE
;
8211 /* Overlay handling. We handle overlays with some static variables. */
8213 /* The overlay virtual address. */
8214 static etree_type
*overlay_vma
;
8215 /* And subsection alignment. */
8216 static etree_type
*overlay_subalign
;
8218 /* An expression for the maximum section size seen so far. */
8219 static etree_type
*overlay_max
;
8221 /* A list of all the sections in this overlay. */
8223 struct overlay_list
{
8224 struct overlay_list
*next
;
8225 lang_output_section_statement_type
*os
;
8228 static struct overlay_list
*overlay_list
;
8230 /* Start handling an overlay. */
8233 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
8235 /* The grammar should prevent nested overlays from occurring. */
8236 ASSERT (overlay_vma
== NULL
8237 && overlay_subalign
== NULL
8238 && overlay_max
== NULL
);
8240 overlay_vma
= vma_expr
;
8241 overlay_subalign
= subalign
;
8244 /* Start a section in an overlay. We handle this by calling
8245 lang_enter_output_section_statement with the correct VMA.
8246 lang_leave_overlay sets up the LMA and memory regions. */
8249 lang_enter_overlay_section (const char *name
)
8251 struct overlay_list
*n
;
8254 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
8255 0, overlay_subalign
, 0, 0, 0);
8257 /* If this is the first section, then base the VMA of future
8258 sections on this one. This will work correctly even if `.' is
8259 used in the addresses. */
8260 if (overlay_list
== NULL
)
8261 overlay_vma
= exp_nameop (ADDR
, name
);
8263 /* Remember the section. */
8264 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
8265 n
->os
= current_section
;
8266 n
->next
= overlay_list
;
8269 size
= exp_nameop (SIZEOF
, name
);
8271 /* Arrange to work out the maximum section end address. */
8272 if (overlay_max
== NULL
)
8275 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
8278 /* Finish a section in an overlay. There isn't any special to do
8282 lang_leave_overlay_section (fill_type
*fill
,
8283 lang_output_section_phdr_list
*phdrs
)
8290 name
= current_section
->name
;
8292 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
8293 region and that no load-time region has been specified. It doesn't
8294 really matter what we say here, since lang_leave_overlay will
8296 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
8298 /* Define the magic symbols. */
8300 clean
= (char *) xmalloc (strlen (name
) + 1);
8302 for (s1
= name
; *s1
!= '\0'; s1
++)
8303 if (ISALNUM (*s1
) || *s1
== '_')
8307 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_start_");
8308 sprintf (buf
, "__load_start_%s", clean
);
8309 lang_add_assignment (exp_provide (buf
,
8310 exp_nameop (LOADADDR
, name
),
8313 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_stop_");
8314 sprintf (buf
, "__load_stop_%s", clean
);
8315 lang_add_assignment (exp_provide (buf
,
8317 exp_nameop (LOADADDR
, name
),
8318 exp_nameop (SIZEOF
, name
)),
8324 /* Finish an overlay. If there are any overlay wide settings, this
8325 looks through all the sections in the overlay and sets them. */
8328 lang_leave_overlay (etree_type
*lma_expr
,
8331 const char *memspec
,
8332 lang_output_section_phdr_list
*phdrs
,
8333 const char *lma_memspec
)
8335 lang_memory_region_type
*region
;
8336 lang_memory_region_type
*lma_region
;
8337 struct overlay_list
*l
;
8338 lang_nocrossref_type
*nocrossref
;
8340 lang_get_regions (®ion
, &lma_region
,
8341 memspec
, lma_memspec
,
8342 lma_expr
!= NULL
, FALSE
);
8346 /* After setting the size of the last section, set '.' to end of the
8348 if (overlay_list
!= NULL
)
8350 overlay_list
->os
->update_dot
= 1;
8351 overlay_list
->os
->update_dot_tree
8352 = exp_assign (".", exp_binop ('+', overlay_vma
, overlay_max
), FALSE
);
8358 struct overlay_list
*next
;
8360 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
8363 l
->os
->region
= region
;
8364 l
->os
->lma_region
= lma_region
;
8366 /* The first section has the load address specified in the
8367 OVERLAY statement. The rest are worked out from that.
8368 The base address is not needed (and should be null) if
8369 an LMA region was specified. */
8372 l
->os
->load_base
= lma_expr
;
8373 l
->os
->sectype
= first_overlay_section
;
8375 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
8376 l
->os
->phdrs
= phdrs
;
8380 lang_nocrossref_type
*nc
;
8382 nc
= (lang_nocrossref_type
*) xmalloc (sizeof *nc
);
8383 nc
->name
= l
->os
->name
;
8384 nc
->next
= nocrossref
;
8393 if (nocrossref
!= NULL
)
8394 lang_add_nocrossref (nocrossref
);
8397 overlay_list
= NULL
;
8399 overlay_subalign
= NULL
;
8402 /* Version handling. This is only useful for ELF. */
8404 /* If PREV is NULL, return first version pattern matching particular symbol.
8405 If PREV is non-NULL, return first version pattern matching particular
8406 symbol after PREV (previously returned by lang_vers_match). */
8408 static struct bfd_elf_version_expr
*
8409 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
8410 struct bfd_elf_version_expr
*prev
,
8414 const char *cxx_sym
= sym
;
8415 const char *java_sym
= sym
;
8416 struct bfd_elf_version_expr
*expr
= NULL
;
8417 enum demangling_styles curr_style
;
8419 curr_style
= CURRENT_DEMANGLING_STYLE
;
8420 cplus_demangle_set_style (no_demangling
);
8421 c_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_NO_OPTS
);
8424 cplus_demangle_set_style (curr_style
);
8426 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8428 cxx_sym
= bfd_demangle (link_info
.output_bfd
, sym
,
8429 DMGL_PARAMS
| DMGL_ANSI
);
8433 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8435 java_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_JAVA
);
8440 if (head
->htab
&& (prev
== NULL
|| prev
->literal
))
8442 struct bfd_elf_version_expr e
;
8444 switch (prev
? prev
->mask
: 0)
8447 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
8450 expr
= (struct bfd_elf_version_expr
*)
8451 htab_find ((htab_t
) head
->htab
, &e
);
8452 while (expr
&& strcmp (expr
->pattern
, c_sym
) == 0)
8453 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
8459 case BFD_ELF_VERSION_C_TYPE
:
8460 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8462 e
.pattern
= cxx_sym
;
8463 expr
= (struct bfd_elf_version_expr
*)
8464 htab_find ((htab_t
) head
->htab
, &e
);
8465 while (expr
&& strcmp (expr
->pattern
, cxx_sym
) == 0)
8466 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
8472 case BFD_ELF_VERSION_CXX_TYPE
:
8473 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8475 e
.pattern
= java_sym
;
8476 expr
= (struct bfd_elf_version_expr
*)
8477 htab_find ((htab_t
) head
->htab
, &e
);
8478 while (expr
&& strcmp (expr
->pattern
, java_sym
) == 0)
8479 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8490 /* Finally, try the wildcards. */
8491 if (prev
== NULL
|| prev
->literal
)
8492 expr
= head
->remaining
;
8495 for (; expr
; expr
= expr
->next
)
8502 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
8505 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8507 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
8511 if (fnmatch (expr
->pattern
, s
, 0) == 0)
8517 free ((char *) c_sym
);
8519 free ((char *) cxx_sym
);
8520 if (java_sym
!= sym
)
8521 free ((char *) java_sym
);
8525 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
8526 return a pointer to the symbol name with any backslash quotes removed. */
8529 realsymbol (const char *pattern
)
8532 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
8533 char *s
, *symbol
= (char *) xmalloc (strlen (pattern
) + 1);
8535 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
8537 /* It is a glob pattern only if there is no preceding
8541 /* Remove the preceding backslash. */
8548 if (*p
== '?' || *p
== '*' || *p
== '[')
8555 backslash
= *p
== '\\';
8571 /* This is called for each variable name or match expression. NEW_NAME is
8572 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
8573 pattern to be matched against symbol names. */
8575 struct bfd_elf_version_expr
*
8576 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
8577 const char *new_name
,
8579 bfd_boolean literal_p
)
8581 struct bfd_elf_version_expr
*ret
;
8583 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
8587 ret
->literal
= TRUE
;
8588 ret
->pattern
= literal_p
? new_name
: realsymbol (new_name
);
8589 if (ret
->pattern
== NULL
)
8591 ret
->pattern
= new_name
;
8592 ret
->literal
= FALSE
;
8595 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
8596 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
8597 else if (strcasecmp (lang
, "C++") == 0)
8598 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
8599 else if (strcasecmp (lang
, "Java") == 0)
8600 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
8603 einfo (_("%X%P: unknown language `%s' in version information\n"),
8605 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
8608 return ldemul_new_vers_pattern (ret
);
8611 /* This is called for each set of variable names and match
8614 struct bfd_elf_version_tree
*
8615 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
8616 struct bfd_elf_version_expr
*locals
)
8618 struct bfd_elf_version_tree
*ret
;
8620 ret
= (struct bfd_elf_version_tree
*) xcalloc (1, sizeof *ret
);
8621 ret
->globals
.list
= globals
;
8622 ret
->locals
.list
= locals
;
8623 ret
->match
= lang_vers_match
;
8624 ret
->name_indx
= (unsigned int) -1;
8628 /* This static variable keeps track of version indices. */
8630 static int version_index
;
8633 version_expr_head_hash (const void *p
)
8635 const struct bfd_elf_version_expr
*e
=
8636 (const struct bfd_elf_version_expr
*) p
;
8638 return htab_hash_string (e
->pattern
);
8642 version_expr_head_eq (const void *p1
, const void *p2
)
8644 const struct bfd_elf_version_expr
*e1
=
8645 (const struct bfd_elf_version_expr
*) p1
;
8646 const struct bfd_elf_version_expr
*e2
=
8647 (const struct bfd_elf_version_expr
*) p2
;
8649 return strcmp (e1
->pattern
, e2
->pattern
) == 0;
8653 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
8656 struct bfd_elf_version_expr
*e
, *next
;
8657 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
8659 for (e
= head
->list
; e
; e
= e
->next
)
8663 head
->mask
|= e
->mask
;
8668 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
8669 version_expr_head_eq
, NULL
);
8670 list_loc
= &head
->list
;
8671 remaining_loc
= &head
->remaining
;
8672 for (e
= head
->list
; e
; e
= next
)
8678 remaining_loc
= &e
->next
;
8682 void **loc
= htab_find_slot ((htab_t
) head
->htab
, e
, INSERT
);
8686 struct bfd_elf_version_expr
*e1
, *last
;
8688 e1
= (struct bfd_elf_version_expr
*) *loc
;
8692 if (e1
->mask
== e
->mask
)
8700 while (e1
&& strcmp (e1
->pattern
, e
->pattern
) == 0);
8704 /* This is a duplicate. */
8705 /* FIXME: Memory leak. Sometimes pattern is not
8706 xmalloced alone, but in larger chunk of memory. */
8707 /* free (e->pattern); */
8712 e
->next
= last
->next
;
8720 list_loc
= &e
->next
;
8724 *remaining_loc
= NULL
;
8725 *list_loc
= head
->remaining
;
8728 head
->remaining
= head
->list
;
8731 /* This is called when we know the name and dependencies of the
8735 lang_register_vers_node (const char *name
,
8736 struct bfd_elf_version_tree
*version
,
8737 struct bfd_elf_version_deps
*deps
)
8739 struct bfd_elf_version_tree
*t
, **pp
;
8740 struct bfd_elf_version_expr
*e1
;
8745 if (link_info
.version_info
!= NULL
8746 && (name
[0] == '\0' || link_info
.version_info
->name
[0] == '\0'))
8748 einfo (_("%X%P: anonymous version tag cannot be combined"
8749 " with other version tags\n"));
8754 /* Make sure this node has a unique name. */
8755 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8756 if (strcmp (t
->name
, name
) == 0)
8757 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
8759 lang_finalize_version_expr_head (&version
->globals
);
8760 lang_finalize_version_expr_head (&version
->locals
);
8762 /* Check the global and local match names, and make sure there
8763 aren't any duplicates. */
8765 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
8767 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8769 struct bfd_elf_version_expr
*e2
;
8771 if (t
->locals
.htab
&& e1
->literal
)
8773 e2
= (struct bfd_elf_version_expr
*)
8774 htab_find ((htab_t
) t
->locals
.htab
, e1
);
8775 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
8777 if (e1
->mask
== e2
->mask
)
8778 einfo (_("%X%P: duplicate expression `%s'"
8779 " in version information\n"), e1
->pattern
);
8783 else if (!e1
->literal
)
8784 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
8785 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
8786 && e1
->mask
== e2
->mask
)
8787 einfo (_("%X%P: duplicate expression `%s'"
8788 " in version information\n"), e1
->pattern
);
8792 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
8794 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8796 struct bfd_elf_version_expr
*e2
;
8798 if (t
->globals
.htab
&& e1
->literal
)
8800 e2
= (struct bfd_elf_version_expr
*)
8801 htab_find ((htab_t
) t
->globals
.htab
, e1
);
8802 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
8804 if (e1
->mask
== e2
->mask
)
8805 einfo (_("%X%P: duplicate expression `%s'"
8806 " in version information\n"),
8811 else if (!e1
->literal
)
8812 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
8813 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
8814 && e1
->mask
== e2
->mask
)
8815 einfo (_("%X%P: duplicate expression `%s'"
8816 " in version information\n"), e1
->pattern
);
8820 version
->deps
= deps
;
8821 version
->name
= name
;
8822 if (name
[0] != '\0')
8825 version
->vernum
= version_index
;
8828 version
->vernum
= 0;
8830 for (pp
= &link_info
.version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
8835 /* This is called when we see a version dependency. */
8837 struct bfd_elf_version_deps
*
8838 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
8840 struct bfd_elf_version_deps
*ret
;
8841 struct bfd_elf_version_tree
*t
;
8843 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
8846 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8848 if (strcmp (t
->name
, name
) == 0)
8850 ret
->version_needed
= t
;
8855 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
8857 ret
->version_needed
= NULL
;
8862 lang_do_version_exports_section (void)
8864 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
8866 LANG_FOR_EACH_INPUT_STATEMENT (is
)
8868 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
8876 contents
= (char *) xmalloc (len
);
8877 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
8878 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
8881 while (p
< contents
+ len
)
8883 greg
= lang_new_vers_pattern (greg
, p
, NULL
, FALSE
);
8884 p
= strchr (p
, '\0') + 1;
8887 /* Do not free the contents, as we used them creating the regex. */
8889 /* Do not include this section in the link. */
8890 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
8893 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, FALSE
);
8894 lang_register_vers_node (command_line
.version_exports_section
,
8895 lang_new_vers_node (greg
, lreg
), NULL
);
8898 /* Evaluate LENGTH and ORIGIN parts of MEMORY spec */
8901 lang_do_memory_regions (void)
8903 lang_memory_region_type
*r
= lang_memory_region_list
;
8905 for (; r
!= NULL
; r
= r
->next
)
8909 exp_fold_tree_no_dot (r
->origin_exp
);
8910 if (expld
.result
.valid_p
)
8912 r
->origin
= expld
.result
.value
;
8913 r
->current
= r
->origin
;
8916 einfo (_("%F%P: invalid origin for memory region %s\n"),
8921 exp_fold_tree_no_dot (r
->length_exp
);
8922 if (expld
.result
.valid_p
)
8923 r
->length
= expld
.result
.value
;
8925 einfo (_("%F%P: invalid length for memory region %s\n"),
8932 lang_add_unique (const char *name
)
8934 struct unique_sections
*ent
;
8936 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
8937 if (strcmp (ent
->name
, name
) == 0)
8940 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
8941 ent
->name
= xstrdup (name
);
8942 ent
->next
= unique_section_list
;
8943 unique_section_list
= ent
;
8946 /* Append the list of dynamic symbols to the existing one. */
8949 lang_append_dynamic_list (struct bfd_elf_version_expr
*dynamic
)
8951 if (link_info
.dynamic_list
)
8953 struct bfd_elf_version_expr
*tail
;
8954 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
8956 tail
->next
= link_info
.dynamic_list
->head
.list
;
8957 link_info
.dynamic_list
->head
.list
= dynamic
;
8961 struct bfd_elf_dynamic_list
*d
;
8963 d
= (struct bfd_elf_dynamic_list
*) xcalloc (1, sizeof *d
);
8964 d
->head
.list
= dynamic
;
8965 d
->match
= lang_vers_match
;
8966 link_info
.dynamic_list
= d
;
8970 /* Append the list of C++ typeinfo dynamic symbols to the existing
8974 lang_append_dynamic_list_cpp_typeinfo (void)
8976 const char *symbols
[] =
8978 "typeinfo name for*",
8981 struct bfd_elf_version_expr
*dynamic
= NULL
;
8984 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
8985 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
8988 lang_append_dynamic_list (dynamic
);
8991 /* Append the list of C++ operator new and delete dynamic symbols to the
8995 lang_append_dynamic_list_cpp_new (void)
8997 const char *symbols
[] =
9002 struct bfd_elf_version_expr
*dynamic
= NULL
;
9005 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9006 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9009 lang_append_dynamic_list (dynamic
);
9012 /* Scan a space and/or comma separated string of features. */
9015 lang_ld_feature (char *str
)
9023 while (*p
== ',' || ISSPACE (*p
))
9028 while (*q
&& *q
!= ',' && !ISSPACE (*q
))
9032 if (strcasecmp (p
, "SANE_EXPR") == 0)
9033 config
.sane_expr
= TRUE
;
9035 einfo (_("%X%P: unknown feature `%s'\n"), p
);
9041 /* Pretty print memory amount. */
9044 lang_print_memory_size (bfd_vma sz
)
9046 if ((sz
& 0x3fffffff) == 0)
9047 printf ("%10" BFD_VMA_FMT
"u GB", sz
>> 30);
9048 else if ((sz
& 0xfffff) == 0)
9049 printf ("%10" BFD_VMA_FMT
"u MB", sz
>> 20);
9050 else if ((sz
& 0x3ff) == 0)
9051 printf ("%10" BFD_VMA_FMT
"u KB", sz
>> 10);
9053 printf (" %10" BFD_VMA_FMT
"u B", sz
);
9056 /* Implement --print-memory-usage: disply per region memory usage. */
9059 lang_print_memory_usage (void)
9061 lang_memory_region_type
*r
;
9063 printf ("Memory region Used Size Region Size %%age Used\n");
9064 for (r
= lang_memory_region_list
; r
->next
!= NULL
; r
= r
->next
)
9066 bfd_vma used_length
= r
->current
- r
->origin
;
9069 printf ("%16s: ",r
->name_list
.name
);
9070 lang_print_memory_size (used_length
);
9071 lang_print_memory_size ((bfd_vma
) r
->length
);
9073 percent
= used_length
* 100.0 / r
->length
;
9075 printf (" %6.2f%%\n", percent
);