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
= 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
,
1085 lang_input_statement_type
*p
;
1087 lang_has_input_file
= TRUE
;
1089 p
= new_stat (lang_input_statement
, stat_ptr
);
1090 memset (&p
->the_bfd
, 0,
1091 sizeof (*p
) - offsetof (lang_input_statement_type
, the_bfd
));
1093 p
->flags
.dynamic
= input_flags
.dynamic
;
1094 p
->flags
.add_DT_NEEDED_for_dynamic
= input_flags
.add_DT_NEEDED_for_dynamic
;
1095 p
->flags
.add_DT_NEEDED_for_regular
= input_flags
.add_DT_NEEDED_for_regular
;
1096 p
->flags
.whole_archive
= input_flags
.whole_archive
;
1097 p
->flags
.sysrooted
= input_flags
.sysrooted
;
1101 case lang_input_file_is_symbols_only_enum
:
1103 p
->local_sym_name
= name
;
1104 p
->flags
.real
= TRUE
;
1105 p
->flags
.just_syms
= TRUE
;
1107 case lang_input_file_is_fake_enum
:
1109 p
->local_sym_name
= name
;
1111 case lang_input_file_is_l_enum
:
1112 if (name
[0] == ':' && name
[1] != '\0')
1114 p
->filename
= name
+ 1;
1115 p
->flags
.full_name_provided
= TRUE
;
1119 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
1120 p
->flags
.maybe_archive
= TRUE
;
1121 p
->flags
.real
= TRUE
;
1122 p
->flags
.search_dirs
= TRUE
;
1124 case lang_input_file_is_marker_enum
:
1126 p
->local_sym_name
= name
;
1127 p
->flags
.search_dirs
= TRUE
;
1129 case lang_input_file_is_search_file_enum
:
1131 p
->local_sym_name
= name
;
1132 p
->flags
.real
= TRUE
;
1133 p
->flags
.search_dirs
= TRUE
;
1135 case lang_input_file_is_file_enum
:
1137 p
->local_sym_name
= name
;
1138 p
->flags
.real
= TRUE
;
1144 lang_statement_append (&input_file_chain
, p
, &p
->next_real_file
);
1148 lang_input_statement_type
*
1149 lang_add_input_file (const char *name
,
1150 lang_input_file_enum_type file_type
,
1154 && (*name
== '=' || CONST_STRNEQ (name
, "$SYSROOT")))
1156 lang_input_statement_type
*ret
;
1157 char *sysrooted_name
1158 = concat (ld_sysroot
,
1159 name
+ (*name
== '=' ? 1 : strlen ("$SYSROOT")),
1160 (const char *) NULL
);
1162 /* We've now forcibly prepended the sysroot, making the input
1163 file independent of the context. Therefore, temporarily
1164 force a non-sysrooted context for this statement, so it won't
1165 get the sysroot prepended again when opened. (N.B. if it's a
1166 script, any child nodes with input files starting with "/"
1167 will be handled as "sysrooted" as they'll be found to be
1168 within the sysroot subdirectory.) */
1169 unsigned int outer_sysrooted
= input_flags
.sysrooted
;
1170 input_flags
.sysrooted
= 0;
1171 ret
= new_afile (sysrooted_name
, file_type
, target
);
1172 input_flags
.sysrooted
= outer_sysrooted
;
1176 return new_afile (name
, file_type
, target
);
1179 struct out_section_hash_entry
1181 struct bfd_hash_entry root
;
1182 lang_statement_union_type s
;
1185 /* The hash table. */
1187 static struct bfd_hash_table output_section_statement_table
;
1189 /* Support routines for the hash table used by lang_output_section_find,
1190 initialize the table, fill in an entry and remove the table. */
1192 static struct bfd_hash_entry
*
1193 output_section_statement_newfunc (struct bfd_hash_entry
*entry
,
1194 struct bfd_hash_table
*table
,
1197 lang_output_section_statement_type
**nextp
;
1198 struct out_section_hash_entry
*ret
;
1202 entry
= (struct bfd_hash_entry
*) bfd_hash_allocate (table
,
1208 entry
= bfd_hash_newfunc (entry
, table
, string
);
1212 ret
= (struct out_section_hash_entry
*) entry
;
1213 memset (&ret
->s
, 0, sizeof (ret
->s
));
1214 ret
->s
.header
.type
= lang_output_section_statement_enum
;
1215 ret
->s
.output_section_statement
.subsection_alignment
= NULL
;
1216 ret
->s
.output_section_statement
.section_alignment
= NULL
;
1217 ret
->s
.output_section_statement
.block_value
= 1;
1218 lang_list_init (&ret
->s
.output_section_statement
.children
);
1219 lang_statement_append (stat_ptr
, &ret
->s
, &ret
->s
.header
.next
);
1221 /* For every output section statement added to the list, except the
1222 first one, lang_os_list.tail points to the "next"
1223 field of the last element of the list. */
1224 if (lang_os_list
.head
!= NULL
)
1225 ret
->s
.output_section_statement
.prev
1226 = ((lang_output_section_statement_type
*)
1227 ((char *) lang_os_list
.tail
1228 - offsetof (lang_output_section_statement_type
, next
)));
1230 /* GCC's strict aliasing rules prevent us from just casting the
1231 address, so we store the pointer in a variable and cast that
1233 nextp
= &ret
->s
.output_section_statement
.next
;
1234 lang_statement_append (&lang_os_list
, &ret
->s
, nextp
);
1239 output_section_statement_table_init (void)
1241 if (!bfd_hash_table_init_n (&output_section_statement_table
,
1242 output_section_statement_newfunc
,
1243 sizeof (struct out_section_hash_entry
),
1245 einfo (_("%F%P: can not create hash table: %E\n"));
1249 output_section_statement_table_free (void)
1251 bfd_hash_table_free (&output_section_statement_table
);
1254 /* Build enough state so that the parser can build its tree. */
1259 obstack_begin (&stat_obstack
, 1000);
1261 stat_ptr
= &statement_list
;
1263 output_section_statement_table_init ();
1265 lang_list_init (stat_ptr
);
1267 lang_list_init (&input_file_chain
);
1268 lang_list_init (&lang_os_list
);
1269 lang_list_init (&file_chain
);
1270 first_file
= lang_add_input_file (NULL
, lang_input_file_is_marker_enum
,
1272 abs_output_section
=
1273 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
, 0, TRUE
);
1275 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
1277 asneeded_list_head
= NULL
;
1278 asneeded_list_tail
= &asneeded_list_head
;
1284 output_section_statement_table_free ();
1287 /*----------------------------------------------------------------------
1288 A region is an area of memory declared with the
1289 MEMORY { name:org=exp, len=exp ... }
1292 We maintain a list of all the regions here.
1294 If no regions are specified in the script, then the default is used
1295 which is created when looked up to be the entire data space.
1297 If create is true we are creating a region inside a MEMORY block.
1298 In this case it is probably an error to create a region that has
1299 already been created. If we are not inside a MEMORY block it is
1300 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1301 and so we issue a warning.
1303 Each region has at least one name. The first name is either
1304 DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add
1305 alias names to an existing region within a script with
1306 REGION_ALIAS (alias, region_name). Each name corresponds to at most one
1309 static lang_memory_region_type
*lang_memory_region_list
;
1310 static lang_memory_region_type
**lang_memory_region_list_tail
1311 = &lang_memory_region_list
;
1313 lang_memory_region_type
*
1314 lang_memory_region_lookup (const char *const name
, bfd_boolean create
)
1316 lang_memory_region_name
*n
;
1317 lang_memory_region_type
*r
;
1318 lang_memory_region_type
*new_region
;
1320 /* NAME is NULL for LMA memspecs if no region was specified. */
1324 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1325 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1326 if (strcmp (n
->name
, name
) == 0)
1329 einfo (_("%P:%pS: warning: redeclaration of memory region `%s'\n"),
1334 if (!create
&& strcmp (name
, DEFAULT_MEMORY_REGION
))
1335 einfo (_("%P:%pS: warning: memory region `%s' not declared\n"),
1338 new_region
= stat_alloc (sizeof (lang_memory_region_type
));
1340 new_region
->name_list
.name
= xstrdup (name
);
1341 new_region
->name_list
.next
= NULL
;
1342 new_region
->next
= NULL
;
1343 new_region
->origin_exp
= NULL
;
1344 new_region
->origin
= 0;
1345 new_region
->length_exp
= NULL
;
1346 new_region
->length
= ~(bfd_size_type
) 0;
1347 new_region
->current
= 0;
1348 new_region
->last_os
= NULL
;
1349 new_region
->flags
= 0;
1350 new_region
->not_flags
= 0;
1351 new_region
->had_full_message
= FALSE
;
1353 *lang_memory_region_list_tail
= new_region
;
1354 lang_memory_region_list_tail
= &new_region
->next
;
1360 lang_memory_region_alias (const char *alias
, const char *region_name
)
1362 lang_memory_region_name
*n
;
1363 lang_memory_region_type
*r
;
1364 lang_memory_region_type
*region
;
1366 /* The default region must be unique. This ensures that it is not necessary
1367 to iterate through the name list if someone wants the check if a region is
1368 the default memory region. */
1369 if (strcmp (region_name
, DEFAULT_MEMORY_REGION
) == 0
1370 || strcmp (alias
, DEFAULT_MEMORY_REGION
) == 0)
1371 einfo (_("%F%P:%pS: error: alias for default memory region\n"), NULL
);
1373 /* Look for the target region and check if the alias is not already
1376 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1377 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1379 if (region
== NULL
&& strcmp (n
->name
, region_name
) == 0)
1381 if (strcmp (n
->name
, alias
) == 0)
1382 einfo (_("%F%P:%pS: error: redefinition of memory region "
1387 /* Check if the target region exists. */
1389 einfo (_("%F%P:%pS: error: memory region `%s' "
1390 "for alias `%s' does not exist\n"),
1391 NULL
, region_name
, alias
);
1393 /* Add alias to region name list. */
1394 n
= stat_alloc (sizeof (lang_memory_region_name
));
1395 n
->name
= xstrdup (alias
);
1396 n
->next
= region
->name_list
.next
;
1397 region
->name_list
.next
= n
;
1400 static lang_memory_region_type
*
1401 lang_memory_default (asection
*section
)
1403 lang_memory_region_type
*p
;
1405 flagword sec_flags
= section
->flags
;
1407 /* Override SEC_DATA to mean a writable section. */
1408 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
1409 sec_flags
|= SEC_DATA
;
1411 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
1413 if ((p
->flags
& sec_flags
) != 0
1414 && (p
->not_flags
& sec_flags
) == 0)
1419 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
1422 /* Get the output section statement directly from the userdata. */
1424 lang_output_section_statement_type
*
1425 lang_output_section_get (const asection
*output_section
)
1427 return get_userdata (output_section
);
1430 /* Find or create an output_section_statement with the given NAME.
1431 If CONSTRAINT is non-zero match one with that constraint, otherwise
1432 match any non-negative constraint. If CREATE, always make a
1433 new output_section_statement for SPECIAL CONSTRAINT. */
1435 lang_output_section_statement_type
*
1436 lang_output_section_statement_lookup (const char *name
,
1440 struct out_section_hash_entry
*entry
;
1442 entry
= ((struct out_section_hash_entry
*)
1443 bfd_hash_lookup (&output_section_statement_table
, name
,
1448 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1452 if (entry
->s
.output_section_statement
.name
!= NULL
)
1454 /* We have a section of this name, but it might not have the correct
1456 struct out_section_hash_entry
*last_ent
;
1458 name
= entry
->s
.output_section_statement
.name
;
1459 if (create
&& constraint
== SPECIAL
)
1460 /* Not traversing to the end reverses the order of the second
1461 and subsequent SPECIAL sections in the hash table chain,
1462 but that shouldn't matter. */
1467 if (constraint
== entry
->s
.output_section_statement
.constraint
1469 && entry
->s
.output_section_statement
.constraint
>= 0))
1470 return &entry
->s
.output_section_statement
;
1472 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1474 while (entry
!= NULL
1475 && name
== entry
->s
.output_section_statement
.name
);
1481 = ((struct out_section_hash_entry
*)
1482 output_section_statement_newfunc (NULL
,
1483 &output_section_statement_table
,
1487 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1490 entry
->root
= last_ent
->root
;
1491 last_ent
->root
.next
= &entry
->root
;
1494 entry
->s
.output_section_statement
.name
= name
;
1495 entry
->s
.output_section_statement
.constraint
= constraint
;
1496 return &entry
->s
.output_section_statement
;
1499 /* Find the next output_section_statement with the same name as OS.
1500 If CONSTRAINT is non-zero, find one with that constraint otherwise
1501 match any non-negative constraint. */
1503 lang_output_section_statement_type
*
1504 next_matching_output_section_statement (lang_output_section_statement_type
*os
,
1507 /* All output_section_statements are actually part of a
1508 struct out_section_hash_entry. */
1509 struct out_section_hash_entry
*entry
= (struct out_section_hash_entry
*)
1511 - offsetof (struct out_section_hash_entry
, s
.output_section_statement
));
1512 const char *name
= os
->name
;
1514 ASSERT (name
== entry
->root
.string
);
1517 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1519 || name
!= entry
->s
.output_section_statement
.name
)
1522 while (constraint
!= entry
->s
.output_section_statement
.constraint
1524 || entry
->s
.output_section_statement
.constraint
< 0));
1526 return &entry
->s
.output_section_statement
;
1529 /* A variant of lang_output_section_find used by place_orphan.
1530 Returns the output statement that should precede a new output
1531 statement for SEC. If an exact match is found on certain flags,
1534 lang_output_section_statement_type
*
1535 lang_output_section_find_by_flags (const asection
*sec
,
1537 lang_output_section_statement_type
**exact
,
1538 lang_match_sec_type_func match_type
)
1540 lang_output_section_statement_type
*first
, *look
, *found
;
1541 flagword look_flags
, differ
;
1543 /* We know the first statement on this list is *ABS*. May as well
1545 first
= &lang_os_list
.head
->output_section_statement
;
1546 first
= first
->next
;
1548 /* First try for an exact match. */
1550 for (look
= first
; look
; look
= look
->next
)
1552 look_flags
= look
->flags
;
1553 if (look
->bfd_section
!= NULL
)
1555 look_flags
= look
->bfd_section
->flags
;
1556 if (match_type
&& !match_type (link_info
.output_bfd
,
1561 differ
= look_flags
^ sec_flags
;
1562 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1563 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1573 if ((sec_flags
& SEC_CODE
) != 0
1574 && (sec_flags
& SEC_ALLOC
) != 0)
1576 /* Try for a rw code section. */
1577 for (look
= first
; look
; look
= look
->next
)
1579 look_flags
= look
->flags
;
1580 if (look
->bfd_section
!= NULL
)
1582 look_flags
= look
->bfd_section
->flags
;
1583 if (match_type
&& !match_type (link_info
.output_bfd
,
1588 differ
= look_flags
^ sec_flags
;
1589 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1590 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1594 else if ((sec_flags
& SEC_READONLY
) != 0
1595 && (sec_flags
& SEC_ALLOC
) != 0)
1597 /* .rodata can go after .text, .sdata2 after .rodata. */
1598 for (look
= first
; look
; look
= look
->next
)
1600 look_flags
= look
->flags
;
1601 if (look
->bfd_section
!= NULL
)
1603 look_flags
= look
->bfd_section
->flags
;
1604 if (match_type
&& !match_type (link_info
.output_bfd
,
1609 differ
= look_flags
^ sec_flags
;
1610 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1611 | SEC_READONLY
| SEC_SMALL_DATA
))
1612 || (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1614 && !(look_flags
& SEC_SMALL_DATA
)))
1618 else if ((sec_flags
& SEC_THREAD_LOCAL
) != 0
1619 && (sec_flags
& SEC_ALLOC
) != 0)
1621 /* .tdata can go after .data, .tbss after .tdata. Treat .tbss
1622 as if it were a loaded section, and don't use match_type. */
1623 bfd_boolean seen_thread_local
= FALSE
;
1626 for (look
= first
; look
; look
= look
->next
)
1628 look_flags
= look
->flags
;
1629 if (look
->bfd_section
!= NULL
)
1630 look_flags
= look
->bfd_section
->flags
;
1632 differ
= look_flags
^ (sec_flags
| SEC_LOAD
| SEC_HAS_CONTENTS
);
1633 if (!(differ
& (SEC_THREAD_LOCAL
| SEC_ALLOC
)))
1635 /* .tdata and .tbss must be adjacent and in that order. */
1636 if (!(look_flags
& SEC_LOAD
)
1637 && (sec_flags
& SEC_LOAD
))
1638 /* ..so if we're at a .tbss section and we're placing
1639 a .tdata section stop looking and return the
1640 previous section. */
1643 seen_thread_local
= TRUE
;
1645 else if (seen_thread_local
)
1647 else if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
)))
1651 else if ((sec_flags
& SEC_SMALL_DATA
) != 0
1652 && (sec_flags
& SEC_ALLOC
) != 0)
1654 /* .sdata goes after .data, .sbss after .sdata. */
1655 for (look
= first
; look
; look
= look
->next
)
1657 look_flags
= look
->flags
;
1658 if (look
->bfd_section
!= NULL
)
1660 look_flags
= look
->bfd_section
->flags
;
1661 if (match_type
&& !match_type (link_info
.output_bfd
,
1666 differ
= look_flags
^ sec_flags
;
1667 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1668 | SEC_THREAD_LOCAL
))
1669 || ((look_flags
& SEC_SMALL_DATA
)
1670 && !(sec_flags
& SEC_HAS_CONTENTS
)))
1674 else if ((sec_flags
& SEC_HAS_CONTENTS
) != 0
1675 && (sec_flags
& SEC_ALLOC
) != 0)
1677 /* .data goes after .rodata. */
1678 for (look
= first
; look
; look
= look
->next
)
1680 look_flags
= look
->flags
;
1681 if (look
->bfd_section
!= NULL
)
1683 look_flags
= look
->bfd_section
->flags
;
1684 if (match_type
&& !match_type (link_info
.output_bfd
,
1689 differ
= look_flags
^ sec_flags
;
1690 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1691 | SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1695 else if ((sec_flags
& SEC_ALLOC
) != 0)
1697 /* .bss goes after any other alloc section. */
1698 for (look
= first
; look
; look
= look
->next
)
1700 look_flags
= look
->flags
;
1701 if (look
->bfd_section
!= NULL
)
1703 look_flags
= look
->bfd_section
->flags
;
1704 if (match_type
&& !match_type (link_info
.output_bfd
,
1709 differ
= look_flags
^ sec_flags
;
1710 if (!(differ
& SEC_ALLOC
))
1716 /* non-alloc go last. */
1717 for (look
= first
; look
; look
= look
->next
)
1719 look_flags
= look
->flags
;
1720 if (look
->bfd_section
!= NULL
)
1721 look_flags
= look
->bfd_section
->flags
;
1722 differ
= look_flags
^ sec_flags
;
1723 if (!(differ
& SEC_DEBUGGING
))
1729 if (found
|| !match_type
)
1732 return lang_output_section_find_by_flags (sec
, sec_flags
, NULL
, NULL
);
1735 /* Find the last output section before given output statement.
1736 Used by place_orphan. */
1739 output_prev_sec_find (lang_output_section_statement_type
*os
)
1741 lang_output_section_statement_type
*lookup
;
1743 for (lookup
= os
->prev
; lookup
!= NULL
; lookup
= lookup
->prev
)
1745 if (lookup
->constraint
< 0)
1748 if (lookup
->bfd_section
!= NULL
&& lookup
->bfd_section
->owner
!= NULL
)
1749 return lookup
->bfd_section
;
1755 /* Look for a suitable place for a new output section statement. The
1756 idea is to skip over anything that might be inside a SECTIONS {}
1757 statement in a script, before we find another output section
1758 statement. Assignments to "dot" before an output section statement
1759 are assumed to belong to it, except in two cases; The first
1760 assignment to dot, and assignments before non-alloc sections.
1761 Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
1762 similar assignments that set the initial address, or we might
1763 insert non-alloc note sections among assignments setting end of
1766 static lang_statement_union_type
**
1767 insert_os_after (lang_output_section_statement_type
*after
)
1769 lang_statement_union_type
**where
;
1770 lang_statement_union_type
**assign
= NULL
;
1771 bfd_boolean ignore_first
;
1773 ignore_first
= after
== &lang_os_list
.head
->output_section_statement
;
1775 for (where
= &after
->header
.next
;
1777 where
= &(*where
)->header
.next
)
1779 switch ((*where
)->header
.type
)
1781 case lang_assignment_statement_enum
:
1784 lang_assignment_statement_type
*ass
;
1786 ass
= &(*where
)->assignment_statement
;
1787 if (ass
->exp
->type
.node_class
!= etree_assert
1788 && ass
->exp
->assign
.dst
[0] == '.'
1789 && ass
->exp
->assign
.dst
[1] == 0)
1793 ignore_first
= FALSE
;
1797 case lang_wild_statement_enum
:
1798 case lang_input_section_enum
:
1799 case lang_object_symbols_statement_enum
:
1800 case lang_fill_statement_enum
:
1801 case lang_data_statement_enum
:
1802 case lang_reloc_statement_enum
:
1803 case lang_padding_statement_enum
:
1804 case lang_constructors_statement_enum
:
1806 ignore_first
= FALSE
;
1808 case lang_output_section_statement_enum
:
1811 asection
*s
= (*where
)->output_section_statement
.bfd_section
;
1814 || s
->map_head
.s
== NULL
1815 || (s
->flags
& SEC_ALLOC
) != 0)
1819 case lang_input_statement_enum
:
1820 case lang_address_statement_enum
:
1821 case lang_target_statement_enum
:
1822 case lang_output_statement_enum
:
1823 case lang_group_statement_enum
:
1824 case lang_insert_statement_enum
:
1833 lang_output_section_statement_type
*
1834 lang_insert_orphan (asection
*s
,
1835 const char *secname
,
1837 lang_output_section_statement_type
*after
,
1838 struct orphan_save
*place
,
1839 etree_type
*address
,
1840 lang_statement_list_type
*add_child
)
1842 lang_statement_list_type add
;
1843 lang_output_section_statement_type
*os
;
1844 lang_output_section_statement_type
**os_tail
;
1846 /* If we have found an appropriate place for the output section
1847 statements for this orphan, add them to our own private list,
1848 inserting them later into the global statement list. */
1851 lang_list_init (&add
);
1852 push_stat_ptr (&add
);
1855 if (bfd_link_relocatable (&link_info
)
1856 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
1857 address
= exp_intop (0);
1859 os_tail
= (lang_output_section_statement_type
**) lang_os_list
.tail
;
1860 os
= lang_enter_output_section_statement (secname
, address
, normal_section
,
1861 NULL
, NULL
, NULL
, constraint
, 0);
1863 if (add_child
== NULL
)
1864 add_child
= &os
->children
;
1865 lang_add_section (add_child
, s
, NULL
, os
);
1867 if (after
&& (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) != 0)
1869 const char *region
= (after
->region
1870 ? after
->region
->name_list
.name
1871 : DEFAULT_MEMORY_REGION
);
1872 const char *lma_region
= (after
->lma_region
1873 ? after
->lma_region
->name_list
.name
1875 lang_leave_output_section_statement (NULL
, region
, after
->phdrs
,
1879 lang_leave_output_section_statement (NULL
, DEFAULT_MEMORY_REGION
, NULL
,
1882 /* Restore the global list pointer. */
1886 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
1888 asection
*snew
, *as
;
1889 bfd_boolean place_after
= place
->stmt
== NULL
;
1890 bfd_boolean insert_after
= TRUE
;
1892 snew
= os
->bfd_section
;
1894 /* Shuffle the bfd section list to make the output file look
1895 neater. This is really only cosmetic. */
1896 if (place
->section
== NULL
1897 && after
!= &lang_os_list
.head
->output_section_statement
)
1899 asection
*bfd_section
= after
->bfd_section
;
1901 /* If the output statement hasn't been used to place any input
1902 sections (and thus doesn't have an output bfd_section),
1903 look for the closest prior output statement having an
1905 if (bfd_section
== NULL
)
1906 bfd_section
= output_prev_sec_find (after
);
1908 if (bfd_section
!= NULL
&& bfd_section
!= snew
)
1909 place
->section
= &bfd_section
->next
;
1912 if (place
->section
== NULL
)
1913 place
->section
= &link_info
.output_bfd
->sections
;
1915 as
= *place
->section
;
1919 /* Put the section at the end of the list. */
1921 /* Unlink the section. */
1922 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1924 /* Now tack it back on in the right place. */
1925 bfd_section_list_append (link_info
.output_bfd
, snew
);
1927 else if ((bfd_get_flavour (link_info
.output_bfd
)
1928 == bfd_target_elf_flavour
)
1929 && (bfd_get_flavour (s
->owner
)
1930 == bfd_target_elf_flavour
)
1931 && ((elf_section_type (s
) == SHT_NOTE
1932 && (s
->flags
& SEC_LOAD
) != 0)
1933 || (elf_section_type (as
) == SHT_NOTE
1934 && (as
->flags
& SEC_LOAD
) != 0)))
1936 /* Make sure that output note sections are grouped and sorted
1937 by alignments when inserting a note section or insert a
1938 section after a note section, */
1940 /* A specific section after which the output note section
1941 should be placed. */
1942 asection
*after_sec
;
1943 /* True if we need to insert the orphan section after a
1944 specific section to maintain output note section order. */
1945 bfd_boolean after_sec_note
= FALSE
;
1947 static asection
*first_orphan_note
= NULL
;
1949 /* Group and sort output note section by alignments in
1952 if (elf_section_type (s
) == SHT_NOTE
1953 && (s
->flags
& SEC_LOAD
) != 0)
1955 /* Search from the beginning for the last output note
1956 section with equal or larger alignments. NB: Don't
1957 place orphan note section after non-note sections. */
1959 first_orphan_note
= NULL
;
1960 for (sec
= link_info
.output_bfd
->sections
;
1962 && !bfd_is_abs_section (sec
));
1965 && elf_section_type (sec
) == SHT_NOTE
1966 && (sec
->flags
& SEC_LOAD
) != 0)
1968 if (!first_orphan_note
)
1969 first_orphan_note
= sec
;
1970 if (sec
->alignment_power
>= s
->alignment_power
)
1973 else if (first_orphan_note
)
1975 /* Stop if there is non-note section after the first
1976 orphan note section. */
1980 /* If this will be the first orphan note section, it can
1981 be placed at the default location. */
1982 after_sec_note
= first_orphan_note
!= NULL
;
1983 if (after_sec
== NULL
&& after_sec_note
)
1985 /* If all output note sections have smaller
1986 alignments, place the section before all
1987 output orphan note sections. */
1988 after_sec
= first_orphan_note
;
1989 insert_after
= FALSE
;
1992 else if (first_orphan_note
)
1994 /* Don't place non-note sections in the middle of orphan
1996 after_sec_note
= TRUE
;
1998 for (sec
= as
->next
;
2000 && !bfd_is_abs_section (sec
));
2002 if (elf_section_type (sec
) == SHT_NOTE
2003 && (sec
->flags
& SEC_LOAD
) != 0)
2011 /* Search forward to insert OS after AFTER_SEC output
2013 lang_output_section_statement_type
*stmt
, *next
;
2014 bfd_boolean found
= FALSE
;
2015 for (stmt
= after
; stmt
!= NULL
; stmt
= next
)
2020 if (stmt
->bfd_section
== after_sec
)
2030 /* If INSERT_AFTER is FALSE, place OS before
2031 AFTER_SEC output statement. */
2032 if (next
&& next
->bfd_section
== after_sec
)
2042 /* Search backward to insert OS after AFTER_SEC output
2045 for (stmt
= after
; stmt
!= NULL
; stmt
= stmt
->prev
)
2049 if (stmt
->bfd_section
== after_sec
)
2058 /* If INSERT_AFTER is FALSE, place OS before
2059 AFTER_SEC output statement. */
2060 if (stmt
->next
->bfd_section
== after_sec
)
2070 if (after_sec
== NULL
2071 || (insert_after
&& after_sec
->next
!= snew
)
2072 || (!insert_after
&& after_sec
->prev
!= snew
))
2074 /* Unlink the section. */
2075 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2077 /* Place SNEW after AFTER_SEC. If AFTER_SEC is NULL,
2082 bfd_section_list_insert_after (link_info
.output_bfd
,
2085 bfd_section_list_insert_before (link_info
.output_bfd
,
2089 bfd_section_list_prepend (link_info
.output_bfd
, snew
);
2092 else if (as
!= snew
&& as
->prev
!= snew
)
2094 /* Unlink the section. */
2095 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2097 /* Now tack it back on in the right place. */
2098 bfd_section_list_insert_before (link_info
.output_bfd
,
2102 else if (as
!= snew
&& as
->prev
!= snew
)
2104 /* Unlink the section. */
2105 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2107 /* Now tack it back on in the right place. */
2108 bfd_section_list_insert_before (link_info
.output_bfd
, as
, snew
);
2111 /* Save the end of this list. Further ophans of this type will
2112 follow the one we've just added. */
2113 place
->section
= &snew
->next
;
2115 /* The following is non-cosmetic. We try to put the output
2116 statements in some sort of reasonable order here, because they
2117 determine the final load addresses of the orphan sections.
2118 In addition, placing output statements in the wrong order may
2119 require extra segments. For instance, given a typical
2120 situation of all read-only sections placed in one segment and
2121 following that a segment containing all the read-write
2122 sections, we wouldn't want to place an orphan read/write
2123 section before or amongst the read-only ones. */
2124 if (add
.head
!= NULL
)
2126 lang_output_section_statement_type
*newly_added_os
;
2128 /* Place OS after AFTER if AFTER_NOTE is TRUE. */
2131 lang_statement_union_type
**where
= insert_os_after (after
);
2136 place
->os_tail
= &after
->next
;
2140 /* Put it after the last orphan statement we added. */
2141 *add
.tail
= *place
->stmt
;
2142 *place
->stmt
= add
.head
;
2145 /* Fix the global list pointer if we happened to tack our
2146 new list at the tail. */
2147 if (*stat_ptr
->tail
== add
.head
)
2148 stat_ptr
->tail
= add
.tail
;
2150 /* Save the end of this list. */
2151 place
->stmt
= add
.tail
;
2153 /* Do the same for the list of output section statements. */
2154 newly_added_os
= *os_tail
;
2156 newly_added_os
->prev
= (lang_output_section_statement_type
*)
2157 ((char *) place
->os_tail
2158 - offsetof (lang_output_section_statement_type
, next
));
2159 newly_added_os
->next
= *place
->os_tail
;
2160 if (newly_added_os
->next
!= NULL
)
2161 newly_added_os
->next
->prev
= newly_added_os
;
2162 *place
->os_tail
= newly_added_os
;
2163 place
->os_tail
= &newly_added_os
->next
;
2165 /* Fixing the global list pointer here is a little different.
2166 We added to the list in lang_enter_output_section_statement,
2167 trimmed off the new output_section_statment above when
2168 assigning *os_tail = NULL, but possibly added it back in
2169 the same place when assigning *place->os_tail. */
2170 if (*os_tail
== NULL
)
2171 lang_os_list
.tail
= (lang_statement_union_type
**) os_tail
;
2178 lang_print_asneeded (void)
2180 struct asneeded_minfo
*m
;
2182 if (asneeded_list_head
== NULL
)
2185 minfo (_("\nAs-needed library included to satisfy reference by file (symbol)\n\n"));
2187 for (m
= asneeded_list_head
; m
!= NULL
; m
= m
->next
)
2191 minfo ("%s", m
->soname
);
2192 len
= strlen (m
->soname
);
2206 minfo ("%pB ", m
->ref
);
2207 minfo ("(%pT)\n", m
->name
);
2212 lang_map_flags (flagword flag
)
2214 if (flag
& SEC_ALLOC
)
2217 if (flag
& SEC_CODE
)
2220 if (flag
& SEC_READONLY
)
2223 if (flag
& SEC_DATA
)
2226 if (flag
& SEC_LOAD
)
2233 lang_memory_region_type
*m
;
2234 bfd_boolean dis_header_printed
= FALSE
;
2236 LANG_FOR_EACH_INPUT_STATEMENT (file
)
2240 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
2241 || file
->flags
.just_syms
)
2244 if (config
.print_map_discarded
)
2245 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2246 if ((s
->output_section
== NULL
2247 || s
->output_section
->owner
!= link_info
.output_bfd
)
2248 && (s
->flags
& (SEC_LINKER_CREATED
| SEC_KEEP
)) == 0)
2250 if (! dis_header_printed
)
2252 fprintf (config
.map_file
, _("\nDiscarded input sections\n\n"));
2253 dis_header_printed
= TRUE
;
2256 print_input_section (s
, TRUE
);
2260 minfo (_("\nMemory Configuration\n\n"));
2261 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
2262 _("Name"), _("Origin"), _("Length"), _("Attributes"));
2264 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
2269 fprintf (config
.map_file
, "%-16s ", m
->name_list
.name
);
2271 sprintf_vma (buf
, m
->origin
);
2272 minfo ("0x%s ", buf
);
2280 minfo ("0x%V", m
->length
);
2281 if (m
->flags
|| m
->not_flags
)
2289 lang_map_flags (m
->flags
);
2295 lang_map_flags (m
->not_flags
);
2302 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
2304 if (!link_info
.reduce_memory_overheads
)
2306 obstack_begin (&map_obstack
, 1000);
2307 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
2309 expld
.phase
= lang_fixed_phase_enum
;
2310 lang_statement_iteration
++;
2311 print_statements ();
2313 ldemul_extra_map_file_text (link_info
.output_bfd
, &link_info
,
2318 sort_def_symbol (struct bfd_link_hash_entry
*hash_entry
,
2319 void *info ATTRIBUTE_UNUSED
)
2321 if ((hash_entry
->type
== bfd_link_hash_defined
2322 || hash_entry
->type
== bfd_link_hash_defweak
)
2323 && hash_entry
->u
.def
.section
->owner
!= link_info
.output_bfd
2324 && hash_entry
->u
.def
.section
->owner
!= NULL
)
2326 input_section_userdata_type
*ud
;
2327 struct map_symbol_def
*def
;
2329 ud
= ((input_section_userdata_type
*)
2330 get_userdata (hash_entry
->u
.def
.section
));
2333 ud
= stat_alloc (sizeof (*ud
));
2334 get_userdata (hash_entry
->u
.def
.section
) = ud
;
2335 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2336 ud
->map_symbol_def_count
= 0;
2338 else if (!ud
->map_symbol_def_tail
)
2339 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2341 def
= (struct map_symbol_def
*) obstack_alloc (&map_obstack
, sizeof *def
);
2342 def
->entry
= hash_entry
;
2343 *(ud
->map_symbol_def_tail
) = def
;
2344 ud
->map_symbol_def_tail
= &def
->next
;
2345 ud
->map_symbol_def_count
++;
2350 /* Initialize an output section. */
2353 init_os (lang_output_section_statement_type
*s
, flagword flags
)
2355 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
2356 einfo (_("%F%P: illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
2358 if (s
->constraint
!= SPECIAL
)
2359 s
->bfd_section
= bfd_get_section_by_name (link_info
.output_bfd
, s
->name
);
2360 if (s
->bfd_section
== NULL
)
2361 s
->bfd_section
= bfd_make_section_anyway_with_flags (link_info
.output_bfd
,
2363 if (s
->bfd_section
== NULL
)
2365 einfo (_("%F%P: output format %s cannot represent section"
2366 " called %s: %E\n"),
2367 link_info
.output_bfd
->xvec
->name
, s
->name
);
2369 s
->bfd_section
->output_section
= s
->bfd_section
;
2370 s
->bfd_section
->output_offset
= 0;
2372 /* Set the userdata of the output section to the output section
2373 statement to avoid lookup. */
2374 get_userdata (s
->bfd_section
) = s
;
2376 /* If there is a base address, make sure that any sections it might
2377 mention are initialized. */
2378 if (s
->addr_tree
!= NULL
)
2379 exp_init_os (s
->addr_tree
);
2381 if (s
->load_base
!= NULL
)
2382 exp_init_os (s
->load_base
);
2384 /* If supplied an alignment, set it. */
2385 if (s
->section_alignment
!= NULL
)
2386 s
->bfd_section
->alignment_power
= exp_get_power (s
->section_alignment
,
2387 "section alignment");
2390 /* Make sure that all output sections mentioned in an expression are
2394 exp_init_os (etree_type
*exp
)
2396 switch (exp
->type
.node_class
)
2400 case etree_provided
:
2401 exp_init_os (exp
->assign
.src
);
2405 exp_init_os (exp
->binary
.lhs
);
2406 exp_init_os (exp
->binary
.rhs
);
2410 exp_init_os (exp
->trinary
.cond
);
2411 exp_init_os (exp
->trinary
.lhs
);
2412 exp_init_os (exp
->trinary
.rhs
);
2416 exp_init_os (exp
->assert_s
.child
);
2420 exp_init_os (exp
->unary
.child
);
2424 switch (exp
->type
.node_code
)
2430 lang_output_section_statement_type
*os
;
2432 os
= lang_output_section_find (exp
->name
.name
);
2433 if (os
!= NULL
&& os
->bfd_section
== NULL
)
2445 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
2447 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
2449 /* If we are only reading symbols from this object, then we want to
2450 discard all sections. */
2451 if (entry
->flags
.just_syms
)
2453 bfd_link_just_syms (abfd
, sec
, &link_info
);
2457 /* Deal with SHF_EXCLUDE ELF sections. */
2458 if (!bfd_link_relocatable (&link_info
)
2459 && (abfd
->flags
& BFD_PLUGIN
) == 0
2460 && (sec
->flags
& (SEC_GROUP
| SEC_KEEP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
2461 sec
->output_section
= bfd_abs_section_ptr
;
2463 if (!(abfd
->flags
& DYNAMIC
))
2464 bfd_section_already_linked (abfd
, sec
, &link_info
);
2468 /* Returns true if SECTION is one we know will be discarded based on its
2469 section flags, otherwise returns false. */
2472 lang_discard_section_p (asection
*section
)
2474 bfd_boolean discard
;
2475 flagword flags
= section
->flags
;
2477 /* Discard sections marked with SEC_EXCLUDE. */
2478 discard
= (flags
& SEC_EXCLUDE
) != 0;
2480 /* Discard the group descriptor sections when we're finally placing the
2481 sections from within the group. */
2482 if ((flags
& SEC_GROUP
) != 0
2483 && link_info
.resolve_section_groups
)
2486 /* Discard debugging sections if we are stripping debugging
2488 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
2489 && (flags
& SEC_DEBUGGING
) != 0)
2495 /* The wild routines.
2497 These expand statements like *(.text) and foo.o to a list of
2498 explicit actions, like foo.o(.text), bar.o(.text) and
2499 foo.o(.text, .data). */
2501 /* Add SECTION to the output section OUTPUT. Do this by creating a
2502 lang_input_section statement which is placed at PTR. */
2505 lang_add_section (lang_statement_list_type
*ptr
,
2507 struct flag_info
*sflag_info
,
2508 lang_output_section_statement_type
*output
)
2510 flagword flags
= section
->flags
;
2512 bfd_boolean discard
;
2513 lang_input_section_type
*new_section
;
2514 bfd
*abfd
= link_info
.output_bfd
;
2516 /* Is this section one we know should be discarded? */
2517 discard
= lang_discard_section_p (section
);
2519 /* Discard input sections which are assigned to a section named
2520 DISCARD_SECTION_NAME. */
2521 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
2526 if (section
->output_section
== NULL
)
2528 /* This prevents future calls from assigning this section. */
2529 section
->output_section
= bfd_abs_section_ptr
;
2538 keep
= bfd_lookup_section_flags (&link_info
, sflag_info
, section
);
2543 if (section
->output_section
!= NULL
)
2546 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2547 to an output section, because we want to be able to include a
2548 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2549 section (I don't know why we want to do this, but we do).
2550 build_link_order in ldwrite.c handles this case by turning
2551 the embedded SEC_NEVER_LOAD section into a fill. */
2552 flags
&= ~ SEC_NEVER_LOAD
;
2554 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2555 already been processed. One reason to do this is that on pe
2556 format targets, .text$foo sections go into .text and it's odd
2557 to see .text with SEC_LINK_ONCE set. */
2558 if ((flags
& (SEC_LINK_ONCE
| SEC_GROUP
)) == (SEC_LINK_ONCE
| SEC_GROUP
))
2560 if (link_info
.resolve_section_groups
)
2561 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2563 flags
&= ~(SEC_LINK_DUPLICATES
| SEC_RELOC
);
2565 else if (!bfd_link_relocatable (&link_info
))
2566 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2568 switch (output
->sectype
)
2570 case normal_section
:
2571 case overlay_section
:
2572 case first_overlay_section
:
2574 case noalloc_section
:
2575 flags
&= ~SEC_ALLOC
;
2577 case noload_section
:
2579 flags
|= SEC_NEVER_LOAD
;
2580 /* Unfortunately GNU ld has managed to evolve two different
2581 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2582 alloc, no contents section. All others get a noload, noalloc
2584 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
2585 flags
&= ~SEC_HAS_CONTENTS
;
2587 flags
&= ~SEC_ALLOC
;
2591 if (output
->bfd_section
== NULL
)
2592 init_os (output
, flags
);
2594 /* If SEC_READONLY is not set in the input section, then clear
2595 it from the output section. */
2596 output
->bfd_section
->flags
&= flags
| ~SEC_READONLY
;
2598 if (output
->bfd_section
->linker_has_input
)
2600 /* Only set SEC_READONLY flag on the first input section. */
2601 flags
&= ~ SEC_READONLY
;
2603 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2604 if ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2605 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2606 || ((flags
& SEC_MERGE
) != 0
2607 && output
->bfd_section
->entsize
!= section
->entsize
))
2609 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2610 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2613 output
->bfd_section
->flags
|= flags
;
2615 if (!output
->bfd_section
->linker_has_input
)
2617 output
->bfd_section
->linker_has_input
= 1;
2618 /* This must happen after flags have been updated. The output
2619 section may have been created before we saw its first input
2620 section, eg. for a data statement. */
2621 bfd_init_private_section_data (section
->owner
, section
,
2622 link_info
.output_bfd
,
2623 output
->bfd_section
,
2625 if ((flags
& SEC_MERGE
) != 0)
2626 output
->bfd_section
->entsize
= section
->entsize
;
2629 if ((flags
& SEC_TIC54X_BLOCK
) != 0
2630 && bfd_get_arch (section
->owner
) == bfd_arch_tic54x
)
2632 /* FIXME: This value should really be obtained from the bfd... */
2633 output
->block_value
= 128;
2636 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2637 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2639 section
->output_section
= output
->bfd_section
;
2641 if (!map_head_is_link_order
)
2643 asection
*s
= output
->bfd_section
->map_tail
.s
;
2644 output
->bfd_section
->map_tail
.s
= section
;
2645 section
->map_head
.s
= NULL
;
2646 section
->map_tail
.s
= s
;
2648 s
->map_head
.s
= section
;
2650 output
->bfd_section
->map_head
.s
= section
;
2653 /* Add a section reference to the list. */
2654 new_section
= new_stat (lang_input_section
, ptr
);
2655 new_section
->section
= section
;
2658 /* Handle wildcard sorting. This returns the lang_input_section which
2659 should follow the one we are going to create for SECTION and FILE,
2660 based on the sorting requirements of WILD. It returns NULL if the
2661 new section should just go at the end of the current list. */
2663 static lang_statement_union_type
*
2664 wild_sort (lang_wild_statement_type
*wild
,
2665 struct wildcard_list
*sec
,
2666 lang_input_statement_type
*file
,
2669 lang_statement_union_type
*l
;
2671 if (!wild
->filenames_sorted
2672 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
2675 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
2677 lang_input_section_type
*ls
;
2679 if (l
->header
.type
!= lang_input_section_enum
)
2681 ls
= &l
->input_section
;
2683 /* Sorting by filename takes precedence over sorting by section
2686 if (wild
->filenames_sorted
)
2688 const char *fn
, *ln
;
2692 /* The PE support for the .idata section as generated by
2693 dlltool assumes that files will be sorted by the name of
2694 the archive and then the name of the file within the
2697 if (file
->the_bfd
!= NULL
2698 && file
->the_bfd
->my_archive
!= NULL
)
2700 fn
= bfd_get_filename (file
->the_bfd
->my_archive
);
2705 fn
= file
->filename
;
2709 if (ls
->section
->owner
->my_archive
!= NULL
)
2711 ln
= bfd_get_filename (ls
->section
->owner
->my_archive
);
2716 ln
= ls
->section
->owner
->filename
;
2720 i
= filename_cmp (fn
, ln
);
2729 fn
= file
->filename
;
2731 ln
= ls
->section
->owner
->filename
;
2733 i
= filename_cmp (fn
, ln
);
2741 /* Here either the files are not sorted by name, or we are
2742 looking at the sections for this file. */
2745 && sec
->spec
.sorted
!= none
2746 && sec
->spec
.sorted
!= by_none
)
2747 if (compare_section (sec
->spec
.sorted
, section
, ls
->section
) < 0)
2754 /* Expand a wild statement for a particular FILE. SECTION may be
2755 NULL, in which case it is a wild card. */
2758 output_section_callback (lang_wild_statement_type
*ptr
,
2759 struct wildcard_list
*sec
,
2761 struct flag_info
*sflag_info
,
2762 lang_input_statement_type
*file
,
2765 lang_statement_union_type
*before
;
2766 lang_output_section_statement_type
*os
;
2768 os
= (lang_output_section_statement_type
*) output
;
2770 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2771 if (unique_section_p (section
, os
))
2774 before
= wild_sort (ptr
, sec
, file
, section
);
2776 /* Here BEFORE points to the lang_input_section which
2777 should follow the one we are about to add. If BEFORE
2778 is NULL, then the section should just go at the end
2779 of the current list. */
2782 lang_add_section (&ptr
->children
, section
, sflag_info
, os
);
2785 lang_statement_list_type list
;
2786 lang_statement_union_type
**pp
;
2788 lang_list_init (&list
);
2789 lang_add_section (&list
, section
, sflag_info
, os
);
2791 /* If we are discarding the section, LIST.HEAD will
2793 if (list
.head
!= NULL
)
2795 ASSERT (list
.head
->header
.next
== NULL
);
2797 for (pp
= &ptr
->children
.head
;
2799 pp
= &(*pp
)->header
.next
)
2800 ASSERT (*pp
!= NULL
);
2802 list
.head
->header
.next
= *pp
;
2808 /* Check if all sections in a wild statement for a particular FILE
2812 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2813 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2815 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
2816 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2819 lang_output_section_statement_type
*os
;
2821 os
= (lang_output_section_statement_type
*) output
;
2823 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2824 if (unique_section_p (section
, os
))
2827 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2828 os
->all_input_readonly
= FALSE
;
2831 /* This is passed a file name which must have been seen already and
2832 added to the statement tree. We will see if it has been opened
2833 already and had its symbols read. If not then we'll read it. */
2835 static lang_input_statement_type
*
2836 lookup_name (const char *name
)
2838 lang_input_statement_type
*search
;
2840 for (search
= &input_file_chain
.head
->input_statement
;
2842 search
= search
->next_real_file
)
2844 /* Use the local_sym_name as the name of the file that has
2845 already been loaded as filename might have been transformed
2846 via the search directory lookup mechanism. */
2847 const char *filename
= search
->local_sym_name
;
2849 if (filename
!= NULL
2850 && filename_cmp (filename
, name
) == 0)
2856 /* Arrange to splice the input statement added by new_afile into
2857 statement_list after the current input_file_chain tail.
2858 We know input_file_chain is not an empty list, and that
2859 lookup_name was called via open_input_bfds. Later calls to
2860 lookup_name should always match an existing input_statement. */
2861 lang_statement_union_type
**tail
= stat_ptr
->tail
;
2862 lang_statement_union_type
**after
2863 = (void *) ((char *) input_file_chain
.tail
2864 - offsetof (lang_input_statement_type
, next_real_file
)
2865 + offsetof (lang_input_statement_type
, header
.next
));
2866 lang_statement_union_type
*rest
= *after
;
2867 stat_ptr
->tail
= after
;
2868 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2870 *stat_ptr
->tail
= rest
;
2872 stat_ptr
->tail
= tail
;
2875 /* If we have already added this file, or this file is not real
2876 don't add this file. */
2877 if (search
->flags
.loaded
|| !search
->flags
.real
)
2880 if (!load_symbols (search
, NULL
))
2886 /* Save LIST as a list of libraries whose symbols should not be exported. */
2891 struct excluded_lib
*next
;
2893 static struct excluded_lib
*excluded_libs
;
2896 add_excluded_libs (const char *list
)
2898 const char *p
= list
, *end
;
2902 struct excluded_lib
*entry
;
2903 end
= strpbrk (p
, ",:");
2905 end
= p
+ strlen (p
);
2906 entry
= (struct excluded_lib
*) xmalloc (sizeof (*entry
));
2907 entry
->next
= excluded_libs
;
2908 entry
->name
= (char *) xmalloc (end
- p
+ 1);
2909 memcpy (entry
->name
, p
, end
- p
);
2910 entry
->name
[end
- p
] = '\0';
2911 excluded_libs
= entry
;
2919 check_excluded_libs (bfd
*abfd
)
2921 struct excluded_lib
*lib
= excluded_libs
;
2925 int len
= strlen (lib
->name
);
2926 const char *filename
= lbasename (abfd
->filename
);
2928 if (strcmp (lib
->name
, "ALL") == 0)
2930 abfd
->no_export
= TRUE
;
2934 if (filename_ncmp (lib
->name
, filename
, len
) == 0
2935 && (filename
[len
] == '\0'
2936 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
2937 && filename
[len
+ 2] == '\0')))
2939 abfd
->no_export
= TRUE
;
2947 /* Get the symbols for an input file. */
2950 load_symbols (lang_input_statement_type
*entry
,
2951 lang_statement_list_type
*place
)
2955 if (entry
->flags
.loaded
)
2958 ldfile_open_file (entry
);
2960 /* Do not process further if the file was missing. */
2961 if (entry
->flags
.missing_file
)
2964 if (trace_files
|| verbose
)
2965 info_msg ("%pI\n", entry
);
2967 if (!bfd_check_format (entry
->the_bfd
, bfd_archive
)
2968 && !bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
2971 struct lang_input_statement_flags save_flags
;
2974 err
= bfd_get_error ();
2976 /* See if the emulation has some special knowledge. */
2977 if (ldemul_unrecognized_file (entry
))
2980 if (err
== bfd_error_file_ambiguously_recognized
)
2984 einfo (_("%P: %pB: file not recognized: %E;"
2985 " matching formats:"), entry
->the_bfd
);
2986 for (p
= matching
; *p
!= NULL
; p
++)
2990 else if (err
!= bfd_error_file_not_recognized
2992 einfo (_("%F%P: %pB: file not recognized: %E\n"), entry
->the_bfd
);
2994 bfd_close (entry
->the_bfd
);
2995 entry
->the_bfd
= NULL
;
2997 /* Try to interpret the file as a linker script. */
2998 save_flags
= input_flags
;
2999 ldfile_open_command_file (entry
->filename
);
3001 push_stat_ptr (place
);
3002 input_flags
.add_DT_NEEDED_for_regular
3003 = entry
->flags
.add_DT_NEEDED_for_regular
;
3004 input_flags
.add_DT_NEEDED_for_dynamic
3005 = entry
->flags
.add_DT_NEEDED_for_dynamic
;
3006 input_flags
.whole_archive
= entry
->flags
.whole_archive
;
3007 input_flags
.dynamic
= entry
->flags
.dynamic
;
3009 ldfile_assumed_script
= TRUE
;
3010 parser_input
= input_script
;
3012 ldfile_assumed_script
= FALSE
;
3014 /* missing_file is sticky. sysrooted will already have been
3015 restored when seeing EOF in yyparse, but no harm to restore
3017 save_flags
.missing_file
|= input_flags
.missing_file
;
3018 input_flags
= save_flags
;
3022 entry
->flags
.loaded
= TRUE
;
3027 if (ldemul_recognized_file (entry
))
3030 /* We don't call ldlang_add_file for an archive. Instead, the
3031 add_symbols entry point will call ldlang_add_file, via the
3032 add_archive_element callback, for each element of the archive
3034 switch (bfd_get_format (entry
->the_bfd
))
3040 if (!entry
->flags
.reload
)
3041 ldlang_add_file (entry
);
3045 check_excluded_libs (entry
->the_bfd
);
3047 entry
->the_bfd
->usrdata
= entry
;
3048 if (entry
->flags
.whole_archive
)
3051 bfd_boolean loaded
= TRUE
;
3056 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
3061 if (!bfd_check_format (member
, bfd_object
))
3063 einfo (_("%F%P: %pB: member %pB in archive is not an object\n"),
3064 entry
->the_bfd
, member
);
3069 if (!(*link_info
.callbacks
3070 ->add_archive_element
) (&link_info
, member
,
3071 "--whole-archive", &subsbfd
))
3074 /* Potentially, the add_archive_element hook may have set a
3075 substitute BFD for us. */
3076 if (!bfd_link_add_symbols (subsbfd
, &link_info
))
3078 einfo (_("%F%P: %pB: error adding symbols: %E\n"), member
);
3083 entry
->flags
.loaded
= loaded
;
3089 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
3090 entry
->flags
.loaded
= TRUE
;
3092 einfo (_("%F%P: %pB: error adding symbols: %E\n"), entry
->the_bfd
);
3094 return entry
->flags
.loaded
;
3097 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
3098 may be NULL, indicating that it is a wildcard. Separate
3099 lang_input_section statements are created for each part of the
3100 expansion; they are added after the wild statement S. OUTPUT is
3101 the output section. */
3104 wild (lang_wild_statement_type
*s
,
3105 const char *target ATTRIBUTE_UNUSED
,
3106 lang_output_section_statement_type
*output
)
3108 struct wildcard_list
*sec
;
3110 if (s
->handler_data
[0]
3111 && s
->handler_data
[0]->spec
.sorted
== by_name
3112 && !s
->filenames_sorted
)
3114 lang_section_bst_type
*tree
;
3116 walk_wild (s
, output_section_callback_fast
, output
);
3121 output_section_callback_tree_to_list (s
, tree
, output
);
3126 walk_wild (s
, output_section_callback
, output
);
3128 if (default_common_section
== NULL
)
3129 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
3130 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
3132 /* Remember the section that common is going to in case we
3133 later get something which doesn't know where to put it. */
3134 default_common_section
= output
;
3139 /* Return TRUE iff target is the sought target. */
3142 get_target (const bfd_target
*target
, void *data
)
3144 const char *sought
= (const char *) data
;
3146 return strcmp (target
->name
, sought
) == 0;
3149 /* Like strcpy() but convert to lower case as well. */
3152 stricpy (char *dest
, char *src
)
3156 while ((c
= *src
++) != 0)
3157 *dest
++ = TOLOWER (c
);
3162 /* Remove the first occurrence of needle (if any) in haystack
3166 strcut (char *haystack
, char *needle
)
3168 haystack
= strstr (haystack
, needle
);
3174 for (src
= haystack
+ strlen (needle
); *src
;)
3175 *haystack
++ = *src
++;
3181 /* Compare two target format name strings.
3182 Return a value indicating how "similar" they are. */
3185 name_compare (char *first
, char *second
)
3191 copy1
= (char *) xmalloc (strlen (first
) + 1);
3192 copy2
= (char *) xmalloc (strlen (second
) + 1);
3194 /* Convert the names to lower case. */
3195 stricpy (copy1
, first
);
3196 stricpy (copy2
, second
);
3198 /* Remove size and endian strings from the name. */
3199 strcut (copy1
, "big");
3200 strcut (copy1
, "little");
3201 strcut (copy2
, "big");
3202 strcut (copy2
, "little");
3204 /* Return a value based on how many characters match,
3205 starting from the beginning. If both strings are
3206 the same then return 10 * their length. */
3207 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
3208 if (copy1
[result
] == 0)
3220 /* Set by closest_target_match() below. */
3221 static const bfd_target
*winner
;
3223 /* Scan all the valid bfd targets looking for one that has the endianness
3224 requirement that was specified on the command line, and is the nearest
3225 match to the original output target. */
3228 closest_target_match (const bfd_target
*target
, void *data
)
3230 const bfd_target
*original
= (const bfd_target
*) data
;
3232 if (command_line
.endian
== ENDIAN_BIG
3233 && target
->byteorder
!= BFD_ENDIAN_BIG
)
3236 if (command_line
.endian
== ENDIAN_LITTLE
3237 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
3240 /* Must be the same flavour. */
3241 if (target
->flavour
!= original
->flavour
)
3244 /* Ignore generic big and little endian elf vectors. */
3245 if (strcmp (target
->name
, "elf32-big") == 0
3246 || strcmp (target
->name
, "elf64-big") == 0
3247 || strcmp (target
->name
, "elf32-little") == 0
3248 || strcmp (target
->name
, "elf64-little") == 0)
3251 /* If we have not found a potential winner yet, then record this one. */
3258 /* Oh dear, we now have two potential candidates for a successful match.
3259 Compare their names and choose the better one. */
3260 if (name_compare (target
->name
, original
->name
)
3261 > name_compare (winner
->name
, original
->name
))
3264 /* Keep on searching until wqe have checked them all. */
3268 /* Return the BFD target format of the first input file. */
3271 get_first_input_target (void)
3273 char *target
= NULL
;
3275 LANG_FOR_EACH_INPUT_STATEMENT (s
)
3277 if (s
->header
.type
== lang_input_statement_enum
3280 ldfile_open_file (s
);
3282 if (s
->the_bfd
!= NULL
3283 && bfd_check_format (s
->the_bfd
, bfd_object
))
3285 target
= bfd_get_target (s
->the_bfd
);
3297 lang_get_output_target (void)
3301 /* Has the user told us which output format to use? */
3302 if (output_target
!= NULL
)
3303 return output_target
;
3305 /* No - has the current target been set to something other than
3307 if (current_target
!= default_target
&& current_target
!= NULL
)
3308 return current_target
;
3310 /* No - can we determine the format of the first input file? */
3311 target
= get_first_input_target ();
3315 /* Failed - use the default output target. */
3316 return default_target
;
3319 /* Open the output file. */
3322 open_output (const char *name
)
3324 output_target
= lang_get_output_target ();
3326 /* Has the user requested a particular endianness on the command
3328 if (command_line
.endian
!= ENDIAN_UNSET
)
3330 /* Get the chosen target. */
3331 const bfd_target
*target
3332 = bfd_iterate_over_targets (get_target
, (void *) output_target
);
3334 /* If the target is not supported, we cannot do anything. */
3337 enum bfd_endian desired_endian
;
3339 if (command_line
.endian
== ENDIAN_BIG
)
3340 desired_endian
= BFD_ENDIAN_BIG
;
3342 desired_endian
= BFD_ENDIAN_LITTLE
;
3344 /* See if the target has the wrong endianness. This should
3345 not happen if the linker script has provided big and
3346 little endian alternatives, but some scrips don't do
3348 if (target
->byteorder
!= desired_endian
)
3350 /* If it does, then see if the target provides
3351 an alternative with the correct endianness. */
3352 if (target
->alternative_target
!= NULL
3353 && (target
->alternative_target
->byteorder
== desired_endian
))
3354 output_target
= target
->alternative_target
->name
;
3357 /* Try to find a target as similar as possible to
3358 the default target, but which has the desired
3359 endian characteristic. */
3360 bfd_iterate_over_targets (closest_target_match
,
3363 /* Oh dear - we could not find any targets that
3364 satisfy our requirements. */
3366 einfo (_("%P: warning: could not find any targets"
3367 " that match endianness requirement\n"));
3369 output_target
= winner
->name
;
3375 link_info
.output_bfd
= bfd_openw (name
, output_target
);
3377 if (link_info
.output_bfd
== NULL
)
3379 if (bfd_get_error () == bfd_error_invalid_target
)
3380 einfo (_("%F%P: target %s not found\n"), output_target
);
3382 einfo (_("%F%P: cannot open output file %s: %E\n"), name
);
3385 delete_output_file_on_failure
= TRUE
;
3387 if (!bfd_set_format (link_info
.output_bfd
, bfd_object
))
3388 einfo (_("%F%P: %s: can not make object file: %E\n"), name
);
3389 if (!bfd_set_arch_mach (link_info
.output_bfd
,
3390 ldfile_output_architecture
,
3391 ldfile_output_machine
))
3392 einfo (_("%F%P: %s: can not set architecture: %E\n"), name
);
3394 link_info
.hash
= bfd_link_hash_table_create (link_info
.output_bfd
);
3395 if (link_info
.hash
== NULL
)
3396 einfo (_("%F%P: can not create hash table: %E\n"));
3398 bfd_set_gp_size (link_info
.output_bfd
, g_switch_value
);
3402 ldlang_open_output (lang_statement_union_type
*statement
)
3404 switch (statement
->header
.type
)
3406 case lang_output_statement_enum
:
3407 ASSERT (link_info
.output_bfd
== NULL
);
3408 open_output (statement
->output_statement
.name
);
3409 ldemul_set_output_arch ();
3410 if (config
.magic_demand_paged
3411 && !bfd_link_relocatable (&link_info
))
3412 link_info
.output_bfd
->flags
|= D_PAGED
;
3414 link_info
.output_bfd
->flags
&= ~D_PAGED
;
3415 if (config
.text_read_only
)
3416 link_info
.output_bfd
->flags
|= WP_TEXT
;
3418 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
3419 if (link_info
.traditional_format
)
3420 link_info
.output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
3422 link_info
.output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
3425 case lang_target_statement_enum
:
3426 current_target
= statement
->target_statement
.target
;
3436 unsigned x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3437 ldfile_output_machine
);
3440 while ((x
& 1) == 0)
3448 /* Open all the input files. */
3452 OPEN_BFD_NORMAL
= 0,
3456 #ifdef ENABLE_PLUGINS
3457 static lang_input_statement_type
*plugin_insert
= NULL
;
3458 static struct bfd_link_hash_entry
*plugin_undefs
= NULL
;
3462 open_input_bfds (lang_statement_union_type
*s
, enum open_bfd_mode mode
)
3464 for (; s
!= NULL
; s
= s
->header
.next
)
3466 switch (s
->header
.type
)
3468 case lang_constructors_statement_enum
:
3469 open_input_bfds (constructor_list
.head
, mode
);
3471 case lang_output_section_statement_enum
:
3472 open_input_bfds (s
->output_section_statement
.children
.head
, mode
);
3474 case lang_wild_statement_enum
:
3475 /* Maybe we should load the file's symbols. */
3476 if ((mode
& OPEN_BFD_RESCAN
) == 0
3477 && s
->wild_statement
.filename
3478 && !wildcardp (s
->wild_statement
.filename
)
3479 && !archive_path (s
->wild_statement
.filename
))
3480 lookup_name (s
->wild_statement
.filename
);
3481 open_input_bfds (s
->wild_statement
.children
.head
, mode
);
3483 case lang_group_statement_enum
:
3485 struct bfd_link_hash_entry
*undefs
;
3486 #ifdef ENABLE_PLUGINS
3487 lang_input_statement_type
*plugin_insert_save
;
3490 /* We must continually search the entries in the group
3491 until no new symbols are added to the list of undefined
3496 #ifdef ENABLE_PLUGINS
3497 plugin_insert_save
= plugin_insert
;
3499 undefs
= link_info
.hash
->undefs_tail
;
3500 open_input_bfds (s
->group_statement
.children
.head
,
3501 mode
| OPEN_BFD_FORCE
);
3503 while (undefs
!= link_info
.hash
->undefs_tail
3504 #ifdef ENABLE_PLUGINS
3505 /* Objects inserted by a plugin, which are loaded
3506 before we hit this loop, may have added new
3508 || (plugin_insert
!= plugin_insert_save
&& plugin_undefs
)
3513 case lang_target_statement_enum
:
3514 current_target
= s
->target_statement
.target
;
3516 case lang_input_statement_enum
:
3517 if (s
->input_statement
.flags
.real
)
3519 lang_statement_union_type
**os_tail
;
3520 lang_statement_list_type add
;
3523 s
->input_statement
.target
= current_target
;
3525 /* If we are being called from within a group, and this
3526 is an archive which has already been searched, then
3527 force it to be researched unless the whole archive
3528 has been loaded already. Do the same for a rescan.
3529 Likewise reload --as-needed shared libs. */
3530 if (mode
!= OPEN_BFD_NORMAL
3531 #ifdef ENABLE_PLUGINS
3532 && ((mode
& OPEN_BFD_RESCAN
) == 0
3533 || plugin_insert
== NULL
)
3535 && s
->input_statement
.flags
.loaded
3536 && (abfd
= s
->input_statement
.the_bfd
) != NULL
3537 && ((bfd_get_format (abfd
) == bfd_archive
3538 && !s
->input_statement
.flags
.whole_archive
)
3539 || (bfd_get_format (abfd
) == bfd_object
3540 && ((abfd
->flags
) & DYNAMIC
) != 0
3541 && s
->input_statement
.flags
.add_DT_NEEDED_for_regular
3542 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3543 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)))
3545 s
->input_statement
.flags
.loaded
= FALSE
;
3546 s
->input_statement
.flags
.reload
= TRUE
;
3549 os_tail
= lang_os_list
.tail
;
3550 lang_list_init (&add
);
3552 if (!load_symbols (&s
->input_statement
, &add
))
3553 config
.make_executable
= FALSE
;
3555 if (add
.head
!= NULL
)
3557 /* If this was a script with output sections then
3558 tack any added statements on to the end of the
3559 list. This avoids having to reorder the output
3560 section statement list. Very likely the user
3561 forgot -T, and whatever we do here will not meet
3562 naive user expectations. */
3563 if (os_tail
!= lang_os_list
.tail
)
3565 einfo (_("%P: warning: %s contains output sections;"
3566 " did you forget -T?\n"),
3567 s
->input_statement
.filename
);
3568 *stat_ptr
->tail
= add
.head
;
3569 stat_ptr
->tail
= add
.tail
;
3573 *add
.tail
= s
->header
.next
;
3574 s
->header
.next
= add
.head
;
3578 #ifdef ENABLE_PLUGINS
3579 /* If we have found the point at which a plugin added new
3580 files, clear plugin_insert to enable archive rescan. */
3581 if (&s
->input_statement
== plugin_insert
)
3582 plugin_insert
= NULL
;
3585 case lang_assignment_statement_enum
:
3586 if (s
->assignment_statement
.exp
->type
.node_class
!= etree_assert
)
3587 exp_fold_tree_no_dot (s
->assignment_statement
.exp
);
3594 /* Exit if any of the files were missing. */
3595 if (input_flags
.missing_file
)
3599 /* Add the supplied name to the symbol table as an undefined reference.
3600 This is a two step process as the symbol table doesn't even exist at
3601 the time the ld command line is processed. First we put the name
3602 on a list, then, once the output file has been opened, transfer the
3603 name to the symbol table. */
3605 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3607 #define ldlang_undef_chain_list_head entry_symbol.next
3610 ldlang_add_undef (const char *const name
, bfd_boolean cmdline
)
3612 ldlang_undef_chain_list_type
*new_undef
;
3614 undef_from_cmdline
= undef_from_cmdline
|| cmdline
;
3615 new_undef
= stat_alloc (sizeof (*new_undef
));
3616 new_undef
->next
= ldlang_undef_chain_list_head
;
3617 ldlang_undef_chain_list_head
= new_undef
;
3619 new_undef
->name
= xstrdup (name
);
3621 if (link_info
.output_bfd
!= NULL
)
3622 insert_undefined (new_undef
->name
);
3625 /* Insert NAME as undefined in the symbol table. */
3628 insert_undefined (const char *name
)
3630 struct bfd_link_hash_entry
*h
;
3632 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
3634 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
3635 if (h
->type
== bfd_link_hash_new
)
3637 h
->type
= bfd_link_hash_undefined
;
3638 h
->u
.undef
.abfd
= NULL
;
3639 h
->non_ir_ref_regular
= TRUE
;
3640 if (is_elf_hash_table (link_info
.hash
))
3641 ((struct elf_link_hash_entry
*) h
)->mark
= 1;
3642 bfd_link_add_undef (link_info
.hash
, h
);
3646 /* Run through the list of undefineds created above and place them
3647 into the linker hash table as undefined symbols belonging to the
3651 lang_place_undefineds (void)
3653 ldlang_undef_chain_list_type
*ptr
;
3655 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3656 insert_undefined (ptr
->name
);
3659 /* Structure used to build the list of symbols that the user has required
3662 struct require_defined_symbol
3665 struct require_defined_symbol
*next
;
3668 /* The list of symbols that the user has required be defined. */
3670 static struct require_defined_symbol
*require_defined_symbol_list
;
3672 /* Add a new symbol NAME to the list of symbols that are required to be
3676 ldlang_add_require_defined (const char *const name
)
3678 struct require_defined_symbol
*ptr
;
3680 ldlang_add_undef (name
, TRUE
);
3681 ptr
= stat_alloc (sizeof (*ptr
));
3682 ptr
->next
= require_defined_symbol_list
;
3683 ptr
->name
= strdup (name
);
3684 require_defined_symbol_list
= ptr
;
3687 /* Check that all symbols the user required to be defined, are defined,
3688 raise an error if we find a symbol that is not defined. */
3691 ldlang_check_require_defined_symbols (void)
3693 struct require_defined_symbol
*ptr
;
3695 for (ptr
= require_defined_symbol_list
; ptr
!= NULL
; ptr
= ptr
->next
)
3697 struct bfd_link_hash_entry
*h
;
3699 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
,
3700 FALSE
, FALSE
, TRUE
);
3702 || (h
->type
!= bfd_link_hash_defined
3703 && h
->type
!= bfd_link_hash_defweak
))
3704 einfo(_("%X%P: required symbol `%s' not defined\n"), ptr
->name
);
3708 /* Check for all readonly or some readwrite sections. */
3711 check_input_sections
3712 (lang_statement_union_type
*s
,
3713 lang_output_section_statement_type
*output_section_statement
)
3715 for (; s
!= NULL
; s
= s
->header
.next
)
3717 switch (s
->header
.type
)
3719 case lang_wild_statement_enum
:
3720 walk_wild (&s
->wild_statement
, check_section_callback
,
3721 output_section_statement
);
3722 if (!output_section_statement
->all_input_readonly
)
3725 case lang_constructors_statement_enum
:
3726 check_input_sections (constructor_list
.head
,
3727 output_section_statement
);
3728 if (!output_section_statement
->all_input_readonly
)
3731 case lang_group_statement_enum
:
3732 check_input_sections (s
->group_statement
.children
.head
,
3733 output_section_statement
);
3734 if (!output_section_statement
->all_input_readonly
)
3743 /* Update wildcard statements if needed. */
3746 update_wild_statements (lang_statement_union_type
*s
)
3748 struct wildcard_list
*sec
;
3750 switch (sort_section
)
3760 for (; s
!= NULL
; s
= s
->header
.next
)
3762 switch (s
->header
.type
)
3767 case lang_wild_statement_enum
:
3768 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
3770 /* Don't sort .init/.fini sections. */
3771 if (strcmp (sec
->spec
.name
, ".init") != 0
3772 && strcmp (sec
->spec
.name
, ".fini") != 0)
3773 switch (sec
->spec
.sorted
)
3776 sec
->spec
.sorted
= sort_section
;
3779 if (sort_section
== by_alignment
)
3780 sec
->spec
.sorted
= by_name_alignment
;
3783 if (sort_section
== by_name
)
3784 sec
->spec
.sorted
= by_alignment_name
;
3791 case lang_constructors_statement_enum
:
3792 update_wild_statements (constructor_list
.head
);
3795 case lang_output_section_statement_enum
:
3796 update_wild_statements
3797 (s
->output_section_statement
.children
.head
);
3800 case lang_group_statement_enum
:
3801 update_wild_statements (s
->group_statement
.children
.head
);
3809 /* Open input files and attach to output sections. */
3812 map_input_to_output_sections
3813 (lang_statement_union_type
*s
, const char *target
,
3814 lang_output_section_statement_type
*os
)
3816 for (; s
!= NULL
; s
= s
->header
.next
)
3818 lang_output_section_statement_type
*tos
;
3821 switch (s
->header
.type
)
3823 case lang_wild_statement_enum
:
3824 wild (&s
->wild_statement
, target
, os
);
3826 case lang_constructors_statement_enum
:
3827 map_input_to_output_sections (constructor_list
.head
,
3831 case lang_output_section_statement_enum
:
3832 tos
= &s
->output_section_statement
;
3833 if (tos
->constraint
!= 0)
3835 if (tos
->constraint
!= ONLY_IF_RW
3836 && tos
->constraint
!= ONLY_IF_RO
)
3838 tos
->all_input_readonly
= TRUE
;
3839 check_input_sections (tos
->children
.head
, tos
);
3840 if (tos
->all_input_readonly
!= (tos
->constraint
== ONLY_IF_RO
))
3842 tos
->constraint
= -1;
3846 map_input_to_output_sections (tos
->children
.head
,
3850 case lang_output_statement_enum
:
3852 case lang_target_statement_enum
:
3853 target
= s
->target_statement
.target
;
3855 case lang_group_statement_enum
:
3856 map_input_to_output_sections (s
->group_statement
.children
.head
,
3860 case lang_data_statement_enum
:
3861 /* Make sure that any sections mentioned in the expression
3863 exp_init_os (s
->data_statement
.exp
);
3864 /* The output section gets CONTENTS, ALLOC and LOAD, but
3865 these may be overridden by the script. */
3866 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
;
3867 switch (os
->sectype
)
3869 case normal_section
:
3870 case overlay_section
:
3871 case first_overlay_section
:
3873 case noalloc_section
:
3874 flags
= SEC_HAS_CONTENTS
;
3876 case noload_section
:
3877 if (bfd_get_flavour (link_info
.output_bfd
)
3878 == bfd_target_elf_flavour
)
3879 flags
= SEC_NEVER_LOAD
| SEC_ALLOC
;
3881 flags
= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
;
3884 if (os
->bfd_section
== NULL
)
3885 init_os (os
, flags
);
3887 os
->bfd_section
->flags
|= flags
;
3889 case lang_input_section_enum
:
3891 case lang_fill_statement_enum
:
3892 case lang_object_symbols_statement_enum
:
3893 case lang_reloc_statement_enum
:
3894 case lang_padding_statement_enum
:
3895 case lang_input_statement_enum
:
3896 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3899 case lang_assignment_statement_enum
:
3900 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3903 /* Make sure that any sections mentioned in the assignment
3905 exp_init_os (s
->assignment_statement
.exp
);
3907 case lang_address_statement_enum
:
3908 /* Mark the specified section with the supplied address.
3909 If this section was actually a segment marker, then the
3910 directive is ignored if the linker script explicitly
3911 processed the segment marker. Originally, the linker
3912 treated segment directives (like -Ttext on the
3913 command-line) as section directives. We honor the
3914 section directive semantics for backwards compatibility;
3915 linker scripts that do not specifically check for
3916 SEGMENT_START automatically get the old semantics. */
3917 if (!s
->address_statement
.segment
3918 || !s
->address_statement
.segment
->used
)
3920 const char *name
= s
->address_statement
.section_name
;
3922 /* Create the output section statement here so that
3923 orphans with a set address will be placed after other
3924 script sections. If we let the orphan placement code
3925 place them in amongst other sections then the address
3926 will affect following script sections, which is
3927 likely to surprise naive users. */
3928 tos
= lang_output_section_statement_lookup (name
, 0, TRUE
);
3929 tos
->addr_tree
= s
->address_statement
.address
;
3930 if (tos
->bfd_section
== NULL
)
3934 case lang_insert_statement_enum
:
3940 /* An insert statement snips out all the linker statements from the
3941 start of the list and places them after the output section
3942 statement specified by the insert. This operation is complicated
3943 by the fact that we keep a doubly linked list of output section
3944 statements as well as the singly linked list of all statements.
3945 FIXME someday: Twiddling with the list not only moves statements
3946 from the user's script but also input and group statements that are
3947 built from command line object files and --start-group. We only
3948 get away with this because the list pointers used by file_chain
3949 and input_file_chain are not reordered, and processing via
3950 statement_list after this point mostly ignores input statements.
3951 One exception is the map file, where LOAD and START GROUP/END GROUP
3952 can end up looking odd. */
3955 process_insert_statements (lang_statement_union_type
**start
)
3957 lang_statement_union_type
**s
;
3958 lang_output_section_statement_type
*first_os
= NULL
;
3959 lang_output_section_statement_type
*last_os
= NULL
;
3960 lang_output_section_statement_type
*os
;
3965 if ((*s
)->header
.type
== lang_output_section_statement_enum
)
3967 /* Keep pointers to the first and last output section
3968 statement in the sequence we may be about to move. */
3969 os
= &(*s
)->output_section_statement
;
3971 ASSERT (last_os
== NULL
|| last_os
->next
== os
);
3974 /* Set constraint negative so that lang_output_section_find
3975 won't match this output section statement. At this
3976 stage in linking constraint has values in the range
3977 [-1, ONLY_IN_RW]. */
3978 last_os
->constraint
= -2 - last_os
->constraint
;
3979 if (first_os
== NULL
)
3982 else if ((*s
)->header
.type
== lang_group_statement_enum
)
3984 /* A user might put -T between --start-group and
3985 --end-group. One way this odd construct might arise is
3986 from a wrapper around ld to change library search
3987 behaviour. For example:
3989 exec real_ld --start-group "$@" --end-group
3990 This isn't completely unreasonable so go looking inside a
3991 group statement for insert statements. */
3992 process_insert_statements (&(*s
)->group_statement
.children
.head
);
3994 else if ((*s
)->header
.type
== lang_insert_statement_enum
)
3996 lang_insert_statement_type
*i
= &(*s
)->insert_statement
;
3997 lang_output_section_statement_type
*where
;
3998 lang_statement_union_type
**ptr
;
3999 lang_statement_union_type
*first
;
4001 where
= lang_output_section_find (i
->where
);
4002 if (where
!= NULL
&& i
->is_before
)
4005 where
= where
->prev
;
4006 while (where
!= NULL
&& where
->constraint
< 0);
4010 einfo (_("%F%P: %s not found for insert\n"), i
->where
);
4014 /* Deal with reordering the output section statement list. */
4015 if (last_os
!= NULL
)
4017 asection
*first_sec
, *last_sec
;
4018 struct lang_output_section_statement_struct
**next
;
4020 /* Snip out the output sections we are moving. */
4021 first_os
->prev
->next
= last_os
->next
;
4022 if (last_os
->next
== NULL
)
4024 next
= &first_os
->prev
->next
;
4025 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4028 last_os
->next
->prev
= first_os
->prev
;
4029 /* Add them in at the new position. */
4030 last_os
->next
= where
->next
;
4031 if (where
->next
== NULL
)
4033 next
= &last_os
->next
;
4034 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4037 where
->next
->prev
= last_os
;
4038 first_os
->prev
= where
;
4039 where
->next
= first_os
;
4041 /* Move the bfd sections in the same way. */
4044 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4046 os
->constraint
= -2 - os
->constraint
;
4047 if (os
->bfd_section
!= NULL
4048 && os
->bfd_section
->owner
!= NULL
)
4050 last_sec
= os
->bfd_section
;
4051 if (first_sec
== NULL
)
4052 first_sec
= last_sec
;
4057 if (last_sec
!= NULL
)
4059 asection
*sec
= where
->bfd_section
;
4061 sec
= output_prev_sec_find (where
);
4063 /* The place we want to insert must come after the
4064 sections we are moving. So if we find no
4065 section or if the section is the same as our
4066 last section, then no move is needed. */
4067 if (sec
!= NULL
&& sec
!= last_sec
)
4069 /* Trim them off. */
4070 if (first_sec
->prev
!= NULL
)
4071 first_sec
->prev
->next
= last_sec
->next
;
4073 link_info
.output_bfd
->sections
= last_sec
->next
;
4074 if (last_sec
->next
!= NULL
)
4075 last_sec
->next
->prev
= first_sec
->prev
;
4077 link_info
.output_bfd
->section_last
= first_sec
->prev
;
4079 last_sec
->next
= sec
->next
;
4080 if (sec
->next
!= NULL
)
4081 sec
->next
->prev
= last_sec
;
4083 link_info
.output_bfd
->section_last
= last_sec
;
4084 first_sec
->prev
= sec
;
4085 sec
->next
= first_sec
;
4093 ptr
= insert_os_after (where
);
4094 /* Snip everything from the start of the list, up to and
4095 including the insert statement we are currently processing. */
4097 *start
= (*s
)->header
.next
;
4098 /* Add them back where they belong, minus the insert. */
4101 statement_list
.tail
= s
;
4106 s
= &(*s
)->header
.next
;
4109 /* Undo constraint twiddling. */
4110 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4112 os
->constraint
= -2 - os
->constraint
;
4118 /* An output section might have been removed after its statement was
4119 added. For example, ldemul_before_allocation can remove dynamic
4120 sections if they turn out to be not needed. Clean them up here. */
4123 strip_excluded_output_sections (void)
4125 lang_output_section_statement_type
*os
;
4127 /* Run lang_size_sections (if not already done). */
4128 if (expld
.phase
!= lang_mark_phase_enum
)
4130 expld
.phase
= lang_mark_phase_enum
;
4131 expld
.dataseg
.phase
= exp_seg_none
;
4132 one_lang_size_sections_pass (NULL
, FALSE
);
4133 lang_reset_memory_regions ();
4136 for (os
= &lang_os_list
.head
->output_section_statement
;
4140 asection
*output_section
;
4141 bfd_boolean exclude
;
4143 if (os
->constraint
< 0)
4146 output_section
= os
->bfd_section
;
4147 if (output_section
== NULL
)
4150 exclude
= (output_section
->rawsize
== 0
4151 && (output_section
->flags
& SEC_KEEP
) == 0
4152 && !bfd_section_removed_from_list (link_info
.output_bfd
,
4155 /* Some sections have not yet been sized, notably .gnu.version,
4156 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
4157 input sections, so don't drop output sections that have such
4158 input sections unless they are also marked SEC_EXCLUDE. */
4159 if (exclude
&& output_section
->map_head
.s
!= NULL
)
4163 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
4164 if ((s
->flags
& SEC_EXCLUDE
) == 0
4165 && ((s
->flags
& SEC_LINKER_CREATED
) != 0
4166 || link_info
.emitrelocations
))
4175 /* We don't set bfd_section to NULL since bfd_section of the
4176 removed output section statement may still be used. */
4177 if (!os
->update_dot
)
4179 output_section
->flags
|= SEC_EXCLUDE
;
4180 bfd_section_list_remove (link_info
.output_bfd
, output_section
);
4181 link_info
.output_bfd
->section_count
--;
4186 /* Called from ldwrite to clear out asection.map_head and
4187 asection.map_tail for use as link_orders in ldwrite. */
4190 lang_clear_os_map (void)
4192 lang_output_section_statement_type
*os
;
4194 if (map_head_is_link_order
)
4197 for (os
= &lang_os_list
.head
->output_section_statement
;
4201 asection
*output_section
;
4203 if (os
->constraint
< 0)
4206 output_section
= os
->bfd_section
;
4207 if (output_section
== NULL
)
4210 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
4211 output_section
->map_head
.link_order
= NULL
;
4212 output_section
->map_tail
.link_order
= NULL
;
4215 /* Stop future calls to lang_add_section from messing with map_head
4216 and map_tail link_order fields. */
4217 map_head_is_link_order
= TRUE
;
4221 print_output_section_statement
4222 (lang_output_section_statement_type
*output_section_statement
)
4224 asection
*section
= output_section_statement
->bfd_section
;
4227 if (output_section_statement
!= abs_output_section
)
4229 minfo ("\n%s", output_section_statement
->name
);
4231 if (section
!= NULL
)
4233 print_dot
= section
->vma
;
4235 len
= strlen (output_section_statement
->name
);
4236 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4241 while (len
< SECTION_NAME_MAP_LENGTH
)
4247 minfo ("0x%V %W", section
->vma
, TO_ADDR (section
->size
));
4249 if (section
->vma
!= section
->lma
)
4250 minfo (_(" load address 0x%V"), section
->lma
);
4252 if (output_section_statement
->update_dot_tree
!= NULL
)
4253 exp_fold_tree (output_section_statement
->update_dot_tree
,
4254 bfd_abs_section_ptr
, &print_dot
);
4260 print_statement_list (output_section_statement
->children
.head
,
4261 output_section_statement
);
4265 print_assignment (lang_assignment_statement_type
*assignment
,
4266 lang_output_section_statement_type
*output_section
)
4273 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4276 if (assignment
->exp
->type
.node_class
== etree_assert
)
4279 tree
= assignment
->exp
->assert_s
.child
;
4283 const char *dst
= assignment
->exp
->assign
.dst
;
4285 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
4286 tree
= assignment
->exp
;
4289 osec
= output_section
->bfd_section
;
4291 osec
= bfd_abs_section_ptr
;
4293 if (assignment
->exp
->type
.node_class
!= etree_provide
)
4294 exp_fold_tree (tree
, osec
, &print_dot
);
4296 expld
.result
.valid_p
= FALSE
;
4298 if (expld
.result
.valid_p
)
4302 if (assignment
->exp
->type
.node_class
== etree_assert
4304 || expld
.assign_name
!= NULL
)
4306 value
= expld
.result
.value
;
4308 if (expld
.result
.section
!= NULL
)
4309 value
+= expld
.result
.section
->vma
;
4311 minfo ("0x%V", value
);
4317 struct bfd_link_hash_entry
*h
;
4319 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
4320 FALSE
, FALSE
, TRUE
);
4322 && (h
->type
== bfd_link_hash_defined
4323 || h
->type
== bfd_link_hash_defweak
))
4325 value
= h
->u
.def
.value
;
4326 value
+= h
->u
.def
.section
->output_section
->vma
;
4327 value
+= h
->u
.def
.section
->output_offset
;
4329 minfo ("[0x%V]", value
);
4332 minfo ("[unresolved]");
4337 if (assignment
->exp
->type
.node_class
== etree_provide
)
4338 minfo ("[!provide]");
4345 expld
.assign_name
= NULL
;
4348 exp_print_tree (assignment
->exp
);
4353 print_input_statement (lang_input_statement_type
*statm
)
4355 if (statm
->filename
!= NULL
)
4356 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
4359 /* Print all symbols defined in a particular section. This is called
4360 via bfd_link_hash_traverse, or by print_all_symbols. */
4363 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
4365 asection
*sec
= (asection
*) ptr
;
4367 if ((hash_entry
->type
== bfd_link_hash_defined
4368 || hash_entry
->type
== bfd_link_hash_defweak
)
4369 && sec
== hash_entry
->u
.def
.section
)
4373 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4376 (hash_entry
->u
.def
.value
4377 + hash_entry
->u
.def
.section
->output_offset
4378 + hash_entry
->u
.def
.section
->output_section
->vma
));
4380 minfo (" %pT\n", hash_entry
->root
.string
);
4387 hash_entry_addr_cmp (const void *a
, const void *b
)
4389 const struct bfd_link_hash_entry
*l
= *(const struct bfd_link_hash_entry
**)a
;
4390 const struct bfd_link_hash_entry
*r
= *(const struct bfd_link_hash_entry
**)b
;
4392 if (l
->u
.def
.value
< r
->u
.def
.value
)
4394 else if (l
->u
.def
.value
> r
->u
.def
.value
)
4401 print_all_symbols (asection
*sec
)
4403 input_section_userdata_type
*ud
4404 = (input_section_userdata_type
*) get_userdata (sec
);
4405 struct map_symbol_def
*def
;
4406 struct bfd_link_hash_entry
**entries
;
4412 *ud
->map_symbol_def_tail
= 0;
4414 /* Sort the symbols by address. */
4415 entries
= (struct bfd_link_hash_entry
**)
4416 obstack_alloc (&map_obstack
,
4417 ud
->map_symbol_def_count
* sizeof (*entries
));
4419 for (i
= 0, def
= ud
->map_symbol_def_head
; def
; def
= def
->next
, i
++)
4420 entries
[i
] = def
->entry
;
4422 qsort (entries
, ud
->map_symbol_def_count
, sizeof (*entries
),
4423 hash_entry_addr_cmp
);
4425 /* Print the symbols. */
4426 for (i
= 0; i
< ud
->map_symbol_def_count
; i
++)
4427 print_one_symbol (entries
[i
], sec
);
4429 obstack_free (&map_obstack
, entries
);
4432 /* Print information about an input section to the map file. */
4435 print_input_section (asection
*i
, bfd_boolean is_discarded
)
4437 bfd_size_type size
= i
->size
;
4444 minfo ("%s", i
->name
);
4446 len
= 1 + strlen (i
->name
);
4447 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4452 while (len
< SECTION_NAME_MAP_LENGTH
)
4458 if (i
->output_section
!= NULL
4459 && i
->output_section
->owner
== link_info
.output_bfd
)
4460 addr
= i
->output_section
->vma
+ i
->output_offset
;
4468 minfo ("0x%V %W %pB\n", addr
, size
, i
->owner
);
4470 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
4472 len
= SECTION_NAME_MAP_LENGTH
+ 3;
4484 minfo (_("%W (size before relaxing)\n"), i
->rawsize
);
4487 if (i
->output_section
!= NULL
4488 && i
->output_section
->owner
== link_info
.output_bfd
)
4490 if (link_info
.reduce_memory_overheads
)
4491 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, i
);
4493 print_all_symbols (i
);
4495 /* Update print_dot, but make sure that we do not move it
4496 backwards - this could happen if we have overlays and a
4497 later overlay is shorter than an earier one. */
4498 if (addr
+ TO_ADDR (size
) > print_dot
)
4499 print_dot
= addr
+ TO_ADDR (size
);
4504 print_fill_statement (lang_fill_statement_type
*fill
)
4508 fputs (" FILL mask 0x", config
.map_file
);
4509 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
4510 fprintf (config
.map_file
, "%02x", *p
);
4511 fputs ("\n", config
.map_file
);
4515 print_data_statement (lang_data_statement_type
*data
)
4523 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4526 addr
= data
->output_offset
;
4527 if (data
->output_section
!= NULL
)
4528 addr
+= data
->output_section
->vma
;
4556 if (size
< TO_SIZE ((unsigned) 1))
4557 size
= TO_SIZE ((unsigned) 1);
4558 minfo ("0x%V %W %s 0x%v", addr
, TO_ADDR (size
), name
, data
->value
);
4560 if (data
->exp
->type
.node_class
!= etree_value
)
4563 exp_print_tree (data
->exp
);
4568 print_dot
= addr
+ TO_ADDR (size
);
4571 /* Print an address statement. These are generated by options like
4575 print_address_statement (lang_address_statement_type
*address
)
4577 minfo (_("Address of section %s set to "), address
->section_name
);
4578 exp_print_tree (address
->address
);
4582 /* Print a reloc statement. */
4585 print_reloc_statement (lang_reloc_statement_type
*reloc
)
4592 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4595 addr
= reloc
->output_offset
;
4596 if (reloc
->output_section
!= NULL
)
4597 addr
+= reloc
->output_section
->vma
;
4599 size
= bfd_get_reloc_size (reloc
->howto
);
4601 minfo ("0x%V %W RELOC %s ", addr
, TO_ADDR (size
), reloc
->howto
->name
);
4603 if (reloc
->name
!= NULL
)
4604 minfo ("%s+", reloc
->name
);
4606 minfo ("%s+", reloc
->section
->name
);
4608 exp_print_tree (reloc
->addend_exp
);
4612 print_dot
= addr
+ TO_ADDR (size
);
4616 print_padding_statement (lang_padding_statement_type
*s
)
4624 len
= sizeof " *fill*" - 1;
4625 while (len
< SECTION_NAME_MAP_LENGTH
)
4631 addr
= s
->output_offset
;
4632 if (s
->output_section
!= NULL
)
4633 addr
+= s
->output_section
->vma
;
4634 minfo ("0x%V %W ", addr
, TO_ADDR (s
->size
));
4636 if (s
->fill
->size
!= 0)
4640 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
4641 fprintf (config
.map_file
, "%02x", *p
);
4646 print_dot
= addr
+ TO_ADDR (s
->size
);
4650 print_wild_statement (lang_wild_statement_type
*w
,
4651 lang_output_section_statement_type
*os
)
4653 struct wildcard_list
*sec
;
4657 if (w
->exclude_name_list
)
4660 minfo ("EXCLUDE_FILE(%s", w
->exclude_name_list
->name
);
4661 for (tmp
= w
->exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4662 minfo (" %s", tmp
->name
);
4666 if (w
->filenames_sorted
)
4667 minfo ("SORT_BY_NAME(");
4668 if (w
->filename
!= NULL
)
4669 minfo ("%s", w
->filename
);
4672 if (w
->filenames_sorted
)
4676 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
4678 int closing_paren
= 0;
4680 switch (sec
->spec
.sorted
)
4686 minfo ("SORT_BY_NAME(");
4691 minfo ("SORT_BY_ALIGNMENT(");
4695 case by_name_alignment
:
4696 minfo ("SORT_BY_NAME(SORT_BY_ALIGNMENT(");
4700 case by_alignment_name
:
4701 minfo ("SORT_BY_ALIGNMENT(SORT_BY_NAME(");
4706 minfo ("SORT_NONE(");
4710 case by_init_priority
:
4711 minfo ("SORT_BY_INIT_PRIORITY(");
4716 if (sec
->spec
.exclude_name_list
!= NULL
)
4719 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
4720 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4721 minfo (" %s", tmp
->name
);
4724 if (sec
->spec
.name
!= NULL
)
4725 minfo ("%s", sec
->spec
.name
);
4728 for (;closing_paren
> 0; closing_paren
--)
4737 print_statement_list (w
->children
.head
, os
);
4740 /* Print a group statement. */
4743 print_group (lang_group_statement_type
*s
,
4744 lang_output_section_statement_type
*os
)
4746 fprintf (config
.map_file
, "START GROUP\n");
4747 print_statement_list (s
->children
.head
, os
);
4748 fprintf (config
.map_file
, "END GROUP\n");
4751 /* Print the list of statements in S.
4752 This can be called for any statement type. */
4755 print_statement_list (lang_statement_union_type
*s
,
4756 lang_output_section_statement_type
*os
)
4760 print_statement (s
, os
);
4765 /* Print the first statement in statement list S.
4766 This can be called for any statement type. */
4769 print_statement (lang_statement_union_type
*s
,
4770 lang_output_section_statement_type
*os
)
4772 switch (s
->header
.type
)
4775 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
4778 case lang_constructors_statement_enum
:
4779 if (constructor_list
.head
!= NULL
)
4781 if (constructors_sorted
)
4782 minfo (" SORT (CONSTRUCTORS)\n");
4784 minfo (" CONSTRUCTORS\n");
4785 print_statement_list (constructor_list
.head
, os
);
4788 case lang_wild_statement_enum
:
4789 print_wild_statement (&s
->wild_statement
, os
);
4791 case lang_address_statement_enum
:
4792 print_address_statement (&s
->address_statement
);
4794 case lang_object_symbols_statement_enum
:
4795 minfo (" CREATE_OBJECT_SYMBOLS\n");
4797 case lang_fill_statement_enum
:
4798 print_fill_statement (&s
->fill_statement
);
4800 case lang_data_statement_enum
:
4801 print_data_statement (&s
->data_statement
);
4803 case lang_reloc_statement_enum
:
4804 print_reloc_statement (&s
->reloc_statement
);
4806 case lang_input_section_enum
:
4807 print_input_section (s
->input_section
.section
, FALSE
);
4809 case lang_padding_statement_enum
:
4810 print_padding_statement (&s
->padding_statement
);
4812 case lang_output_section_statement_enum
:
4813 print_output_section_statement (&s
->output_section_statement
);
4815 case lang_assignment_statement_enum
:
4816 print_assignment (&s
->assignment_statement
, os
);
4818 case lang_target_statement_enum
:
4819 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
4821 case lang_output_statement_enum
:
4822 minfo ("OUTPUT(%s", s
->output_statement
.name
);
4823 if (output_target
!= NULL
)
4824 minfo (" %s", output_target
);
4827 case lang_input_statement_enum
:
4828 print_input_statement (&s
->input_statement
);
4830 case lang_group_statement_enum
:
4831 print_group (&s
->group_statement
, os
);
4833 case lang_insert_statement_enum
:
4834 minfo ("INSERT %s %s\n",
4835 s
->insert_statement
.is_before
? "BEFORE" : "AFTER",
4836 s
->insert_statement
.where
);
4842 print_statements (void)
4844 print_statement_list (statement_list
.head
, abs_output_section
);
4847 /* Print the first N statements in statement list S to STDERR.
4848 If N == 0, nothing is printed.
4849 If N < 0, the entire list is printed.
4850 Intended to be called from GDB. */
4853 dprint_statement (lang_statement_union_type
*s
, int n
)
4855 FILE *map_save
= config
.map_file
;
4857 config
.map_file
= stderr
;
4860 print_statement_list (s
, abs_output_section
);
4863 while (s
&& --n
>= 0)
4865 print_statement (s
, abs_output_section
);
4870 config
.map_file
= map_save
;
4874 insert_pad (lang_statement_union_type
**ptr
,
4876 bfd_size_type alignment_needed
,
4877 asection
*output_section
,
4880 static fill_type zero_fill
;
4881 lang_statement_union_type
*pad
= NULL
;
4883 if (ptr
!= &statement_list
.head
)
4884 pad
= ((lang_statement_union_type
*)
4885 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
4887 && pad
->header
.type
== lang_padding_statement_enum
4888 && pad
->padding_statement
.output_section
== output_section
)
4890 /* Use the existing pad statement. */
4892 else if ((pad
= *ptr
) != NULL
4893 && pad
->header
.type
== lang_padding_statement_enum
4894 && pad
->padding_statement
.output_section
== output_section
)
4896 /* Use the existing pad statement. */
4900 /* Make a new padding statement, linked into existing chain. */
4901 pad
= stat_alloc (sizeof (lang_padding_statement_type
));
4902 pad
->header
.next
= *ptr
;
4904 pad
->header
.type
= lang_padding_statement_enum
;
4905 pad
->padding_statement
.output_section
= output_section
;
4908 pad
->padding_statement
.fill
= fill
;
4910 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
4911 pad
->padding_statement
.size
= alignment_needed
;
4912 if (!(output_section
->flags
& SEC_FIXED_SIZE
))
4913 output_section
->size
= TO_SIZE (dot
+ TO_ADDR (alignment_needed
)
4914 - output_section
->vma
);
4917 /* Work out how much this section will move the dot point. */
4921 (lang_statement_union_type
**this_ptr
,
4922 lang_output_section_statement_type
*output_section_statement
,
4926 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
4927 asection
*i
= is
->section
;
4928 asection
*o
= output_section_statement
->bfd_section
;
4930 if (i
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
4931 i
->output_offset
= i
->vma
- o
->vma
;
4932 else if (((i
->flags
& SEC_EXCLUDE
) != 0)
4933 || output_section_statement
->ignored
)
4934 i
->output_offset
= dot
- o
->vma
;
4937 bfd_size_type alignment_needed
;
4939 /* Align this section first to the input sections requirement,
4940 then to the output section's requirement. If this alignment
4941 is greater than any seen before, then record it too. Perform
4942 the alignment by inserting a magic 'padding' statement. */
4944 if (output_section_statement
->subsection_alignment
!= NULL
)
4946 = exp_get_power (output_section_statement
->subsection_alignment
,
4947 "subsection alignment");
4949 if (o
->alignment_power
< i
->alignment_power
)
4950 o
->alignment_power
= i
->alignment_power
;
4952 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
4954 if (alignment_needed
!= 0)
4956 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
4957 dot
+= alignment_needed
;
4960 /* Remember where in the output section this input section goes. */
4961 i
->output_offset
= dot
- o
->vma
;
4963 /* Mark how big the output section must be to contain this now. */
4964 dot
+= TO_ADDR (i
->size
);
4965 if (!(o
->flags
& SEC_FIXED_SIZE
))
4966 o
->size
= TO_SIZE (dot
- o
->vma
);
4979 sort_sections_by_lma (const void *arg1
, const void *arg2
)
4981 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
4982 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
4984 if (sec1
->lma
< sec2
->lma
)
4986 else if (sec1
->lma
> sec2
->lma
)
4988 else if (sec1
->id
< sec2
->id
)
4990 else if (sec1
->id
> sec2
->id
)
4997 sort_sections_by_vma (const void *arg1
, const void *arg2
)
4999 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
5000 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
5002 if (sec1
->vma
< sec2
->vma
)
5004 else if (sec1
->vma
> sec2
->vma
)
5006 else if (sec1
->id
< sec2
->id
)
5008 else if (sec1
->id
> sec2
->id
)
5014 #define IS_TBSS(s) \
5015 ((s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == SEC_THREAD_LOCAL)
5017 #define IGNORE_SECTION(s) \
5018 ((s->flags & SEC_ALLOC) == 0 || IS_TBSS (s))
5020 /* Check to see if any allocated sections overlap with other allocated
5021 sections. This can happen if a linker script specifies the output
5022 section addresses of the two sections. Also check whether any memory
5023 region has overflowed. */
5026 lang_check_section_addresses (void)
5029 struct check_sec
*sections
;
5034 bfd_vma p_start
= 0;
5036 lang_memory_region_type
*m
;
5037 bfd_boolean overlays
;
5039 /* Detect address space overflow on allocated sections. */
5040 addr_mask
= ((bfd_vma
) 1 <<
5041 (bfd_arch_bits_per_address (link_info
.output_bfd
) - 1)) - 1;
5042 addr_mask
= (addr_mask
<< 1) + 1;
5043 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5044 if ((s
->flags
& SEC_ALLOC
) != 0)
5046 s_end
= (s
->vma
+ s
->size
) & addr_mask
;
5047 if (s_end
!= 0 && s_end
< (s
->vma
& addr_mask
))
5048 einfo (_("%X%P: section %s VMA wraps around address space\n"),
5052 s_end
= (s
->lma
+ s
->size
) & addr_mask
;
5053 if (s_end
!= 0 && s_end
< (s
->lma
& addr_mask
))
5054 einfo (_("%X%P: section %s LMA wraps around address space\n"),
5059 if (bfd_count_sections (link_info
.output_bfd
) <= 1)
5062 count
= bfd_count_sections (link_info
.output_bfd
);
5063 sections
= XNEWVEC (struct check_sec
, count
);
5065 /* Scan all sections in the output list. */
5067 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5069 if (IGNORE_SECTION (s
)
5073 sections
[count
].sec
= s
;
5074 sections
[count
].warned
= FALSE
;
5084 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_lma
);
5086 /* First check section LMAs. There should be no overlap of LMAs on
5087 loadable sections, even with overlays. */
5088 for (p
= NULL
, i
= 0; i
< count
; i
++)
5090 s
= sections
[i
].sec
;
5091 if ((s
->flags
& SEC_LOAD
) != 0)
5094 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5096 /* Look for an overlap. We have sorted sections by lma, so
5097 we know that s_start >= p_start. Besides the obvious
5098 case of overlap when the current section starts before
5099 the previous one ends, we also must have overlap if the
5100 previous section wraps around the address space. */
5102 && (s_start
<= p_end
5103 || p_end
< p_start
))
5105 einfo (_("%X%P: section %s LMA [%V,%V]"
5106 " overlaps section %s LMA [%V,%V]\n"),
5107 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5108 sections
[i
].warned
= TRUE
;
5116 /* If any non-zero size allocated section (excluding tbss) starts at
5117 exactly the same VMA as another such section, then we have
5118 overlays. Overlays generated by the OVERLAY keyword will have
5119 this property. It is possible to intentionally generate overlays
5120 that fail this test, but it would be unusual. */
5121 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_vma
);
5123 p_start
= sections
[0].sec
->vma
;
5124 for (i
= 1; i
< count
; i
++)
5126 s_start
= sections
[i
].sec
->vma
;
5127 if (p_start
== s_start
)
5135 /* Now check section VMAs if no overlays were detected. */
5138 for (p
= NULL
, i
= 0; i
< count
; i
++)
5140 s
= sections
[i
].sec
;
5142 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5145 && !sections
[i
].warned
5146 && (s_start
<= p_end
5147 || p_end
< p_start
))
5148 einfo (_("%X%P: section %s VMA [%V,%V]"
5149 " overlaps section %s VMA [%V,%V]\n"),
5150 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5159 /* If any memory region has overflowed, report by how much.
5160 We do not issue this diagnostic for regions that had sections
5161 explicitly placed outside their bounds; os_region_check's
5162 diagnostics are adequate for that case.
5164 FIXME: It is conceivable that m->current - (m->origin + m->length)
5165 might overflow a 32-bit integer. There is, alas, no way to print
5166 a bfd_vma quantity in decimal. */
5167 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
5168 if (m
->had_full_message
)
5170 unsigned long over
= m
->current
- (m
->origin
+ m
->length
);
5171 einfo (ngettext ("%X%P: region `%s' overflowed by %lu byte\n",
5172 "%X%P: region `%s' overflowed by %lu bytes\n",
5174 m
->name_list
.name
, over
);
5178 /* Make sure the new address is within the region. We explicitly permit the
5179 current address to be at the exact end of the region when the address is
5180 non-zero, in case the region is at the end of addressable memory and the
5181 calculation wraps around. */
5184 os_region_check (lang_output_section_statement_type
*os
,
5185 lang_memory_region_type
*region
,
5189 if ((region
->current
< region
->origin
5190 || (region
->current
- region
->origin
> region
->length
))
5191 && ((region
->current
!= region
->origin
+ region
->length
)
5196 einfo (_("%X%P: address 0x%v of %pB section `%s'"
5197 " is not within region `%s'\n"),
5199 os
->bfd_section
->owner
,
5200 os
->bfd_section
->name
,
5201 region
->name_list
.name
);
5203 else if (!region
->had_full_message
)
5205 region
->had_full_message
= TRUE
;
5207 einfo (_("%X%P: %pB section `%s' will not fit in region `%s'\n"),
5208 os
->bfd_section
->owner
,
5209 os
->bfd_section
->name
,
5210 region
->name_list
.name
);
5216 ldlang_check_relro_region (lang_statement_union_type
*s
,
5217 seg_align_type
*seg
)
5219 if (seg
->relro
== exp_seg_relro_start
)
5221 if (!seg
->relro_start_stat
)
5222 seg
->relro_start_stat
= s
;
5225 ASSERT (seg
->relro_start_stat
== s
);
5228 else if (seg
->relro
== exp_seg_relro_end
)
5230 if (!seg
->relro_end_stat
)
5231 seg
->relro_end_stat
= s
;
5234 ASSERT (seg
->relro_end_stat
== s
);
5239 /* Set the sizes for all the output sections. */
5242 lang_size_sections_1
5243 (lang_statement_union_type
**prev
,
5244 lang_output_section_statement_type
*output_section_statement
,
5248 bfd_boolean check_regions
)
5250 lang_statement_union_type
*s
;
5252 /* Size up the sections from their constituent parts. */
5253 for (s
= *prev
; s
!= NULL
; s
= s
->header
.next
)
5255 switch (s
->header
.type
)
5257 case lang_output_section_statement_enum
:
5259 bfd_vma newdot
, after
, dotdelta
;
5260 lang_output_section_statement_type
*os
;
5261 lang_memory_region_type
*r
;
5262 int section_alignment
= 0;
5264 os
= &s
->output_section_statement
;
5265 if (os
->constraint
== -1)
5268 /* FIXME: We shouldn't need to zero section vmas for ld -r
5269 here, in lang_insert_orphan, or in the default linker scripts.
5270 This is covering for coff backend linker bugs. See PR6945. */
5271 if (os
->addr_tree
== NULL
5272 && bfd_link_relocatable (&link_info
)
5273 && (bfd_get_flavour (link_info
.output_bfd
)
5274 == bfd_target_coff_flavour
))
5275 os
->addr_tree
= exp_intop (0);
5276 if (os
->addr_tree
!= NULL
)
5278 os
->processed_vma
= FALSE
;
5279 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
5281 if (expld
.result
.valid_p
)
5283 dot
= expld
.result
.value
;
5284 if (expld
.result
.section
!= NULL
)
5285 dot
+= expld
.result
.section
->vma
;
5287 else if (expld
.phase
!= lang_mark_phase_enum
)
5288 einfo (_("%F%P:%pS: non constant or forward reference"
5289 " address expression for section %s\n"),
5290 os
->addr_tree
, os
->name
);
5293 if (os
->bfd_section
== NULL
)
5294 /* This section was removed or never actually created. */
5297 /* If this is a COFF shared library section, use the size and
5298 address from the input section. FIXME: This is COFF
5299 specific; it would be cleaner if there were some other way
5300 to do this, but nothing simple comes to mind. */
5301 if (((bfd_get_flavour (link_info
.output_bfd
)
5302 == bfd_target_ecoff_flavour
)
5303 || (bfd_get_flavour (link_info
.output_bfd
)
5304 == bfd_target_coff_flavour
))
5305 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
5309 if (os
->children
.head
== NULL
5310 || os
->children
.head
->header
.next
!= NULL
5311 || (os
->children
.head
->header
.type
5312 != lang_input_section_enum
))
5313 einfo (_("%X%P: internal error on COFF shared library"
5314 " section %s\n"), os
->name
);
5316 input
= os
->children
.head
->input_section
.section
;
5317 bfd_set_section_vma (os
->bfd_section
->owner
,
5319 bfd_section_vma (input
->owner
, input
));
5320 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5321 os
->bfd_section
->size
= input
->size
;
5327 if (bfd_is_abs_section (os
->bfd_section
))
5329 /* No matter what happens, an abs section starts at zero. */
5330 ASSERT (os
->bfd_section
->vma
== 0);
5334 if (os
->addr_tree
== NULL
)
5336 /* No address specified for this section, get one
5337 from the region specification. */
5338 if (os
->region
== NULL
5339 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
5340 && os
->region
->name_list
.name
[0] == '*'
5341 && strcmp (os
->region
->name_list
.name
,
5342 DEFAULT_MEMORY_REGION
) == 0))
5344 os
->region
= lang_memory_default (os
->bfd_section
);
5347 /* If a loadable section is using the default memory
5348 region, and some non default memory regions were
5349 defined, issue an error message. */
5351 && !IGNORE_SECTION (os
->bfd_section
)
5352 && !bfd_link_relocatable (&link_info
)
5354 && strcmp (os
->region
->name_list
.name
,
5355 DEFAULT_MEMORY_REGION
) == 0
5356 && lang_memory_region_list
!= NULL
5357 && (strcmp (lang_memory_region_list
->name_list
.name
,
5358 DEFAULT_MEMORY_REGION
) != 0
5359 || lang_memory_region_list
->next
!= NULL
)
5360 && expld
.phase
!= lang_mark_phase_enum
)
5362 /* By default this is an error rather than just a
5363 warning because if we allocate the section to the
5364 default memory region we can end up creating an
5365 excessively large binary, or even seg faulting when
5366 attempting to perform a negative seek. See
5367 sources.redhat.com/ml/binutils/2003-04/msg00423.html
5368 for an example of this. This behaviour can be
5369 overridden by the using the --no-check-sections
5371 if (command_line
.check_section_addresses
)
5372 einfo (_("%F%P: error: no memory region specified"
5373 " for loadable section `%s'\n"),
5374 bfd_get_section_name (link_info
.output_bfd
,
5377 einfo (_("%P: warning: no memory region specified"
5378 " for loadable section `%s'\n"),
5379 bfd_get_section_name (link_info
.output_bfd
,
5383 newdot
= os
->region
->current
;
5384 section_alignment
= os
->bfd_section
->alignment_power
;
5387 section_alignment
= exp_get_power (os
->section_alignment
,
5388 "section alignment");
5390 /* Align to what the section needs. */
5391 if (section_alignment
> 0)
5393 bfd_vma savedot
= newdot
;
5394 newdot
= align_power (newdot
, section_alignment
);
5396 dotdelta
= newdot
- savedot
;
5398 && (config
.warn_section_align
5399 || os
->addr_tree
!= NULL
)
5400 && expld
.phase
!= lang_mark_phase_enum
)
5401 einfo (ngettext ("%P: warning: changing start of "
5402 "section %s by %lu byte\n",
5403 "%P: warning: changing start of "
5404 "section %s by %lu bytes\n",
5405 (unsigned long) dotdelta
),
5406 os
->name
, (unsigned long) dotdelta
);
5409 bfd_set_section_vma (0, os
->bfd_section
, newdot
);
5411 os
->bfd_section
->output_offset
= 0;
5414 lang_size_sections_1 (&os
->children
.head
, os
,
5415 os
->fill
, newdot
, relax
, check_regions
);
5417 os
->processed_vma
= TRUE
;
5419 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5420 /* Except for some special linker created sections,
5421 no output section should change from zero size
5422 after strip_excluded_output_sections. A non-zero
5423 size on an ignored section indicates that some
5424 input section was not sized early enough. */
5425 ASSERT (os
->bfd_section
->size
== 0);
5428 dot
= os
->bfd_section
->vma
;
5430 /* Put the section within the requested block size, or
5431 align at the block boundary. */
5433 + TO_ADDR (os
->bfd_section
->size
)
5434 + os
->block_value
- 1)
5435 & - (bfd_vma
) os
->block_value
);
5437 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5438 os
->bfd_section
->size
= TO_SIZE (after
5439 - os
->bfd_section
->vma
);
5442 /* Set section lma. */
5445 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
5449 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
5450 os
->bfd_section
->lma
= lma
;
5452 else if (os
->lma_region
!= NULL
)
5454 bfd_vma lma
= os
->lma_region
->current
;
5456 if (os
->align_lma_with_input
)
5460 /* When LMA_REGION is the same as REGION, align the LMA
5461 as we did for the VMA, possibly including alignment
5462 from the bfd section. If a different region, then
5463 only align according to the value in the output
5465 if (os
->lma_region
!= os
->region
)
5466 section_alignment
= exp_get_power (os
->section_alignment
,
5467 "section alignment");
5468 if (section_alignment
> 0)
5469 lma
= align_power (lma
, section_alignment
);
5471 os
->bfd_section
->lma
= lma
;
5473 else if (r
->last_os
!= NULL
5474 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5479 last
= r
->last_os
->output_section_statement
.bfd_section
;
5481 /* A backwards move of dot should be accompanied by
5482 an explicit assignment to the section LMA (ie.
5483 os->load_base set) because backwards moves can
5484 create overlapping LMAs. */
5486 && os
->bfd_section
->size
!= 0
5487 && dot
+ TO_ADDR (os
->bfd_section
->size
) <= last
->vma
)
5489 /* If dot moved backwards then leave lma equal to
5490 vma. This is the old default lma, which might
5491 just happen to work when the backwards move is
5492 sufficiently large. Nag if this changes anything,
5493 so people can fix their linker scripts. */
5495 if (last
->vma
!= last
->lma
)
5496 einfo (_("%P: warning: dot moved backwards "
5497 "before `%s'\n"), os
->name
);
5501 /* If this is an overlay, set the current lma to that
5502 at the end of the previous section. */
5503 if (os
->sectype
== overlay_section
)
5504 lma
= last
->lma
+ TO_ADDR (last
->size
);
5506 /* Otherwise, keep the same lma to vma relationship
5507 as the previous section. */
5509 lma
= dot
+ last
->lma
- last
->vma
;
5511 if (section_alignment
> 0)
5512 lma
= align_power (lma
, section_alignment
);
5513 os
->bfd_section
->lma
= lma
;
5516 os
->processed_lma
= TRUE
;
5518 /* Keep track of normal sections using the default
5519 lma region. We use this to set the lma for
5520 following sections. Overlays or other linker
5521 script assignment to lma might mean that the
5522 default lma == vma is incorrect.
5523 To avoid warnings about dot moving backwards when using
5524 -Ttext, don't start tracking sections until we find one
5525 of non-zero size or with lma set differently to vma.
5526 Do this tracking before we short-cut the loop so that we
5527 track changes for the case where the section size is zero,
5528 but the lma is set differently to the vma. This is
5529 important, if an orphan section is placed after an
5530 otherwise empty output section that has an explicit lma
5531 set, we want that lma reflected in the orphans lma. */
5532 if (((!IGNORE_SECTION (os
->bfd_section
)
5533 && (os
->bfd_section
->size
!= 0
5534 || (r
->last_os
== NULL
5535 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
5536 || (r
->last_os
!= NULL
5537 && dot
>= (r
->last_os
->output_section_statement
5538 .bfd_section
->vma
))))
5539 || os
->sectype
== first_overlay_section
)
5540 && os
->lma_region
== NULL
5541 && !bfd_link_relocatable (&link_info
))
5544 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5547 /* .tbss sections effectively have zero size. */
5548 if (!IS_TBSS (os
->bfd_section
)
5549 || bfd_link_relocatable (&link_info
))
5550 dotdelta
= TO_ADDR (os
->bfd_section
->size
);
5555 if (os
->update_dot_tree
!= 0)
5556 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5558 /* Update dot in the region ?
5559 We only do this if the section is going to be allocated,
5560 since unallocated sections do not contribute to the region's
5561 overall size in memory. */
5562 if (os
->region
!= NULL
5563 && (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)))
5565 os
->region
->current
= dot
;
5568 /* Make sure the new address is within the region. */
5569 os_region_check (os
, os
->region
, os
->addr_tree
,
5570 os
->bfd_section
->vma
);
5572 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
5573 && ((os
->bfd_section
->flags
& SEC_LOAD
)
5574 || os
->align_lma_with_input
))
5576 os
->lma_region
->current
= os
->bfd_section
->lma
+ dotdelta
;
5579 os_region_check (os
, os
->lma_region
, NULL
,
5580 os
->bfd_section
->lma
);
5586 case lang_constructors_statement_enum
:
5587 dot
= lang_size_sections_1 (&constructor_list
.head
,
5588 output_section_statement
,
5589 fill
, dot
, relax
, check_regions
);
5592 case lang_data_statement_enum
:
5594 unsigned int size
= 0;
5596 s
->data_statement
.output_offset
=
5597 dot
- output_section_statement
->bfd_section
->vma
;
5598 s
->data_statement
.output_section
=
5599 output_section_statement
->bfd_section
;
5601 /* We might refer to provided symbols in the expression, and
5602 need to mark them as needed. */
5603 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5605 switch (s
->data_statement
.type
)
5623 if (size
< TO_SIZE ((unsigned) 1))
5624 size
= TO_SIZE ((unsigned) 1);
5625 dot
+= TO_ADDR (size
);
5626 if (!(output_section_statement
->bfd_section
->flags
5628 output_section_statement
->bfd_section
->size
5629 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5634 case lang_reloc_statement_enum
:
5638 s
->reloc_statement
.output_offset
=
5639 dot
- output_section_statement
->bfd_section
->vma
;
5640 s
->reloc_statement
.output_section
=
5641 output_section_statement
->bfd_section
;
5642 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
5643 dot
+= TO_ADDR (size
);
5644 if (!(output_section_statement
->bfd_section
->flags
5646 output_section_statement
->bfd_section
->size
5647 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5651 case lang_wild_statement_enum
:
5652 dot
= lang_size_sections_1 (&s
->wild_statement
.children
.head
,
5653 output_section_statement
,
5654 fill
, dot
, relax
, check_regions
);
5657 case lang_object_symbols_statement_enum
:
5658 link_info
.create_object_symbols_section
5659 = output_section_statement
->bfd_section
;
5660 output_section_statement
->bfd_section
->flags
|= SEC_KEEP
;
5663 case lang_output_statement_enum
:
5664 case lang_target_statement_enum
:
5667 case lang_input_section_enum
:
5671 i
= s
->input_section
.section
;
5676 if (!bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
5677 einfo (_("%F%P: can't relax section: %E\n"));
5681 dot
= size_input_section (prev
, output_section_statement
,
5686 case lang_input_statement_enum
:
5689 case lang_fill_statement_enum
:
5690 s
->fill_statement
.output_section
=
5691 output_section_statement
->bfd_section
;
5693 fill
= s
->fill_statement
.fill
;
5696 case lang_assignment_statement_enum
:
5698 bfd_vma newdot
= dot
;
5699 etree_type
*tree
= s
->assignment_statement
.exp
;
5701 expld
.dataseg
.relro
= exp_seg_relro_none
;
5703 exp_fold_tree (tree
,
5704 output_section_statement
->bfd_section
,
5707 ldlang_check_relro_region (s
, &expld
.dataseg
);
5709 expld
.dataseg
.relro
= exp_seg_relro_none
;
5711 /* This symbol may be relative to this section. */
5712 if ((tree
->type
.node_class
== etree_provided
5713 || tree
->type
.node_class
== etree_assign
)
5714 && (tree
->assign
.dst
[0] != '.'
5715 || tree
->assign
.dst
[1] != '\0'))
5716 output_section_statement
->update_dot
= 1;
5718 if (!output_section_statement
->ignored
)
5720 if (output_section_statement
== abs_output_section
)
5722 /* If we don't have an output section, then just adjust
5723 the default memory address. */
5724 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
5725 FALSE
)->current
= newdot
;
5727 else if (newdot
!= dot
)
5729 /* Insert a pad after this statement. We can't
5730 put the pad before when relaxing, in case the
5731 assignment references dot. */
5732 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
5733 output_section_statement
->bfd_section
, dot
);
5735 /* Don't neuter the pad below when relaxing. */
5738 /* If dot is advanced, this implies that the section
5739 should have space allocated to it, unless the
5740 user has explicitly stated that the section
5741 should not be allocated. */
5742 if (output_section_statement
->sectype
!= noalloc_section
5743 && (output_section_statement
->sectype
!= noload_section
5744 || (bfd_get_flavour (link_info
.output_bfd
)
5745 == bfd_target_elf_flavour
)))
5746 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
5753 case lang_padding_statement_enum
:
5754 /* If this is the first time lang_size_sections is called,
5755 we won't have any padding statements. If this is the
5756 second or later passes when relaxing, we should allow
5757 padding to shrink. If padding is needed on this pass, it
5758 will be added back in. */
5759 s
->padding_statement
.size
= 0;
5761 /* Make sure output_offset is valid. If relaxation shrinks
5762 the section and this pad isn't needed, it's possible to
5763 have output_offset larger than the final size of the
5764 section. bfd_set_section_contents will complain even for
5765 a pad size of zero. */
5766 s
->padding_statement
.output_offset
5767 = dot
- output_section_statement
->bfd_section
->vma
;
5770 case lang_group_statement_enum
:
5771 dot
= lang_size_sections_1 (&s
->group_statement
.children
.head
,
5772 output_section_statement
,
5773 fill
, dot
, relax
, check_regions
);
5776 case lang_insert_statement_enum
:
5779 /* We can only get here when relaxing is turned on. */
5780 case lang_address_statement_enum
:
5787 prev
= &s
->header
.next
;
5792 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
5793 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
5794 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
5795 segments. We are allowed an opportunity to override this decision. */
5798 ldlang_override_segment_assignment (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5799 bfd
*abfd ATTRIBUTE_UNUSED
,
5800 asection
*current_section
,
5801 asection
*previous_section
,
5802 bfd_boolean new_segment
)
5804 lang_output_section_statement_type
*cur
;
5805 lang_output_section_statement_type
*prev
;
5807 /* The checks below are only necessary when the BFD library has decided
5808 that the two sections ought to be placed into the same segment. */
5812 /* Paranoia checks. */
5813 if (current_section
== NULL
|| previous_section
== NULL
)
5816 /* If this flag is set, the target never wants code and non-code
5817 sections comingled in the same segment. */
5818 if (config
.separate_code
5819 && ((current_section
->flags
^ previous_section
->flags
) & SEC_CODE
))
5822 /* Find the memory regions associated with the two sections.
5823 We call lang_output_section_find() here rather than scanning the list
5824 of output sections looking for a matching section pointer because if
5825 we have a large number of sections then a hash lookup is faster. */
5826 cur
= lang_output_section_find (current_section
->name
);
5827 prev
= lang_output_section_find (previous_section
->name
);
5829 /* More paranoia. */
5830 if (cur
== NULL
|| prev
== NULL
)
5833 /* If the regions are different then force the sections to live in
5834 different segments. See the email thread starting at the following
5835 URL for the reasons why this is necessary:
5836 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
5837 return cur
->region
!= prev
->region
;
5841 one_lang_size_sections_pass (bfd_boolean
*relax
, bfd_boolean check_regions
)
5843 lang_statement_iteration
++;
5844 lang_size_sections_1 (&statement_list
.head
, abs_output_section
,
5845 0, 0, relax
, check_regions
);
5849 lang_size_segment (seg_align_type
*seg
)
5851 /* If XXX_SEGMENT_ALIGN XXX_SEGMENT_END pair was seen, check whether
5852 a page could be saved in the data segment. */
5853 bfd_vma first
, last
;
5855 first
= -seg
->base
& (seg
->pagesize
- 1);
5856 last
= seg
->end
& (seg
->pagesize
- 1);
5858 && ((seg
->base
& ~(seg
->pagesize
- 1))
5859 != (seg
->end
& ~(seg
->pagesize
- 1)))
5860 && first
+ last
<= seg
->pagesize
)
5862 seg
->phase
= exp_seg_adjust
;
5866 seg
->phase
= exp_seg_done
;
5871 lang_size_relro_segment_1 (seg_align_type
*seg
)
5873 bfd_vma relro_end
, desired_end
;
5876 /* Compute the expected PT_GNU_RELRO/PT_LOAD segment end. */
5877 relro_end
= ((seg
->relro_end
+ seg
->pagesize
- 1)
5878 & ~(seg
->pagesize
- 1));
5880 /* Adjust by the offset arg of XXX_SEGMENT_RELRO_END. */
5881 desired_end
= relro_end
- seg
->relro_offset
;
5883 /* For sections in the relro segment.. */
5884 for (sec
= link_info
.output_bfd
->section_last
; sec
; sec
= sec
->prev
)
5885 if ((sec
->flags
& SEC_ALLOC
) != 0
5886 && sec
->vma
>= seg
->base
5887 && sec
->vma
< seg
->relro_end
- seg
->relro_offset
)
5889 /* Where do we want to put this section so that it ends as
5891 bfd_vma start
, end
, bump
;
5893 end
= start
= sec
->vma
;
5895 end
+= TO_ADDR (sec
->size
);
5896 bump
= desired_end
- end
;
5897 /* We'd like to increase START by BUMP, but we must heed
5898 alignment so the increase might be less than optimum. */
5900 start
&= ~(((bfd_vma
) 1 << sec
->alignment_power
) - 1);
5901 /* This is now the desired end for the previous section. */
5902 desired_end
= start
;
5905 seg
->phase
= exp_seg_relro_adjust
;
5906 ASSERT (desired_end
>= seg
->base
);
5907 seg
->base
= desired_end
;
5912 lang_size_relro_segment (bfd_boolean
*relax
, bfd_boolean check_regions
)
5914 bfd_boolean do_reset
= FALSE
;
5915 bfd_boolean do_data_relro
;
5916 bfd_vma data_initial_base
, data_relro_end
;
5918 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
5920 do_data_relro
= TRUE
;
5921 data_initial_base
= expld
.dataseg
.base
;
5922 data_relro_end
= lang_size_relro_segment_1 (&expld
.dataseg
);
5926 do_data_relro
= FALSE
;
5927 data_initial_base
= data_relro_end
= 0;
5932 lang_reset_memory_regions ();
5933 one_lang_size_sections_pass (relax
, check_regions
);
5935 /* Assignments to dot, or to output section address in a user
5936 script have increased padding over the original. Revert. */
5937 if (do_data_relro
&& expld
.dataseg
.relro_end
> data_relro_end
)
5939 expld
.dataseg
.base
= data_initial_base
;;
5944 if (!do_data_relro
&& lang_size_segment (&expld
.dataseg
))
5951 lang_size_sections (bfd_boolean
*relax
, bfd_boolean check_regions
)
5953 expld
.phase
= lang_allocating_phase_enum
;
5954 expld
.dataseg
.phase
= exp_seg_none
;
5956 one_lang_size_sections_pass (relax
, check_regions
);
5958 if (expld
.dataseg
.phase
!= exp_seg_end_seen
)
5959 expld
.dataseg
.phase
= exp_seg_done
;
5961 if (expld
.dataseg
.phase
== exp_seg_end_seen
)
5963 bfd_boolean do_reset
5964 = lang_size_relro_segment (relax
, check_regions
);
5968 lang_reset_memory_regions ();
5969 one_lang_size_sections_pass (relax
, check_regions
);
5972 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
5974 link_info
.relro_start
= expld
.dataseg
.base
;
5975 link_info
.relro_end
= expld
.dataseg
.relro_end
;
5980 static lang_output_section_statement_type
*current_section
;
5981 static lang_assignment_statement_type
*current_assign
;
5982 static bfd_boolean prefer_next_section
;
5984 /* Worker function for lang_do_assignments. Recursiveness goes here. */
5987 lang_do_assignments_1 (lang_statement_union_type
*s
,
5988 lang_output_section_statement_type
*current_os
,
5991 bfd_boolean
*found_end
)
5993 for (; s
!= NULL
; s
= s
->header
.next
)
5995 switch (s
->header
.type
)
5997 case lang_constructors_statement_enum
:
5998 dot
= lang_do_assignments_1 (constructor_list
.head
,
5999 current_os
, fill
, dot
, found_end
);
6002 case lang_output_section_statement_enum
:
6004 lang_output_section_statement_type
*os
;
6007 os
= &(s
->output_section_statement
);
6008 os
->after_end
= *found_end
;
6009 if (os
->bfd_section
!= NULL
&& !os
->ignored
)
6011 if ((os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
6013 current_section
= os
;
6014 prefer_next_section
= FALSE
;
6016 dot
= os
->bfd_section
->vma
;
6018 newdot
= lang_do_assignments_1 (os
->children
.head
,
6019 os
, os
->fill
, dot
, found_end
);
6022 if (os
->bfd_section
!= NULL
)
6024 /* .tbss sections effectively have zero size. */
6025 if (!IS_TBSS (os
->bfd_section
)
6026 || bfd_link_relocatable (&link_info
))
6027 dot
+= TO_ADDR (os
->bfd_section
->size
);
6029 if (os
->update_dot_tree
!= NULL
)
6030 exp_fold_tree (os
->update_dot_tree
,
6031 bfd_abs_section_ptr
, &dot
);
6039 case lang_wild_statement_enum
:
6041 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
6042 current_os
, fill
, dot
, found_end
);
6045 case lang_object_symbols_statement_enum
:
6046 case lang_output_statement_enum
:
6047 case lang_target_statement_enum
:
6050 case lang_data_statement_enum
:
6051 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
6052 if (expld
.result
.valid_p
)
6054 s
->data_statement
.value
= expld
.result
.value
;
6055 if (expld
.result
.section
!= NULL
)
6056 s
->data_statement
.value
+= expld
.result
.section
->vma
;
6058 else if (expld
.phase
== lang_final_phase_enum
)
6059 einfo (_("%F%P: invalid data statement\n"));
6062 switch (s
->data_statement
.type
)
6080 if (size
< TO_SIZE ((unsigned) 1))
6081 size
= TO_SIZE ((unsigned) 1);
6082 dot
+= TO_ADDR (size
);
6086 case lang_reloc_statement_enum
:
6087 exp_fold_tree (s
->reloc_statement
.addend_exp
,
6088 bfd_abs_section_ptr
, &dot
);
6089 if (expld
.result
.valid_p
)
6090 s
->reloc_statement
.addend_value
= expld
.result
.value
;
6091 else if (expld
.phase
== lang_final_phase_enum
)
6092 einfo (_("%F%P: invalid reloc statement\n"));
6093 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
6096 case lang_input_section_enum
:
6098 asection
*in
= s
->input_section
.section
;
6100 if ((in
->flags
& SEC_EXCLUDE
) == 0)
6101 dot
+= TO_ADDR (in
->size
);
6105 case lang_input_statement_enum
:
6108 case lang_fill_statement_enum
:
6109 fill
= s
->fill_statement
.fill
;
6112 case lang_assignment_statement_enum
:
6113 current_assign
= &s
->assignment_statement
;
6114 if (current_assign
->exp
->type
.node_class
!= etree_assert
)
6116 const char *p
= current_assign
->exp
->assign
.dst
;
6118 if (current_os
== abs_output_section
&& p
[0] == '.' && p
[1] == 0)
6119 prefer_next_section
= TRUE
;
6123 if (strcmp (p
, "end") == 0)
6126 exp_fold_tree (s
->assignment_statement
.exp
,
6127 (current_os
->bfd_section
!= NULL
6128 ? current_os
->bfd_section
: bfd_und_section_ptr
),
6132 case lang_padding_statement_enum
:
6133 dot
+= TO_ADDR (s
->padding_statement
.size
);
6136 case lang_group_statement_enum
:
6137 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
6138 current_os
, fill
, dot
, found_end
);
6141 case lang_insert_statement_enum
:
6144 case lang_address_statement_enum
:
6156 lang_do_assignments (lang_phase_type phase
)
6158 bfd_boolean found_end
= FALSE
;
6160 current_section
= NULL
;
6161 prefer_next_section
= FALSE
;
6162 expld
.phase
= phase
;
6163 lang_statement_iteration
++;
6164 lang_do_assignments_1 (statement_list
.head
,
6165 abs_output_section
, NULL
, 0, &found_end
);
6168 /* For an assignment statement outside of an output section statement,
6169 choose the best of neighbouring output sections to use for values
6173 section_for_dot (void)
6177 /* Assignments belong to the previous output section, unless there
6178 has been an assignment to "dot", in which case following
6179 assignments belong to the next output section. (The assumption
6180 is that an assignment to "dot" is setting up the address for the
6181 next output section.) Except that past the assignment to "_end"
6182 we always associate with the previous section. This exception is
6183 for targets like SH that define an alloc .stack or other
6184 weirdness after non-alloc sections. */
6185 if (current_section
== NULL
|| prefer_next_section
)
6187 lang_statement_union_type
*stmt
;
6188 lang_output_section_statement_type
*os
;
6190 for (stmt
= (lang_statement_union_type
*) current_assign
;
6192 stmt
= stmt
->header
.next
)
6193 if (stmt
->header
.type
== lang_output_section_statement_enum
)
6196 os
= &stmt
->output_section_statement
;
6199 && (os
->bfd_section
== NULL
6200 || (os
->bfd_section
->flags
& SEC_EXCLUDE
) != 0
6201 || bfd_section_removed_from_list (link_info
.output_bfd
,
6205 if (current_section
== NULL
|| os
== NULL
|| !os
->after_end
)
6208 s
= os
->bfd_section
;
6210 s
= link_info
.output_bfd
->section_last
;
6212 && ((s
->flags
& SEC_ALLOC
) == 0
6213 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6218 return bfd_abs_section_ptr
;
6222 s
= current_section
->bfd_section
;
6224 /* The section may have been stripped. */
6226 && ((s
->flags
& SEC_EXCLUDE
) != 0
6227 || (s
->flags
& SEC_ALLOC
) == 0
6228 || (s
->flags
& SEC_THREAD_LOCAL
) != 0
6229 || bfd_section_removed_from_list (link_info
.output_bfd
, s
)))
6232 s
= link_info
.output_bfd
->sections
;
6234 && ((s
->flags
& SEC_ALLOC
) == 0
6235 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6240 return bfd_abs_section_ptr
;
6243 /* Array of __start/__stop/.startof./.sizeof/ symbols. */
6245 static struct bfd_link_hash_entry
**start_stop_syms
;
6246 static size_t start_stop_count
= 0;
6247 static size_t start_stop_alloc
= 0;
6249 /* Give start/stop SYMBOL for SEC a preliminary definition, and add it
6250 to start_stop_syms. */
6253 lang_define_start_stop (const char *symbol
, asection
*sec
)
6255 struct bfd_link_hash_entry
*h
;
6257 h
= bfd_define_start_stop (link_info
.output_bfd
, &link_info
, symbol
, sec
);
6260 if (start_stop_count
== start_stop_alloc
)
6262 start_stop_alloc
= 2 * start_stop_alloc
+ 10;
6264 = xrealloc (start_stop_syms
,
6265 start_stop_alloc
* sizeof (*start_stop_syms
));
6267 start_stop_syms
[start_stop_count
++] = h
;
6271 /* Check for input sections whose names match references to
6272 __start_SECNAME or __stop_SECNAME symbols. Give the symbols
6273 preliminary definitions. */
6276 lang_init_start_stop (void)
6280 char leading_char
= bfd_get_symbol_leading_char (link_info
.output_bfd
);
6282 for (abfd
= link_info
.input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6283 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6286 const char *secname
= s
->name
;
6288 for (ps
= secname
; *ps
!= '\0'; ps
++)
6289 if (!ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
6293 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6295 symbol
[0] = leading_char
;
6296 sprintf (symbol
+ (leading_char
!= 0), "__start_%s", secname
);
6297 lang_define_start_stop (symbol
, s
);
6299 symbol
[1] = leading_char
;
6300 memcpy (symbol
+ 1 + (leading_char
!= 0), "__stop", 6);
6301 lang_define_start_stop (symbol
+ 1, s
);
6308 /* Iterate over start_stop_syms. */
6311 foreach_start_stop (void (*func
) (struct bfd_link_hash_entry
*))
6315 for (i
= 0; i
< start_stop_count
; ++i
)
6316 func (start_stop_syms
[i
]);
6319 /* __start and __stop symbols are only supposed to be defined by the
6320 linker for orphan sections, but we now extend that to sections that
6321 map to an output section of the same name. The symbols were
6322 defined early for --gc-sections, before we mapped input to output
6323 sections, so undo those that don't satisfy this rule. */
6326 undef_start_stop (struct bfd_link_hash_entry
*h
)
6328 if (h
->ldscript_def
)
6331 if (h
->u
.def
.section
->output_section
== NULL
6332 || h
->u
.def
.section
->output_section
->owner
!= link_info
.output_bfd
6333 || strcmp (h
->u
.def
.section
->name
,
6334 h
->u
.def
.section
->output_section
->name
) != 0)
6336 asection
*sec
= bfd_get_section_by_name (link_info
.output_bfd
,
6337 h
->u
.def
.section
->name
);
6340 /* When there are more than one input sections with the same
6341 section name, SECNAME, linker picks the first one to define
6342 __start_SECNAME and __stop_SECNAME symbols. When the first
6343 input section is removed by comdat group, we need to check
6344 if there is still an output section with section name
6347 for (i
= sec
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
6348 if (strcmp (h
->u
.def
.section
->name
, i
->name
) == 0)
6350 h
->u
.def
.section
= i
;
6354 h
->type
= bfd_link_hash_undefined
;
6355 h
->u
.undef
.abfd
= NULL
;
6360 lang_undef_start_stop (void)
6362 foreach_start_stop (undef_start_stop
);
6365 /* Check for output sections whose names match references to
6366 .startof.SECNAME or .sizeof.SECNAME symbols. Give the symbols
6367 preliminary definitions. */
6370 lang_init_startof_sizeof (void)
6374 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6376 const char *secname
= s
->name
;
6377 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6379 sprintf (symbol
, ".startof.%s", secname
);
6380 lang_define_start_stop (symbol
, s
);
6382 memcpy (symbol
+ 1, ".size", 5);
6383 lang_define_start_stop (symbol
+ 1, s
);
6388 /* Set .startof., .sizeof., __start and __stop symbols final values. */
6391 set_start_stop (struct bfd_link_hash_entry
*h
)
6394 || h
->type
!= bfd_link_hash_defined
)
6397 if (h
->root
.string
[0] == '.')
6399 /* .startof. or .sizeof. symbol.
6400 .startof. already has final value. */
6401 if (h
->root
.string
[2] == 'i')
6404 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6405 h
->u
.def
.section
= bfd_abs_section_ptr
;
6410 /* __start or __stop symbol. */
6411 int has_lead
= bfd_get_symbol_leading_char (link_info
.output_bfd
) != 0;
6413 h
->u
.def
.section
= h
->u
.def
.section
->output_section
;
6414 if (h
->root
.string
[4 + has_lead
] == 'o')
6417 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6423 lang_finalize_start_stop (void)
6425 foreach_start_stop (set_start_stop
);
6431 struct bfd_link_hash_entry
*h
;
6434 if ((bfd_link_relocatable (&link_info
) && !link_info
.gc_sections
)
6435 || bfd_link_dll (&link_info
))
6436 warn
= entry_from_cmdline
;
6440 /* Force the user to specify a root when generating a relocatable with
6441 --gc-sections, unless --gc-keep-exported was also given. */
6442 if (bfd_link_relocatable (&link_info
)
6443 && link_info
.gc_sections
6444 && !link_info
.gc_keep_exported
6445 && !(entry_from_cmdline
|| undef_from_cmdline
))
6446 einfo (_("%F%P: gc-sections requires either an entry or "
6447 "an undefined symbol\n"));
6449 if (entry_symbol
.name
== NULL
)
6451 /* No entry has been specified. Look for the default entry, but
6452 don't warn if we don't find it. */
6453 entry_symbol
.name
= entry_symbol_default
;
6457 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
6458 FALSE
, FALSE
, TRUE
);
6460 && (h
->type
== bfd_link_hash_defined
6461 || h
->type
== bfd_link_hash_defweak
)
6462 && h
->u
.def
.section
->output_section
!= NULL
)
6466 val
= (h
->u
.def
.value
6467 + bfd_get_section_vma (link_info
.output_bfd
,
6468 h
->u
.def
.section
->output_section
)
6469 + h
->u
.def
.section
->output_offset
);
6470 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6471 einfo (_("%F%P: %s: can't set start address\n"), entry_symbol
.name
);
6478 /* We couldn't find the entry symbol. Try parsing it as a
6480 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
6483 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6484 einfo (_("%F%P: can't set start address\n"));
6490 /* Can't find the entry symbol, and it's not a number. Use
6491 the first address in the text section. */
6492 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
6496 einfo (_("%P: warning: cannot find entry symbol %s;"
6497 " defaulting to %V\n"),
6499 bfd_get_section_vma (link_info
.output_bfd
, ts
));
6500 if (!(bfd_set_start_address
6501 (link_info
.output_bfd
,
6502 bfd_get_section_vma (link_info
.output_bfd
, ts
))))
6503 einfo (_("%F%P: can't set start address\n"));
6508 einfo (_("%P: warning: cannot find entry symbol %s;"
6509 " not setting start address\n"),
6516 /* This is a small function used when we want to ignore errors from
6520 ignore_bfd_errors (const char *fmt ATTRIBUTE_UNUSED
,
6521 va_list ap ATTRIBUTE_UNUSED
)
6523 /* Don't do anything. */
6526 /* Check that the architecture of all the input files is compatible
6527 with the output file. Also call the backend to let it do any
6528 other checking that is needed. */
6533 lang_input_statement_type
*file
;
6535 const bfd_arch_info_type
*compatible
;
6537 for (file
= &file_chain
.head
->input_statement
;
6541 #ifdef ENABLE_PLUGINS
6542 /* Don't check format of files claimed by plugin. */
6543 if (file
->flags
.claimed
)
6545 #endif /* ENABLE_PLUGINS */
6546 input_bfd
= file
->the_bfd
;
6548 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
6549 command_line
.accept_unknown_input_arch
);
6551 /* In general it is not possible to perform a relocatable
6552 link between differing object formats when the input
6553 file has relocations, because the relocations in the
6554 input format may not have equivalent representations in
6555 the output format (and besides BFD does not translate
6556 relocs for other link purposes than a final link). */
6557 if ((bfd_link_relocatable (&link_info
)
6558 || link_info
.emitrelocations
)
6559 && (compatible
== NULL
6560 || (bfd_get_flavour (input_bfd
)
6561 != bfd_get_flavour (link_info
.output_bfd
)))
6562 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
6564 einfo (_("%F%P: relocatable linking with relocations from"
6565 " format %s (%pB) to format %s (%pB) is not supported\n"),
6566 bfd_get_target (input_bfd
), input_bfd
,
6567 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
6568 /* einfo with %F exits. */
6571 if (compatible
== NULL
)
6573 if (command_line
.warn_mismatch
)
6574 einfo (_("%X%P: %s architecture of input file `%pB'"
6575 " is incompatible with %s output\n"),
6576 bfd_printable_name (input_bfd
), input_bfd
,
6577 bfd_printable_name (link_info
.output_bfd
));
6579 else if (bfd_count_sections (input_bfd
))
6581 /* If the input bfd has no contents, it shouldn't set the
6582 private data of the output bfd. */
6584 bfd_error_handler_type pfn
= NULL
;
6586 /* If we aren't supposed to warn about mismatched input
6587 files, temporarily set the BFD error handler to a
6588 function which will do nothing. We still want to call
6589 bfd_merge_private_bfd_data, since it may set up
6590 information which is needed in the output file. */
6591 if (!command_line
.warn_mismatch
)
6592 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
6593 if (!bfd_merge_private_bfd_data (input_bfd
, &link_info
))
6595 if (command_line
.warn_mismatch
)
6596 einfo (_("%X%P: failed to merge target specific data"
6597 " of file %pB\n"), input_bfd
);
6599 if (!command_line
.warn_mismatch
)
6600 bfd_set_error_handler (pfn
);
6605 /* Look through all the global common symbols and attach them to the
6606 correct section. The -sort-common command line switch may be used
6607 to roughly sort the entries by alignment. */
6612 if (link_info
.inhibit_common_definition
)
6614 if (bfd_link_relocatable (&link_info
)
6615 && !command_line
.force_common_definition
)
6618 if (!config
.sort_common
)
6619 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
6624 if (config
.sort_common
== sort_descending
)
6626 for (power
= 4; power
> 0; power
--)
6627 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6630 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6634 for (power
= 0; power
<= 4; power
++)
6635 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6637 power
= (unsigned int) -1;
6638 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6643 /* Place one common symbol in the correct section. */
6646 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
6648 unsigned int power_of_two
;
6652 if (h
->type
!= bfd_link_hash_common
)
6656 power_of_two
= h
->u
.c
.p
->alignment_power
;
6658 if (config
.sort_common
== sort_descending
6659 && power_of_two
< *(unsigned int *) info
)
6661 else if (config
.sort_common
== sort_ascending
6662 && power_of_two
> *(unsigned int *) info
)
6665 section
= h
->u
.c
.p
->section
;
6666 if (!bfd_define_common_symbol (link_info
.output_bfd
, &link_info
, h
))
6667 einfo (_("%F%P: could not define common symbol `%pT': %E\n"),
6670 if (config
.map_file
!= NULL
)
6672 static bfd_boolean header_printed
;
6677 if (!header_printed
)
6679 minfo (_("\nAllocating common symbols\n"));
6680 minfo (_("Common symbol size file\n\n"));
6681 header_printed
= TRUE
;
6684 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
6685 DMGL_ANSI
| DMGL_PARAMS
);
6688 minfo ("%s", h
->root
.string
);
6689 len
= strlen (h
->root
.string
);
6694 len
= strlen (name
);
6710 if (size
<= 0xffffffff)
6711 sprintf (buf
, "%lx", (unsigned long) size
);
6713 sprintf_vma (buf
, size
);
6723 minfo ("%pB\n", section
->owner
);
6729 /* Handle a single orphan section S, placing the orphan into an appropriate
6730 output section. The effects of the --orphan-handling command line
6731 option are handled here. */
6734 ldlang_place_orphan (asection
*s
)
6736 if (config
.orphan_handling
== orphan_handling_discard
)
6738 lang_output_section_statement_type
*os
;
6739 os
= lang_output_section_statement_lookup (DISCARD_SECTION_NAME
, 0,
6741 if (os
->addr_tree
== NULL
6742 && (bfd_link_relocatable (&link_info
)
6743 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6744 os
->addr_tree
= exp_intop (0);
6745 lang_add_section (&os
->children
, s
, NULL
, os
);
6749 lang_output_section_statement_type
*os
;
6750 const char *name
= s
->name
;
6753 if (config
.orphan_handling
== orphan_handling_error
)
6754 einfo (_("%X%P: error: unplaced orphan section `%pA' from `%pB'\n"),
6757 if (config
.unique_orphan_sections
|| unique_section_p (s
, NULL
))
6758 constraint
= SPECIAL
;
6760 os
= ldemul_place_orphan (s
, name
, constraint
);
6763 os
= lang_output_section_statement_lookup (name
, constraint
, TRUE
);
6764 if (os
->addr_tree
== NULL
6765 && (bfd_link_relocatable (&link_info
)
6766 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6767 os
->addr_tree
= exp_intop (0);
6768 lang_add_section (&os
->children
, s
, NULL
, os
);
6771 if (config
.orphan_handling
== orphan_handling_warn
)
6772 einfo (_("%P: warning: orphan section `%pA' from `%pB' being "
6773 "placed in section `%s'\n"),
6774 s
, s
->owner
, os
->name
);
6778 /* Run through the input files and ensure that every input section has
6779 somewhere to go. If one is found without a destination then create
6780 an input request and place it into the statement tree. */
6783 lang_place_orphans (void)
6785 LANG_FOR_EACH_INPUT_STATEMENT (file
)
6789 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6791 if (s
->output_section
== NULL
)
6793 /* This section of the file is not attached, root
6794 around for a sensible place for it to go. */
6796 if (file
->flags
.just_syms
)
6797 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
6798 else if (lang_discard_section_p (s
))
6799 s
->output_section
= bfd_abs_section_ptr
;
6800 else if (strcmp (s
->name
, "COMMON") == 0)
6802 /* This is a lonely common section which must have
6803 come from an archive. We attach to the section
6804 with the wildcard. */
6805 if (!bfd_link_relocatable (&link_info
)
6806 || command_line
.force_common_definition
)
6808 if (default_common_section
== NULL
)
6809 default_common_section
6810 = lang_output_section_statement_lookup (".bss", 0,
6812 lang_add_section (&default_common_section
->children
, s
,
6813 NULL
, default_common_section
);
6817 ldlang_place_orphan (s
);
6824 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
6826 flagword
*ptr_flags
;
6828 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
6834 /* PR 17900: An exclamation mark in the attributes reverses
6835 the sense of any of the attributes that follow. */
6838 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
6842 *ptr_flags
|= SEC_ALLOC
;
6846 *ptr_flags
|= SEC_READONLY
;
6850 *ptr_flags
|= SEC_DATA
;
6854 *ptr_flags
|= SEC_CODE
;
6859 *ptr_flags
|= SEC_LOAD
;
6863 einfo (_("%F%P: invalid character %c (%d) in flags\n"),
6871 /* Call a function on each real input file. This function will be
6872 called on an archive, but not on the elements. */
6875 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
6877 lang_input_statement_type
*f
;
6879 for (f
= &input_file_chain
.head
->input_statement
;
6881 f
= f
->next_real_file
)
6886 /* Call a function on each real file. The function will be called on
6887 all the elements of an archive which are included in the link, but
6888 will not be called on the archive file itself. */
6891 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
6893 LANG_FOR_EACH_INPUT_STATEMENT (f
)
6901 ldlang_add_file (lang_input_statement_type
*entry
)
6903 lang_statement_append (&file_chain
, entry
, &entry
->next
);
6905 /* The BFD linker needs to have a list of all input BFDs involved in
6907 ASSERT (entry
->the_bfd
->link
.next
== NULL
);
6908 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
6910 *link_info
.input_bfds_tail
= entry
->the_bfd
;
6911 link_info
.input_bfds_tail
= &entry
->the_bfd
->link
.next
;
6912 entry
->the_bfd
->usrdata
= entry
;
6913 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
6915 /* Look through the sections and check for any which should not be
6916 included in the link. We need to do this now, so that we can
6917 notice when the backend linker tries to report multiple
6918 definition errors for symbols which are in sections we aren't
6919 going to link. FIXME: It might be better to entirely ignore
6920 symbols which are defined in sections which are going to be
6921 discarded. This would require modifying the backend linker for
6922 each backend which might set the SEC_LINK_ONCE flag. If we do
6923 this, we should probably handle SEC_EXCLUDE in the same way. */
6925 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
6929 lang_add_output (const char *name
, int from_script
)
6931 /* Make -o on command line override OUTPUT in script. */
6932 if (!had_output_filename
|| !from_script
)
6934 output_filename
= name
;
6935 had_output_filename
= TRUE
;
6939 lang_output_section_statement_type
*
6940 lang_enter_output_section_statement (const char *output_section_statement_name
,
6941 etree_type
*address_exp
,
6942 enum section_type sectype
,
6944 etree_type
*subalign
,
6947 int align_with_input
)
6949 lang_output_section_statement_type
*os
;
6951 os
= lang_output_section_statement_lookup (output_section_statement_name
,
6953 current_section
= os
;
6955 if (os
->addr_tree
== NULL
)
6957 os
->addr_tree
= address_exp
;
6959 os
->sectype
= sectype
;
6960 if (sectype
!= noload_section
)
6961 os
->flags
= SEC_NO_FLAGS
;
6963 os
->flags
= SEC_NEVER_LOAD
;
6964 os
->block_value
= 1;
6966 /* Make next things chain into subchain of this. */
6967 push_stat_ptr (&os
->children
);
6969 os
->align_lma_with_input
= align_with_input
== ALIGN_WITH_INPUT
;
6970 if (os
->align_lma_with_input
&& align
!= NULL
)
6971 einfo (_("%F%P:%pS: error: align with input and explicit align specified\n"),
6974 os
->subsection_alignment
= subalign
;
6975 os
->section_alignment
= align
;
6977 os
->load_base
= ebase
;
6984 lang_output_statement_type
*new_stmt
;
6986 new_stmt
= new_stat (lang_output_statement
, stat_ptr
);
6987 new_stmt
->name
= output_filename
;
6990 /* Reset the current counters in the regions. */
6993 lang_reset_memory_regions (void)
6995 lang_memory_region_type
*p
= lang_memory_region_list
;
6997 lang_output_section_statement_type
*os
;
6999 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
7001 p
->current
= p
->origin
;
7005 for (os
= &lang_os_list
.head
->output_section_statement
;
7009 os
->processed_vma
= FALSE
;
7010 os
->processed_lma
= FALSE
;
7013 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
7015 /* Save the last size for possible use by bfd_relax_section. */
7016 o
->rawsize
= o
->size
;
7017 if (!(o
->flags
& SEC_FIXED_SIZE
))
7022 /* Worker for lang_gc_sections_1. */
7025 gc_section_callback (lang_wild_statement_type
*ptr
,
7026 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7028 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
7029 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7030 void *data ATTRIBUTE_UNUSED
)
7032 /* If the wild pattern was marked KEEP, the member sections
7033 should be as well. */
7034 if (ptr
->keep_sections
)
7035 section
->flags
|= SEC_KEEP
;
7038 /* Iterate over sections marking them against GC. */
7041 lang_gc_sections_1 (lang_statement_union_type
*s
)
7043 for (; s
!= NULL
; s
= s
->header
.next
)
7045 switch (s
->header
.type
)
7047 case lang_wild_statement_enum
:
7048 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
7050 case lang_constructors_statement_enum
:
7051 lang_gc_sections_1 (constructor_list
.head
);
7053 case lang_output_section_statement_enum
:
7054 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
7056 case lang_group_statement_enum
:
7057 lang_gc_sections_1 (s
->group_statement
.children
.head
);
7066 lang_gc_sections (void)
7068 /* Keep all sections so marked in the link script. */
7069 lang_gc_sections_1 (statement_list
.head
);
7071 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
7072 the special case of debug info. (See bfd/stabs.c)
7073 Twiddle the flag here, to simplify later linker code. */
7074 if (bfd_link_relocatable (&link_info
))
7076 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7079 #ifdef ENABLE_PLUGINS
7080 if (f
->flags
.claimed
)
7083 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7084 if ((sec
->flags
& SEC_DEBUGGING
) == 0)
7085 sec
->flags
&= ~SEC_EXCLUDE
;
7089 if (link_info
.gc_sections
)
7090 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
7093 /* Worker for lang_find_relro_sections_1. */
7096 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
7097 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7099 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
7100 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7103 /* Discarded, excluded and ignored sections effectively have zero
7105 if (section
->output_section
!= NULL
7106 && section
->output_section
->owner
== link_info
.output_bfd
7107 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
7108 && !IGNORE_SECTION (section
)
7109 && section
->size
!= 0)
7111 bfd_boolean
*has_relro_section
= (bfd_boolean
*) data
;
7112 *has_relro_section
= TRUE
;
7116 /* Iterate over sections for relro sections. */
7119 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
7120 seg_align_type
*seg
,
7121 bfd_boolean
*has_relro_section
)
7123 if (*has_relro_section
)
7126 for (; s
!= NULL
; s
= s
->header
.next
)
7128 if (s
== seg
->relro_end_stat
)
7131 switch (s
->header
.type
)
7133 case lang_wild_statement_enum
:
7134 walk_wild (&s
->wild_statement
,
7135 find_relro_section_callback
,
7138 case lang_constructors_statement_enum
:
7139 lang_find_relro_sections_1 (constructor_list
.head
,
7140 seg
, has_relro_section
);
7142 case lang_output_section_statement_enum
:
7143 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
7144 seg
, has_relro_section
);
7146 case lang_group_statement_enum
:
7147 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
7148 seg
, has_relro_section
);
7157 lang_find_relro_sections (void)
7159 bfd_boolean has_relro_section
= FALSE
;
7161 /* Check all sections in the link script. */
7163 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
7164 &expld
.dataseg
, &has_relro_section
);
7166 if (!has_relro_section
)
7167 link_info
.relro
= FALSE
;
7170 /* Relax all sections until bfd_relax_section gives up. */
7173 lang_relax_sections (bfd_boolean need_layout
)
7175 if (RELAXATION_ENABLED
)
7177 /* We may need more than one relaxation pass. */
7178 int i
= link_info
.relax_pass
;
7180 /* The backend can use it to determine the current pass. */
7181 link_info
.relax_pass
= 0;
7185 /* Keep relaxing until bfd_relax_section gives up. */
7186 bfd_boolean relax_again
;
7188 link_info
.relax_trip
= -1;
7191 link_info
.relax_trip
++;
7193 /* Note: pe-dll.c does something like this also. If you find
7194 you need to change this code, you probably need to change
7195 pe-dll.c also. DJ */
7197 /* Do all the assignments with our current guesses as to
7199 lang_do_assignments (lang_assigning_phase_enum
);
7201 /* We must do this after lang_do_assignments, because it uses
7203 lang_reset_memory_regions ();
7205 /* Perform another relax pass - this time we know where the
7206 globals are, so can make a better guess. */
7207 relax_again
= FALSE
;
7208 lang_size_sections (&relax_again
, FALSE
);
7210 while (relax_again
);
7212 link_info
.relax_pass
++;
7219 /* Final extra sizing to report errors. */
7220 lang_do_assignments (lang_assigning_phase_enum
);
7221 lang_reset_memory_regions ();
7222 lang_size_sections (NULL
, TRUE
);
7226 #ifdef ENABLE_PLUGINS
7227 /* Find the insert point for the plugin's replacement files. We
7228 place them after the first claimed real object file, or if the
7229 first claimed object is an archive member, after the last real
7230 object file immediately preceding the archive. In the event
7231 no objects have been claimed at all, we return the first dummy
7232 object file on the list as the insert point; that works, but
7233 the callee must be careful when relinking the file_chain as it
7234 is not actually on that chain, only the statement_list and the
7235 input_file list; in that case, the replacement files must be
7236 inserted at the head of the file_chain. */
7238 static lang_input_statement_type
*
7239 find_replacements_insert_point (bfd_boolean
*before
)
7241 lang_input_statement_type
*claim1
, *lastobject
;
7242 lastobject
= &input_file_chain
.head
->input_statement
;
7243 for (claim1
= &file_chain
.head
->input_statement
;
7245 claim1
= claim1
->next
)
7247 if (claim1
->flags
.claimed
)
7249 *before
= claim1
->flags
.claim_archive
;
7250 return claim1
->flags
.claim_archive
? lastobject
: claim1
;
7252 /* Update lastobject if this is a real object file. */
7253 if (claim1
->the_bfd
!= NULL
&& claim1
->the_bfd
->my_archive
== NULL
)
7254 lastobject
= claim1
;
7256 /* No files were claimed by the plugin. Choose the last object
7257 file found on the list (maybe the first, dummy entry) as the
7263 /* Find where to insert ADD, an archive element or shared library
7264 added during a rescan. */
7266 static lang_input_statement_type
**
7267 find_rescan_insertion (lang_input_statement_type
*add
)
7269 bfd
*add_bfd
= add
->the_bfd
;
7270 lang_input_statement_type
*f
;
7271 lang_input_statement_type
*last_loaded
= NULL
;
7272 lang_input_statement_type
*before
= NULL
;
7273 lang_input_statement_type
**iter
= NULL
;
7275 if (add_bfd
->my_archive
!= NULL
)
7276 add_bfd
= add_bfd
->my_archive
;
7278 /* First look through the input file chain, to find an object file
7279 before the one we've rescanned. Normal object files always
7280 appear on both the input file chain and the file chain, so this
7281 lets us get quickly to somewhere near the correct place on the
7282 file chain if it is full of archive elements. Archives don't
7283 appear on the file chain, but if an element has been extracted
7284 then their input_statement->next points at it. */
7285 for (f
= &input_file_chain
.head
->input_statement
;
7287 f
= f
->next_real_file
)
7289 if (f
->the_bfd
== add_bfd
)
7291 before
= last_loaded
;
7292 if (f
->next
!= NULL
)
7293 return &f
->next
->next
;
7295 if (f
->the_bfd
!= NULL
&& f
->next
!= NULL
)
7299 for (iter
= before
? &before
->next
: &file_chain
.head
->input_statement
.next
;
7301 iter
= &(*iter
)->next
)
7302 if (!(*iter
)->flags
.claim_archive
7303 && (*iter
)->the_bfd
->my_archive
== NULL
)
7309 /* Insert SRCLIST into DESTLIST after given element by chaining
7310 on FIELD as the next-pointer. (Counterintuitively does not need
7311 a pointer to the actual after-node itself, just its chain field.) */
7314 lang_list_insert_after (lang_statement_list_type
*destlist
,
7315 lang_statement_list_type
*srclist
,
7316 lang_statement_union_type
**field
)
7318 *(srclist
->tail
) = *field
;
7319 *field
= srclist
->head
;
7320 if (destlist
->tail
== field
)
7321 destlist
->tail
= srclist
->tail
;
7324 /* Detach new nodes added to DESTLIST since the time ORIGLIST
7325 was taken as a copy of it and leave them in ORIGLIST. */
7328 lang_list_remove_tail (lang_statement_list_type
*destlist
,
7329 lang_statement_list_type
*origlist
)
7331 union lang_statement_union
**savetail
;
7332 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
7333 ASSERT (origlist
->head
== destlist
->head
);
7334 savetail
= origlist
->tail
;
7335 origlist
->head
= *(savetail
);
7336 origlist
->tail
= destlist
->tail
;
7337 destlist
->tail
= savetail
;
7341 static lang_statement_union_type
**
7342 find_next_input_statement (lang_statement_union_type
**s
)
7344 for ( ; *s
; s
= &(*s
)->header
.next
)
7346 lang_statement_union_type
**t
;
7347 switch ((*s
)->header
.type
)
7349 case lang_input_statement_enum
:
7351 case lang_wild_statement_enum
:
7352 t
= &(*s
)->wild_statement
.children
.head
;
7354 case lang_group_statement_enum
:
7355 t
= &(*s
)->group_statement
.children
.head
;
7357 case lang_output_section_statement_enum
:
7358 t
= &(*s
)->output_section_statement
.children
.head
;
7363 t
= find_next_input_statement (t
);
7369 #endif /* ENABLE_PLUGINS */
7371 /* Add NAME to the list of garbage collection entry points. */
7374 lang_add_gc_name (const char *name
)
7376 struct bfd_sym_chain
*sym
;
7381 sym
= stat_alloc (sizeof (*sym
));
7383 sym
->next
= link_info
.gc_sym_list
;
7385 link_info
.gc_sym_list
= sym
;
7388 /* Check relocations. */
7391 lang_check_relocs (void)
7393 if (link_info
.check_relocs_after_open_input
)
7397 for (abfd
= link_info
.input_bfds
;
7398 abfd
!= (bfd
*) NULL
; abfd
= abfd
->link
.next
)
7399 if (!bfd_link_check_relocs (abfd
, &link_info
))
7401 /* No object output, fail return. */
7402 config
.make_executable
= FALSE
;
7403 /* Note: we do not abort the loop, but rather
7404 continue the scan in case there are other
7405 bad relocations to report. */
7410 /* Look through all output sections looking for places where we can
7411 propagate forward the lma region. */
7414 lang_propagate_lma_regions (void)
7416 lang_output_section_statement_type
*os
;
7418 for (os
= &lang_os_list
.head
->output_section_statement
;
7422 if (os
->prev
!= NULL
7423 && os
->lma_region
== NULL
7424 && os
->load_base
== NULL
7425 && os
->addr_tree
== NULL
7426 && os
->region
== os
->prev
->region
)
7427 os
->lma_region
= os
->prev
->lma_region
;
7434 /* Finalize dynamic list. */
7435 if (link_info
.dynamic_list
)
7436 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
7438 current_target
= default_target
;
7440 /* Open the output file. */
7441 lang_for_each_statement (ldlang_open_output
);
7444 ldemul_create_output_section_statements ();
7446 /* Add to the hash table all undefineds on the command line. */
7447 lang_place_undefineds ();
7449 if (!bfd_section_already_linked_table_init ())
7450 einfo (_("%F%P: can not create hash table: %E\n"));
7452 /* Create a bfd for each input file. */
7453 current_target
= default_target
;
7454 lang_statement_iteration
++;
7455 open_input_bfds (statement_list
.head
, OPEN_BFD_NORMAL
);
7456 /* open_input_bfds also handles assignments, so we can give values
7457 to symbolic origin/length now. */
7458 lang_do_memory_regions ();
7460 #ifdef ENABLE_PLUGINS
7461 if (link_info
.lto_plugin_active
)
7463 lang_statement_list_type added
;
7464 lang_statement_list_type files
, inputfiles
;
7466 /* Now all files are read, let the plugin(s) decide if there
7467 are any more to be added to the link before we call the
7468 emulation's after_open hook. We create a private list of
7469 input statements for this purpose, which we will eventually
7470 insert into the global statement list after the first claimed
7473 /* We need to manipulate all three chains in synchrony. */
7475 inputfiles
= input_file_chain
;
7476 if (plugin_call_all_symbols_read ())
7477 einfo (_("%F%P: %s: plugin reported error after all symbols read\n"),
7478 plugin_error_plugin ());
7479 /* Open any newly added files, updating the file chains. */
7480 plugin_undefs
= link_info
.hash
->undefs_tail
;
7481 open_input_bfds (*added
.tail
, OPEN_BFD_NORMAL
);
7482 if (plugin_undefs
== link_info
.hash
->undefs_tail
)
7483 plugin_undefs
= NULL
;
7484 /* Restore the global list pointer now they have all been added. */
7485 lang_list_remove_tail (stat_ptr
, &added
);
7486 /* And detach the fresh ends of the file lists. */
7487 lang_list_remove_tail (&file_chain
, &files
);
7488 lang_list_remove_tail (&input_file_chain
, &inputfiles
);
7489 /* Were any new files added? */
7490 if (added
.head
!= NULL
)
7492 /* If so, we will insert them into the statement list immediately
7493 after the first input file that was claimed by the plugin,
7494 unless that file was an archive in which case it is inserted
7495 immediately before. */
7497 lang_statement_union_type
**prev
;
7498 plugin_insert
= find_replacements_insert_point (&before
);
7499 /* If a plugin adds input files without having claimed any, we
7500 don't really have a good idea where to place them. Just putting
7501 them at the start or end of the list is liable to leave them
7502 outside the crtbegin...crtend range. */
7503 ASSERT (plugin_insert
!= NULL
);
7504 /* Splice the new statement list into the old one. */
7505 prev
= &plugin_insert
->header
.next
;
7508 prev
= find_next_input_statement (prev
);
7509 if (*prev
!= (void *) plugin_insert
->next_real_file
)
7511 /* We didn't find the expected input statement.
7512 Fall back to adding after plugin_insert. */
7513 prev
= &plugin_insert
->header
.next
;
7516 lang_list_insert_after (stat_ptr
, &added
, prev
);
7517 /* Likewise for the file chains. */
7518 lang_list_insert_after (&input_file_chain
, &inputfiles
,
7519 (void *) &plugin_insert
->next_real_file
);
7520 /* We must be careful when relinking file_chain; we may need to
7521 insert the new files at the head of the list if the insert
7522 point chosen is the dummy first input file. */
7523 if (plugin_insert
->filename
)
7524 lang_list_insert_after (&file_chain
, &files
,
7525 (void *) &plugin_insert
->next
);
7527 lang_list_insert_after (&file_chain
, &files
, &file_chain
.head
);
7529 /* Rescan archives in case new undefined symbols have appeared. */
7531 lang_statement_iteration
++;
7532 open_input_bfds (statement_list
.head
, OPEN_BFD_RESCAN
);
7533 lang_list_remove_tail (&file_chain
, &files
);
7534 while (files
.head
!= NULL
)
7536 lang_input_statement_type
**insert
;
7537 lang_input_statement_type
**iter
, *temp
;
7540 insert
= find_rescan_insertion (&files
.head
->input_statement
);
7541 /* All elements from an archive can be added at once. */
7542 iter
= &files
.head
->input_statement
.next
;
7543 my_arch
= files
.head
->input_statement
.the_bfd
->my_archive
;
7544 if (my_arch
!= NULL
)
7545 for (; *iter
!= NULL
; iter
= &(*iter
)->next
)
7546 if ((*iter
)->the_bfd
->my_archive
!= my_arch
)
7549 *insert
= &files
.head
->input_statement
;
7550 files
.head
= (lang_statement_union_type
*) *iter
;
7552 if (my_arch
!= NULL
)
7554 lang_input_statement_type
*parent
= my_arch
->usrdata
;
7556 parent
->next
= (lang_input_statement_type
*)
7558 - offsetof (lang_input_statement_type
, next
));
7563 #endif /* ENABLE_PLUGINS */
7565 /* Make sure that nobody has tried to add a symbol to this list
7567 ASSERT (link_info
.gc_sym_list
== NULL
);
7569 link_info
.gc_sym_list
= &entry_symbol
;
7571 if (entry_symbol
.name
== NULL
)
7573 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
7575 /* entry_symbol is normally initialied by a ENTRY definition in the
7576 linker script or the -e command line option. But if neither of
7577 these have been used, the target specific backend may still have
7578 provided an entry symbol via a call to lang_default_entry().
7579 Unfortunately this value will not be processed until lang_end()
7580 is called, long after this function has finished. So detect this
7581 case here and add the target's entry symbol to the list of starting
7582 points for garbage collection resolution. */
7583 lang_add_gc_name (entry_symbol_default
);
7586 lang_add_gc_name (link_info
.init_function
);
7587 lang_add_gc_name (link_info
.fini_function
);
7589 ldemul_after_open ();
7590 if (config
.map_file
!= NULL
)
7591 lang_print_asneeded ();
7593 bfd_section_already_linked_table_free ();
7595 /* Make sure that we're not mixing architectures. We call this
7596 after all the input files have been opened, but before we do any
7597 other processing, so that any operations merge_private_bfd_data
7598 does on the output file will be known during the rest of the
7602 /* Handle .exports instead of a version script if we're told to do so. */
7603 if (command_line
.version_exports_section
)
7604 lang_do_version_exports_section ();
7606 /* Build all sets based on the information gathered from the input
7608 ldctor_build_sets ();
7610 /* Give initial values for __start and __stop symbols, so that ELF
7611 gc_sections will keep sections referenced by these symbols. Must
7612 be done before lang_do_assignments below. */
7613 if (config
.build_constructors
)
7614 lang_init_start_stop ();
7616 /* PR 13683: We must rerun the assignments prior to running garbage
7617 collection in order to make sure that all symbol aliases are resolved. */
7618 lang_do_assignments (lang_mark_phase_enum
);
7619 expld
.phase
= lang_first_phase_enum
;
7621 /* Size up the common data. */
7624 /* Remove unreferenced sections if asked to. */
7625 lang_gc_sections ();
7627 /* Check relocations. */
7628 lang_check_relocs ();
7630 ldemul_after_check_relocs ();
7632 /* Update wild statements. */
7633 update_wild_statements (statement_list
.head
);
7635 /* Run through the contours of the script and attach input sections
7636 to the correct output sections. */
7637 lang_statement_iteration
++;
7638 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
7640 /* Start at the statement immediately after the special abs_section
7641 output statement, so that it isn't reordered. */
7642 process_insert_statements (&lang_os_list
.head
->header
.next
);
7644 /* Find any sections not attached explicitly and handle them. */
7645 lang_place_orphans ();
7647 if (!bfd_link_relocatable (&link_info
))
7651 /* Merge SEC_MERGE sections. This has to be done after GC of
7652 sections, so that GCed sections are not merged, but before
7653 assigning dynamic symbols, since removing whole input sections
7655 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
7657 /* Look for a text section and set the readonly attribute in it. */
7658 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
7662 if (config
.text_read_only
)
7663 found
->flags
|= SEC_READONLY
;
7665 found
->flags
&= ~SEC_READONLY
;
7669 /* Copy forward lma regions for output sections in same lma region. */
7670 lang_propagate_lma_regions ();
7672 /* Defining __start/__stop symbols early for --gc-sections to work
7673 around a glibc build problem can result in these symbols being
7674 defined when they should not be. Fix them now. */
7675 if (config
.build_constructors
)
7676 lang_undef_start_stop ();
7678 /* Define .startof./.sizeof. symbols with preliminary values before
7679 dynamic symbols are created. */
7680 if (!bfd_link_relocatable (&link_info
))
7681 lang_init_startof_sizeof ();
7683 /* Do anything special before sizing sections. This is where ELF
7684 and other back-ends size dynamic sections. */
7685 ldemul_before_allocation ();
7687 /* We must record the program headers before we try to fix the
7688 section positions, since they will affect SIZEOF_HEADERS. */
7689 lang_record_phdrs ();
7691 /* Check relro sections. */
7692 if (link_info
.relro
&& !bfd_link_relocatable (&link_info
))
7693 lang_find_relro_sections ();
7695 /* Size up the sections. */
7696 lang_size_sections (NULL
, !RELAXATION_ENABLED
);
7698 /* See if anything special should be done now we know how big
7699 everything is. This is where relaxation is done. */
7700 ldemul_after_allocation ();
7702 /* Fix any __start, __stop, .startof. or .sizeof. symbols. */
7703 lang_finalize_start_stop ();
7705 /* Do all the assignments again, to report errors. Assignment
7706 statements are processed multiple times, updating symbols; In
7707 open_input_bfds, lang_do_assignments, and lang_size_sections.
7708 Since lang_relax_sections calls lang_do_assignments, symbols are
7709 also updated in ldemul_after_allocation. */
7710 lang_do_assignments (lang_final_phase_enum
);
7714 /* Convert absolute symbols to section relative. */
7715 ldexp_finalize_syms ();
7717 /* Make sure that the section addresses make sense. */
7718 if (command_line
.check_section_addresses
)
7719 lang_check_section_addresses ();
7721 /* Check any required symbols are known. */
7722 ldlang_check_require_defined_symbols ();
7727 /* EXPORTED TO YACC */
7730 lang_add_wild (struct wildcard_spec
*filespec
,
7731 struct wildcard_list
*section_list
,
7732 bfd_boolean keep_sections
)
7734 struct wildcard_list
*curr
, *next
;
7735 lang_wild_statement_type
*new_stmt
;
7737 /* Reverse the list as the parser puts it back to front. */
7738 for (curr
= section_list
, section_list
= NULL
;
7740 section_list
= curr
, curr
= next
)
7743 curr
->next
= section_list
;
7746 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
7748 if (strcmp (filespec
->name
, "*") == 0)
7749 filespec
->name
= NULL
;
7750 else if (!wildcardp (filespec
->name
))
7751 lang_has_input_file
= TRUE
;
7754 new_stmt
= new_stat (lang_wild_statement
, stat_ptr
);
7755 new_stmt
->filename
= NULL
;
7756 new_stmt
->filenames_sorted
= FALSE
;
7757 new_stmt
->section_flag_list
= NULL
;
7758 new_stmt
->exclude_name_list
= NULL
;
7759 if (filespec
!= NULL
)
7761 new_stmt
->filename
= filespec
->name
;
7762 new_stmt
->filenames_sorted
= filespec
->sorted
== by_name
;
7763 new_stmt
->section_flag_list
= filespec
->section_flag_list
;
7764 new_stmt
->exclude_name_list
= filespec
->exclude_name_list
;
7766 new_stmt
->section_list
= section_list
;
7767 new_stmt
->keep_sections
= keep_sections
;
7768 lang_list_init (&new_stmt
->children
);
7769 analyze_walk_wild_section_handler (new_stmt
);
7773 lang_section_start (const char *name
, etree_type
*address
,
7774 const segment_type
*segment
)
7776 lang_address_statement_type
*ad
;
7778 ad
= new_stat (lang_address_statement
, stat_ptr
);
7779 ad
->section_name
= name
;
7780 ad
->address
= address
;
7781 ad
->segment
= segment
;
7784 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
7785 because of a -e argument on the command line, or zero if this is
7786 called by ENTRY in a linker script. Command line arguments take
7790 lang_add_entry (const char *name
, bfd_boolean cmdline
)
7792 if (entry_symbol
.name
== NULL
7794 || !entry_from_cmdline
)
7796 entry_symbol
.name
= name
;
7797 entry_from_cmdline
= cmdline
;
7801 /* Set the default start symbol to NAME. .em files should use this,
7802 not lang_add_entry, to override the use of "start" if neither the
7803 linker script nor the command line specifies an entry point. NAME
7804 must be permanently allocated. */
7806 lang_default_entry (const char *name
)
7808 entry_symbol_default
= name
;
7812 lang_add_target (const char *name
)
7814 lang_target_statement_type
*new_stmt
;
7816 new_stmt
= new_stat (lang_target_statement
, stat_ptr
);
7817 new_stmt
->target
= name
;
7821 lang_add_map (const char *name
)
7828 map_option_f
= TRUE
;
7836 lang_add_fill (fill_type
*fill
)
7838 lang_fill_statement_type
*new_stmt
;
7840 new_stmt
= new_stat (lang_fill_statement
, stat_ptr
);
7841 new_stmt
->fill
= fill
;
7845 lang_add_data (int type
, union etree_union
*exp
)
7847 lang_data_statement_type
*new_stmt
;
7849 new_stmt
= new_stat (lang_data_statement
, stat_ptr
);
7850 new_stmt
->exp
= exp
;
7851 new_stmt
->type
= type
;
7854 /* Create a new reloc statement. RELOC is the BFD relocation type to
7855 generate. HOWTO is the corresponding howto structure (we could
7856 look this up, but the caller has already done so). SECTION is the
7857 section to generate a reloc against, or NAME is the name of the
7858 symbol to generate a reloc against. Exactly one of SECTION and
7859 NAME must be NULL. ADDEND is an expression for the addend. */
7862 lang_add_reloc (bfd_reloc_code_real_type reloc
,
7863 reloc_howto_type
*howto
,
7866 union etree_union
*addend
)
7868 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
7872 p
->section
= section
;
7874 p
->addend_exp
= addend
;
7876 p
->addend_value
= 0;
7877 p
->output_section
= NULL
;
7878 p
->output_offset
= 0;
7881 lang_assignment_statement_type
*
7882 lang_add_assignment (etree_type
*exp
)
7884 lang_assignment_statement_type
*new_stmt
;
7886 new_stmt
= new_stat (lang_assignment_statement
, stat_ptr
);
7887 new_stmt
->exp
= exp
;
7892 lang_add_attribute (enum statement_enum attribute
)
7894 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
7898 lang_startup (const char *name
)
7900 if (first_file
->filename
!= NULL
)
7902 einfo (_("%F%P: multiple STARTUP files\n"));
7904 first_file
->filename
= name
;
7905 first_file
->local_sym_name
= name
;
7906 first_file
->flags
.real
= TRUE
;
7910 lang_float (bfd_boolean maybe
)
7912 lang_float_flag
= maybe
;
7916 /* Work out the load- and run-time regions from a script statement, and
7917 store them in *LMA_REGION and *REGION respectively.
7919 MEMSPEC is the name of the run-time region, or the value of
7920 DEFAULT_MEMORY_REGION if the statement didn't specify one.
7921 LMA_MEMSPEC is the name of the load-time region, or null if the
7922 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
7923 had an explicit load address.
7925 It is an error to specify both a load region and a load address. */
7928 lang_get_regions (lang_memory_region_type
**region
,
7929 lang_memory_region_type
**lma_region
,
7930 const char *memspec
,
7931 const char *lma_memspec
,
7932 bfd_boolean have_lma
,
7933 bfd_boolean have_vma
)
7935 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
7937 /* If no runtime region or VMA has been specified, but the load region
7938 has been specified, then use the load region for the runtime region
7940 if (lma_memspec
!= NULL
7942 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
7943 *region
= *lma_region
;
7945 *region
= lang_memory_region_lookup (memspec
, FALSE
);
7947 if (have_lma
&& lma_memspec
!= 0)
7948 einfo (_("%X%P:%pS: section has both a load address and a load region\n"),
7953 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
7954 lang_output_section_phdr_list
*phdrs
,
7955 const char *lma_memspec
)
7957 lang_get_regions (¤t_section
->region
,
7958 ¤t_section
->lma_region
,
7959 memspec
, lma_memspec
,
7960 current_section
->load_base
!= NULL
,
7961 current_section
->addr_tree
!= NULL
);
7963 current_section
->fill
= fill
;
7964 current_section
->phdrs
= phdrs
;
7968 /* Set the output format type. -oformat overrides scripts. */
7971 lang_add_output_format (const char *format
,
7976 if (output_target
== NULL
|| !from_script
)
7978 if (command_line
.endian
== ENDIAN_BIG
7981 else if (command_line
.endian
== ENDIAN_LITTLE
7985 output_target
= format
;
7990 lang_add_insert (const char *where
, int is_before
)
7992 lang_insert_statement_type
*new_stmt
;
7994 new_stmt
= new_stat (lang_insert_statement
, stat_ptr
);
7995 new_stmt
->where
= where
;
7996 new_stmt
->is_before
= is_before
;
7997 saved_script_handle
= previous_script_handle
;
8000 /* Enter a group. This creates a new lang_group_statement, and sets
8001 stat_ptr to build new statements within the group. */
8004 lang_enter_group (void)
8006 lang_group_statement_type
*g
;
8008 g
= new_stat (lang_group_statement
, stat_ptr
);
8009 lang_list_init (&g
->children
);
8010 push_stat_ptr (&g
->children
);
8013 /* Leave a group. This just resets stat_ptr to start writing to the
8014 regular list of statements again. Note that this will not work if
8015 groups can occur inside anything else which can adjust stat_ptr,
8016 but currently they can't. */
8019 lang_leave_group (void)
8024 /* Add a new program header. This is called for each entry in a PHDRS
8025 command in a linker script. */
8028 lang_new_phdr (const char *name
,
8030 bfd_boolean filehdr
,
8035 struct lang_phdr
*n
, **pp
;
8038 n
= stat_alloc (sizeof (struct lang_phdr
));
8041 n
->type
= exp_get_vma (type
, 0, "program header type");
8042 n
->filehdr
= filehdr
;
8047 hdrs
= n
->type
== 1 && (phdrs
|| filehdr
);
8049 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
8052 && !((*pp
)->filehdr
|| (*pp
)->phdrs
))
8054 einfo (_("%X%P:%pS: PHDRS and FILEHDR are not supported"
8055 " when prior PT_LOAD headers lack them\n"), NULL
);
8062 /* Record the program header information in the output BFD. FIXME: We
8063 should not be calling an ELF specific function here. */
8066 lang_record_phdrs (void)
8070 lang_output_section_phdr_list
*last
;
8071 struct lang_phdr
*l
;
8072 lang_output_section_statement_type
*os
;
8075 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
8078 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
8085 for (os
= &lang_os_list
.head
->output_section_statement
;
8089 lang_output_section_phdr_list
*pl
;
8091 if (os
->constraint
< 0)
8099 if (os
->sectype
== noload_section
8100 || os
->bfd_section
== NULL
8101 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
8104 /* Don't add orphans to PT_INTERP header. */
8110 lang_output_section_statement_type
*tmp_os
;
8112 /* If we have not run across a section with a program
8113 header assigned to it yet, then scan forwards to find
8114 one. This prevents inconsistencies in the linker's
8115 behaviour when a script has specified just a single
8116 header and there are sections in that script which are
8117 not assigned to it, and which occur before the first
8118 use of that header. See here for more details:
8119 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
8120 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
8123 last
= tmp_os
->phdrs
;
8127 einfo (_("%F%P: no sections assigned to phdrs\n"));
8132 if (os
->bfd_section
== NULL
)
8135 for (; pl
!= NULL
; pl
= pl
->next
)
8137 if (strcmp (pl
->name
, l
->name
) == 0)
8142 secs
= (asection
**) xrealloc (secs
,
8143 alc
* sizeof (asection
*));
8145 secs
[c
] = os
->bfd_section
;
8152 if (l
->flags
== NULL
)
8155 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
8160 at
= exp_get_vma (l
->at
, 0, "phdr load address");
8162 if (!bfd_record_phdr (link_info
.output_bfd
, l
->type
,
8163 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
8164 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
8165 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
8170 /* Make sure all the phdr assignments succeeded. */
8171 for (os
= &lang_os_list
.head
->output_section_statement
;
8175 lang_output_section_phdr_list
*pl
;
8177 if (os
->constraint
< 0
8178 || os
->bfd_section
== NULL
)
8181 for (pl
= os
->phdrs
;
8184 if (!pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
8185 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
8186 os
->name
, pl
->name
);
8190 /* Record a list of sections which may not be cross referenced. */
8193 lang_add_nocrossref (lang_nocrossref_type
*l
)
8195 struct lang_nocrossrefs
*n
;
8197 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
8198 n
->next
= nocrossref_list
;
8200 n
->onlyfirst
= FALSE
;
8201 nocrossref_list
= n
;
8203 /* Set notice_all so that we get informed about all symbols. */
8204 link_info
.notice_all
= TRUE
;
8207 /* Record a section that cannot be referenced from a list of sections. */
8210 lang_add_nocrossref_to (lang_nocrossref_type
*l
)
8212 lang_add_nocrossref (l
);
8213 nocrossref_list
->onlyfirst
= TRUE
;
8216 /* Overlay handling. We handle overlays with some static variables. */
8218 /* The overlay virtual address. */
8219 static etree_type
*overlay_vma
;
8220 /* And subsection alignment. */
8221 static etree_type
*overlay_subalign
;
8223 /* An expression for the maximum section size seen so far. */
8224 static etree_type
*overlay_max
;
8226 /* A list of all the sections in this overlay. */
8228 struct overlay_list
{
8229 struct overlay_list
*next
;
8230 lang_output_section_statement_type
*os
;
8233 static struct overlay_list
*overlay_list
;
8235 /* Start handling an overlay. */
8238 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
8240 /* The grammar should prevent nested overlays from occurring. */
8241 ASSERT (overlay_vma
== NULL
8242 && overlay_subalign
== NULL
8243 && overlay_max
== NULL
);
8245 overlay_vma
= vma_expr
;
8246 overlay_subalign
= subalign
;
8249 /* Start a section in an overlay. We handle this by calling
8250 lang_enter_output_section_statement with the correct VMA.
8251 lang_leave_overlay sets up the LMA and memory regions. */
8254 lang_enter_overlay_section (const char *name
)
8256 struct overlay_list
*n
;
8259 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
8260 0, overlay_subalign
, 0, 0, 0);
8262 /* If this is the first section, then base the VMA of future
8263 sections on this one. This will work correctly even if `.' is
8264 used in the addresses. */
8265 if (overlay_list
== NULL
)
8266 overlay_vma
= exp_nameop (ADDR
, name
);
8268 /* Remember the section. */
8269 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
8270 n
->os
= current_section
;
8271 n
->next
= overlay_list
;
8274 size
= exp_nameop (SIZEOF
, name
);
8276 /* Arrange to work out the maximum section end address. */
8277 if (overlay_max
== NULL
)
8280 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
8283 /* Finish a section in an overlay. There isn't any special to do
8287 lang_leave_overlay_section (fill_type
*fill
,
8288 lang_output_section_phdr_list
*phdrs
)
8295 name
= current_section
->name
;
8297 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
8298 region and that no load-time region has been specified. It doesn't
8299 really matter what we say here, since lang_leave_overlay will
8301 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
8303 /* Define the magic symbols. */
8305 clean
= (char *) xmalloc (strlen (name
) + 1);
8307 for (s1
= name
; *s1
!= '\0'; s1
++)
8308 if (ISALNUM (*s1
) || *s1
== '_')
8312 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_start_");
8313 sprintf (buf
, "__load_start_%s", clean
);
8314 lang_add_assignment (exp_provide (buf
,
8315 exp_nameop (LOADADDR
, name
),
8318 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_stop_");
8319 sprintf (buf
, "__load_stop_%s", clean
);
8320 lang_add_assignment (exp_provide (buf
,
8322 exp_nameop (LOADADDR
, name
),
8323 exp_nameop (SIZEOF
, name
)),
8329 /* Finish an overlay. If there are any overlay wide settings, this
8330 looks through all the sections in the overlay and sets them. */
8333 lang_leave_overlay (etree_type
*lma_expr
,
8336 const char *memspec
,
8337 lang_output_section_phdr_list
*phdrs
,
8338 const char *lma_memspec
)
8340 lang_memory_region_type
*region
;
8341 lang_memory_region_type
*lma_region
;
8342 struct overlay_list
*l
;
8343 lang_nocrossref_type
*nocrossref
;
8345 lang_get_regions (®ion
, &lma_region
,
8346 memspec
, lma_memspec
,
8347 lma_expr
!= NULL
, FALSE
);
8351 /* After setting the size of the last section, set '.' to end of the
8353 if (overlay_list
!= NULL
)
8355 overlay_list
->os
->update_dot
= 1;
8356 overlay_list
->os
->update_dot_tree
8357 = exp_assign (".", exp_binop ('+', overlay_vma
, overlay_max
), FALSE
);
8363 struct overlay_list
*next
;
8365 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
8368 l
->os
->region
= region
;
8369 l
->os
->lma_region
= lma_region
;
8371 /* The first section has the load address specified in the
8372 OVERLAY statement. The rest are worked out from that.
8373 The base address is not needed (and should be null) if
8374 an LMA region was specified. */
8377 l
->os
->load_base
= lma_expr
;
8378 l
->os
->sectype
= first_overlay_section
;
8380 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
8381 l
->os
->phdrs
= phdrs
;
8385 lang_nocrossref_type
*nc
;
8387 nc
= (lang_nocrossref_type
*) xmalloc (sizeof *nc
);
8388 nc
->name
= l
->os
->name
;
8389 nc
->next
= nocrossref
;
8398 if (nocrossref
!= NULL
)
8399 lang_add_nocrossref (nocrossref
);
8402 overlay_list
= NULL
;
8404 overlay_subalign
= NULL
;
8407 /* Version handling. This is only useful for ELF. */
8409 /* If PREV is NULL, return first version pattern matching particular symbol.
8410 If PREV is non-NULL, return first version pattern matching particular
8411 symbol after PREV (previously returned by lang_vers_match). */
8413 static struct bfd_elf_version_expr
*
8414 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
8415 struct bfd_elf_version_expr
*prev
,
8419 const char *cxx_sym
= sym
;
8420 const char *java_sym
= sym
;
8421 struct bfd_elf_version_expr
*expr
= NULL
;
8422 enum demangling_styles curr_style
;
8424 curr_style
= CURRENT_DEMANGLING_STYLE
;
8425 cplus_demangle_set_style (no_demangling
);
8426 c_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_NO_OPTS
);
8429 cplus_demangle_set_style (curr_style
);
8431 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8433 cxx_sym
= bfd_demangle (link_info
.output_bfd
, sym
,
8434 DMGL_PARAMS
| DMGL_ANSI
);
8438 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8440 java_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_JAVA
);
8445 if (head
->htab
&& (prev
== NULL
|| prev
->literal
))
8447 struct bfd_elf_version_expr e
;
8449 switch (prev
? prev
->mask
: 0)
8452 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
8455 expr
= (struct bfd_elf_version_expr
*)
8456 htab_find ((htab_t
) head
->htab
, &e
);
8457 while (expr
&& strcmp (expr
->pattern
, c_sym
) == 0)
8458 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
8464 case BFD_ELF_VERSION_C_TYPE
:
8465 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8467 e
.pattern
= cxx_sym
;
8468 expr
= (struct bfd_elf_version_expr
*)
8469 htab_find ((htab_t
) head
->htab
, &e
);
8470 while (expr
&& strcmp (expr
->pattern
, cxx_sym
) == 0)
8471 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
8477 case BFD_ELF_VERSION_CXX_TYPE
:
8478 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8480 e
.pattern
= java_sym
;
8481 expr
= (struct bfd_elf_version_expr
*)
8482 htab_find ((htab_t
) head
->htab
, &e
);
8483 while (expr
&& strcmp (expr
->pattern
, java_sym
) == 0)
8484 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8495 /* Finally, try the wildcards. */
8496 if (prev
== NULL
|| prev
->literal
)
8497 expr
= head
->remaining
;
8500 for (; expr
; expr
= expr
->next
)
8507 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
8510 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8512 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
8516 if (fnmatch (expr
->pattern
, s
, 0) == 0)
8522 free ((char *) c_sym
);
8524 free ((char *) cxx_sym
);
8525 if (java_sym
!= sym
)
8526 free ((char *) java_sym
);
8530 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
8531 return a pointer to the symbol name with any backslash quotes removed. */
8534 realsymbol (const char *pattern
)
8537 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
8538 char *s
, *symbol
= (char *) xmalloc (strlen (pattern
) + 1);
8540 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
8542 /* It is a glob pattern only if there is no preceding
8546 /* Remove the preceding backslash. */
8553 if (*p
== '?' || *p
== '*' || *p
== '[')
8560 backslash
= *p
== '\\';
8576 /* This is called for each variable name or match expression. NEW_NAME is
8577 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
8578 pattern to be matched against symbol names. */
8580 struct bfd_elf_version_expr
*
8581 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
8582 const char *new_name
,
8584 bfd_boolean literal_p
)
8586 struct bfd_elf_version_expr
*ret
;
8588 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
8592 ret
->literal
= TRUE
;
8593 ret
->pattern
= literal_p
? new_name
: realsymbol (new_name
);
8594 if (ret
->pattern
== NULL
)
8596 ret
->pattern
= new_name
;
8597 ret
->literal
= FALSE
;
8600 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
8601 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
8602 else if (strcasecmp (lang
, "C++") == 0)
8603 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
8604 else if (strcasecmp (lang
, "Java") == 0)
8605 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
8608 einfo (_("%X%P: unknown language `%s' in version information\n"),
8610 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
8613 return ldemul_new_vers_pattern (ret
);
8616 /* This is called for each set of variable names and match
8619 struct bfd_elf_version_tree
*
8620 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
8621 struct bfd_elf_version_expr
*locals
)
8623 struct bfd_elf_version_tree
*ret
;
8625 ret
= (struct bfd_elf_version_tree
*) xcalloc (1, sizeof *ret
);
8626 ret
->globals
.list
= globals
;
8627 ret
->locals
.list
= locals
;
8628 ret
->match
= lang_vers_match
;
8629 ret
->name_indx
= (unsigned int) -1;
8633 /* This static variable keeps track of version indices. */
8635 static int version_index
;
8638 version_expr_head_hash (const void *p
)
8640 const struct bfd_elf_version_expr
*e
=
8641 (const struct bfd_elf_version_expr
*) p
;
8643 return htab_hash_string (e
->pattern
);
8647 version_expr_head_eq (const void *p1
, const void *p2
)
8649 const struct bfd_elf_version_expr
*e1
=
8650 (const struct bfd_elf_version_expr
*) p1
;
8651 const struct bfd_elf_version_expr
*e2
=
8652 (const struct bfd_elf_version_expr
*) p2
;
8654 return strcmp (e1
->pattern
, e2
->pattern
) == 0;
8658 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
8661 struct bfd_elf_version_expr
*e
, *next
;
8662 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
8664 for (e
= head
->list
; e
; e
= e
->next
)
8668 head
->mask
|= e
->mask
;
8673 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
8674 version_expr_head_eq
, NULL
);
8675 list_loc
= &head
->list
;
8676 remaining_loc
= &head
->remaining
;
8677 for (e
= head
->list
; e
; e
= next
)
8683 remaining_loc
= &e
->next
;
8687 void **loc
= htab_find_slot ((htab_t
) head
->htab
, e
, INSERT
);
8691 struct bfd_elf_version_expr
*e1
, *last
;
8693 e1
= (struct bfd_elf_version_expr
*) *loc
;
8697 if (e1
->mask
== e
->mask
)
8705 while (e1
&& strcmp (e1
->pattern
, e
->pattern
) == 0);
8709 /* This is a duplicate. */
8710 /* FIXME: Memory leak. Sometimes pattern is not
8711 xmalloced alone, but in larger chunk of memory. */
8712 /* free (e->pattern); */
8717 e
->next
= last
->next
;
8725 list_loc
= &e
->next
;
8729 *remaining_loc
= NULL
;
8730 *list_loc
= head
->remaining
;
8733 head
->remaining
= head
->list
;
8736 /* This is called when we know the name and dependencies of the
8740 lang_register_vers_node (const char *name
,
8741 struct bfd_elf_version_tree
*version
,
8742 struct bfd_elf_version_deps
*deps
)
8744 struct bfd_elf_version_tree
*t
, **pp
;
8745 struct bfd_elf_version_expr
*e1
;
8750 if (link_info
.version_info
!= NULL
8751 && (name
[0] == '\0' || link_info
.version_info
->name
[0] == '\0'))
8753 einfo (_("%X%P: anonymous version tag cannot be combined"
8754 " with other version tags\n"));
8759 /* Make sure this node has a unique name. */
8760 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8761 if (strcmp (t
->name
, name
) == 0)
8762 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
8764 lang_finalize_version_expr_head (&version
->globals
);
8765 lang_finalize_version_expr_head (&version
->locals
);
8767 /* Check the global and local match names, and make sure there
8768 aren't any duplicates. */
8770 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
8772 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8774 struct bfd_elf_version_expr
*e2
;
8776 if (t
->locals
.htab
&& e1
->literal
)
8778 e2
= (struct bfd_elf_version_expr
*)
8779 htab_find ((htab_t
) t
->locals
.htab
, e1
);
8780 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
8782 if (e1
->mask
== e2
->mask
)
8783 einfo (_("%X%P: duplicate expression `%s'"
8784 " in version information\n"), e1
->pattern
);
8788 else if (!e1
->literal
)
8789 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
8790 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
8791 && e1
->mask
== e2
->mask
)
8792 einfo (_("%X%P: duplicate expression `%s'"
8793 " in version information\n"), e1
->pattern
);
8797 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
8799 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8801 struct bfd_elf_version_expr
*e2
;
8803 if (t
->globals
.htab
&& e1
->literal
)
8805 e2
= (struct bfd_elf_version_expr
*)
8806 htab_find ((htab_t
) t
->globals
.htab
, e1
);
8807 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
8809 if (e1
->mask
== e2
->mask
)
8810 einfo (_("%X%P: duplicate expression `%s'"
8811 " in version information\n"),
8816 else if (!e1
->literal
)
8817 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
8818 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
8819 && e1
->mask
== e2
->mask
)
8820 einfo (_("%X%P: duplicate expression `%s'"
8821 " in version information\n"), e1
->pattern
);
8825 version
->deps
= deps
;
8826 version
->name
= name
;
8827 if (name
[0] != '\0')
8830 version
->vernum
= version_index
;
8833 version
->vernum
= 0;
8835 for (pp
= &link_info
.version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
8840 /* This is called when we see a version dependency. */
8842 struct bfd_elf_version_deps
*
8843 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
8845 struct bfd_elf_version_deps
*ret
;
8846 struct bfd_elf_version_tree
*t
;
8848 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
8851 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8853 if (strcmp (t
->name
, name
) == 0)
8855 ret
->version_needed
= t
;
8860 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
8862 ret
->version_needed
= NULL
;
8867 lang_do_version_exports_section (void)
8869 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
8871 LANG_FOR_EACH_INPUT_STATEMENT (is
)
8873 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
8881 contents
= (char *) xmalloc (len
);
8882 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
8883 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
8886 while (p
< contents
+ len
)
8888 greg
= lang_new_vers_pattern (greg
, p
, NULL
, FALSE
);
8889 p
= strchr (p
, '\0') + 1;
8892 /* Do not free the contents, as we used them creating the regex. */
8894 /* Do not include this section in the link. */
8895 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
8898 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, FALSE
);
8899 lang_register_vers_node (command_line
.version_exports_section
,
8900 lang_new_vers_node (greg
, lreg
), NULL
);
8903 /* Evaluate LENGTH and ORIGIN parts of MEMORY spec */
8906 lang_do_memory_regions (void)
8908 lang_memory_region_type
*r
= lang_memory_region_list
;
8910 for (; r
!= NULL
; r
= r
->next
)
8914 exp_fold_tree_no_dot (r
->origin_exp
);
8915 if (expld
.result
.valid_p
)
8917 r
->origin
= expld
.result
.value
;
8918 r
->current
= r
->origin
;
8921 einfo (_("%F%P: invalid origin for memory region %s\n"),
8926 exp_fold_tree_no_dot (r
->length_exp
);
8927 if (expld
.result
.valid_p
)
8928 r
->length
= expld
.result
.value
;
8930 einfo (_("%F%P: invalid length for memory region %s\n"),
8937 lang_add_unique (const char *name
)
8939 struct unique_sections
*ent
;
8941 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
8942 if (strcmp (ent
->name
, name
) == 0)
8945 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
8946 ent
->name
= xstrdup (name
);
8947 ent
->next
= unique_section_list
;
8948 unique_section_list
= ent
;
8951 /* Append the list of dynamic symbols to the existing one. */
8954 lang_append_dynamic_list (struct bfd_elf_version_expr
*dynamic
)
8956 if (link_info
.dynamic_list
)
8958 struct bfd_elf_version_expr
*tail
;
8959 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
8961 tail
->next
= link_info
.dynamic_list
->head
.list
;
8962 link_info
.dynamic_list
->head
.list
= dynamic
;
8966 struct bfd_elf_dynamic_list
*d
;
8968 d
= (struct bfd_elf_dynamic_list
*) xcalloc (1, sizeof *d
);
8969 d
->head
.list
= dynamic
;
8970 d
->match
= lang_vers_match
;
8971 link_info
.dynamic_list
= d
;
8975 /* Append the list of C++ typeinfo dynamic symbols to the existing
8979 lang_append_dynamic_list_cpp_typeinfo (void)
8981 const char *symbols
[] =
8983 "typeinfo name for*",
8986 struct bfd_elf_version_expr
*dynamic
= NULL
;
8989 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
8990 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
8993 lang_append_dynamic_list (dynamic
);
8996 /* Append the list of C++ operator new and delete dynamic symbols to the
9000 lang_append_dynamic_list_cpp_new (void)
9002 const char *symbols
[] =
9007 struct bfd_elf_version_expr
*dynamic
= NULL
;
9010 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9011 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9014 lang_append_dynamic_list (dynamic
);
9017 /* Scan a space and/or comma separated string of features. */
9020 lang_ld_feature (char *str
)
9028 while (*p
== ',' || ISSPACE (*p
))
9033 while (*q
&& *q
!= ',' && !ISSPACE (*q
))
9037 if (strcasecmp (p
, "SANE_EXPR") == 0)
9038 config
.sane_expr
= TRUE
;
9040 einfo (_("%X%P: unknown feature `%s'\n"), p
);
9046 /* Pretty print memory amount. */
9049 lang_print_memory_size (bfd_vma sz
)
9051 if ((sz
& 0x3fffffff) == 0)
9052 printf ("%10" BFD_VMA_FMT
"u GB", sz
>> 30);
9053 else if ((sz
& 0xfffff) == 0)
9054 printf ("%10" BFD_VMA_FMT
"u MB", sz
>> 20);
9055 else if ((sz
& 0x3ff) == 0)
9056 printf ("%10" BFD_VMA_FMT
"u KB", sz
>> 10);
9058 printf (" %10" BFD_VMA_FMT
"u B", sz
);
9061 /* Implement --print-memory-usage: disply per region memory usage. */
9064 lang_print_memory_usage (void)
9066 lang_memory_region_type
*r
;
9068 printf ("Memory region Used Size Region Size %%age Used\n");
9069 for (r
= lang_memory_region_list
; r
->next
!= NULL
; r
= r
->next
)
9071 bfd_vma used_length
= r
->current
- r
->origin
;
9074 printf ("%16s: ",r
->name_list
.name
);
9075 lang_print_memory_size (used_length
);
9076 lang_print_memory_size ((bfd_vma
) r
->length
);
9078 percent
= used_length
* 100.0 / r
->length
;
9080 printf (" %6.2f%%\n", percent
);