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_output_section_statement
;
105 lang_statement_list_type
*stat_ptr
= &statement_list
;
106 /* Header for list of statements corresponding to files used in the final
107 executable. This can be either object file specified on the command-line
108 or library member resolving an undefined reference. Next pointer is in next
109 field of a lang_input_statement_type (reached via input_statement field in a
110 lang_statement_union). */
111 lang_statement_list_type file_chain
= { NULL
, NULL
};
112 /* Header for list of statements corresponding to files specified on the
113 command-line for linking. It thus contains real object files and archive
114 but not archive members. Next pointer is in next_real_file field of a
115 lang_input_statement_type statement (reached via input_statement field in a
116 lang_statement_union). */
117 lang_statement_list_type input_file_chain
;
118 struct bfd_sym_chain entry_symbol
= { NULL
, NULL
};
119 const char *entry_section
= ".text";
120 struct lang_input_statement_flags input_flags
;
121 bfd_boolean entry_from_cmdline
;
122 bfd_boolean undef_from_cmdline
;
123 bfd_boolean lang_has_input_file
= FALSE
;
124 bfd_boolean had_output_filename
= FALSE
;
125 bfd_boolean lang_float_flag
= FALSE
;
126 bfd_boolean delete_output_file_on_failure
= FALSE
;
127 struct lang_phdr
*lang_phdr_list
;
128 struct lang_nocrossrefs
*nocrossref_list
;
129 struct asneeded_minfo
**asneeded_list_tail
;
131 /* Functions that traverse the linker script and might evaluate
132 DEFINED() need to increment this at the start of the traversal. */
133 int lang_statement_iteration
= 0;
135 /* Return TRUE if the PATTERN argument is a wildcard pattern.
136 Although backslashes are treated specially if a pattern contains
137 wildcards, we do not consider the mere presence of a backslash to
138 be enough to cause the pattern to be treated as a wildcard.
139 That lets us handle DOS filenames more naturally. */
140 #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
142 #define new_stat(x, y) \
143 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
145 #define outside_section_address(q) \
146 ((q)->output_offset + (q)->output_section->vma)
148 #define outside_symbol_address(q) \
149 ((q)->value + outside_section_address (q->section))
151 #define SECTION_NAME_MAP_LENGTH (16)
154 stat_alloc (size_t size
)
156 return obstack_alloc (&stat_obstack
, size
);
160 name_match (const char *pattern
, const char *name
)
162 if (wildcardp (pattern
))
163 return fnmatch (pattern
, name
, 0);
164 return strcmp (pattern
, name
);
167 /* If PATTERN is of the form archive:file, return a pointer to the
168 separator. If not, return NULL. */
171 archive_path (const char *pattern
)
175 if (link_info
.path_separator
== 0)
178 p
= strchr (pattern
, link_info
.path_separator
);
179 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
180 if (p
== NULL
|| link_info
.path_separator
!= ':')
183 /* Assume a match on the second char is part of drive specifier,
184 as in "c:\silly.dos". */
185 if (p
== pattern
+ 1 && ISALPHA (*pattern
))
186 p
= strchr (p
+ 1, link_info
.path_separator
);
191 /* Given that FILE_SPEC results in a non-NULL SEP result from archive_path,
192 return whether F matches FILE_SPEC. */
195 input_statement_is_archive_path (const char *file_spec
, char *sep
,
196 lang_input_statement_type
*f
)
198 bfd_boolean match
= FALSE
;
201 || name_match (sep
+ 1, f
->filename
) == 0)
202 && ((sep
!= file_spec
)
203 == (f
->the_bfd
!= NULL
&& f
->the_bfd
->my_archive
!= NULL
)))
207 if (sep
!= file_spec
)
209 const char *aname
= f
->the_bfd
->my_archive
->filename
;
211 match
= name_match (file_spec
, aname
) == 0;
212 *sep
= link_info
.path_separator
;
219 unique_section_p (const asection
*sec
,
220 const lang_output_section_statement_type
*os
)
222 struct unique_sections
*unam
;
225 if (!link_info
.resolve_section_groups
226 && sec
->owner
!= NULL
227 && bfd_is_group_section (sec
->owner
, sec
))
229 && strcmp (os
->name
, DISCARD_SECTION_NAME
) == 0);
232 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
233 if (name_match (unam
->name
, secnam
) == 0)
239 /* Generic traversal routines for finding matching sections. */
241 /* Return true if FILE matches a pattern in EXCLUDE_LIST, otherwise return
245 walk_wild_file_in_exclude_list (struct name_list
*exclude_list
,
246 lang_input_statement_type
*file
)
248 struct name_list
*list_tmp
;
250 for (list_tmp
= exclude_list
;
252 list_tmp
= list_tmp
->next
)
254 char *p
= archive_path (list_tmp
->name
);
258 if (input_statement_is_archive_path (list_tmp
->name
, p
, file
))
262 else if (name_match (list_tmp
->name
, file
->filename
) == 0)
265 /* FIXME: Perhaps remove the following at some stage? Matching
266 unadorned archives like this was never documented and has
267 been superceded by the archive:path syntax. */
268 else if (file
->the_bfd
!= NULL
269 && file
->the_bfd
->my_archive
!= NULL
270 && name_match (list_tmp
->name
,
271 file
->the_bfd
->my_archive
->filename
) == 0)
278 /* Try processing a section against a wildcard. This just calls
279 the callback unless the filename exclusion list is present
280 and excludes the file. It's hardly ever present so this
281 function is very fast. */
284 walk_wild_consider_section (lang_wild_statement_type
*ptr
,
285 lang_input_statement_type
*file
,
287 struct wildcard_list
*sec
,
291 /* Don't process sections from files which were excluded. */
292 if (walk_wild_file_in_exclude_list (sec
->spec
.exclude_name_list
, file
))
295 (*callback
) (ptr
, sec
, s
, ptr
->section_flag_list
, file
, data
);
298 /* Lowest common denominator routine that can handle everything correctly,
302 walk_wild_section_general (lang_wild_statement_type
*ptr
,
303 lang_input_statement_type
*file
,
308 struct wildcard_list
*sec
;
310 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
312 sec
= ptr
->section_list
;
314 (*callback
) (ptr
, sec
, s
, ptr
->section_flag_list
, file
, data
);
318 bfd_boolean skip
= FALSE
;
320 if (sec
->spec
.name
!= NULL
)
322 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
324 skip
= name_match (sec
->spec
.name
, sname
) != 0;
328 walk_wild_consider_section (ptr
, file
, s
, sec
, callback
, data
);
335 /* Routines to find a single section given its name. If there's more
336 than one section with that name, we report that. */
340 asection
*found_section
;
341 bfd_boolean multiple_sections_found
;
342 } section_iterator_callback_data
;
345 section_iterator_callback (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*s
, void *data
)
347 section_iterator_callback_data
*d
= (section_iterator_callback_data
*) data
;
349 if (d
->found_section
!= NULL
)
351 d
->multiple_sections_found
= TRUE
;
355 d
->found_section
= s
;
360 find_section (lang_input_statement_type
*file
,
361 struct wildcard_list
*sec
,
362 bfd_boolean
*multiple_sections_found
)
364 section_iterator_callback_data cb_data
= { NULL
, FALSE
};
366 bfd_get_section_by_name_if (file
->the_bfd
, sec
->spec
.name
,
367 section_iterator_callback
, &cb_data
);
368 *multiple_sections_found
= cb_data
.multiple_sections_found
;
369 return cb_data
.found_section
;
372 /* Code for handling simple wildcards without going through fnmatch,
373 which can be expensive because of charset translations etc. */
375 /* A simple wild is a literal string followed by a single '*',
376 where the literal part is at least 4 characters long. */
379 is_simple_wild (const char *name
)
381 size_t len
= strcspn (name
, "*?[");
382 return len
>= 4 && name
[len
] == '*' && name
[len
+ 1] == '\0';
386 match_simple_wild (const char *pattern
, const char *name
)
388 /* The first four characters of the pattern are guaranteed valid
389 non-wildcard characters. So we can go faster. */
390 if (pattern
[0] != name
[0] || pattern
[1] != name
[1]
391 || pattern
[2] != name
[2] || pattern
[3] != name
[3])
396 while (*pattern
!= '*')
397 if (*name
++ != *pattern
++)
403 /* Return the numerical value of the init_priority attribute from
404 section name NAME. */
407 get_init_priority (const char *name
)
410 unsigned long init_priority
;
412 /* GCC uses the following section names for the init_priority
413 attribute with numerical values 101 and 65535 inclusive. A
414 lower value means a higher priority.
416 1: .init_array.NNNN/.fini_array.NNNN: Where NNNN is the
417 decimal numerical value of the init_priority attribute.
418 The order of execution in .init_array is forward and
419 .fini_array is backward.
420 2: .ctors.NNNN/.dtors.NNNN: Where NNNN is 65535 minus the
421 decimal numerical value of the init_priority attribute.
422 The order of execution in .ctors is backward and .dtors
425 if (strncmp (name
, ".init_array.", 12) == 0
426 || strncmp (name
, ".fini_array.", 12) == 0)
428 init_priority
= strtoul (name
+ 12, &end
, 10);
429 return *end
? 0 : init_priority
;
431 else if (strncmp (name
, ".ctors.", 7) == 0
432 || strncmp (name
, ".dtors.", 7) == 0)
434 init_priority
= strtoul (name
+ 7, &end
, 10);
435 return *end
? 0 : 65535 - init_priority
;
441 /* Compare sections ASEC and BSEC according to SORT. */
444 compare_section (sort_type sort
, asection
*asec
, asection
*bsec
)
447 unsigned long ainit_priority
, binit_priority
;
454 case by_init_priority
:
456 = get_init_priority (bfd_get_section_name (asec
->owner
, asec
));
458 = get_init_priority (bfd_get_section_name (bsec
->owner
, bsec
));
459 if (ainit_priority
== 0 || binit_priority
== 0)
461 ret
= ainit_priority
- binit_priority
;
467 case by_alignment_name
:
468 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
469 - bfd_section_alignment (asec
->owner
, asec
));
476 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
477 bfd_get_section_name (bsec
->owner
, bsec
));
480 case by_name_alignment
:
481 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
482 bfd_get_section_name (bsec
->owner
, bsec
));
488 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
489 - bfd_section_alignment (asec
->owner
, asec
));
496 /* Build a Binary Search Tree to sort sections, unlike insertion sort
497 used in wild_sort(). BST is considerably faster if the number of
498 of sections are large. */
500 static lang_section_bst_type
**
501 wild_sort_fast (lang_wild_statement_type
*wild
,
502 struct wildcard_list
*sec
,
503 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
506 lang_section_bst_type
**tree
;
509 if (!wild
->filenames_sorted
510 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
512 /* Append at the right end of tree. */
514 tree
= &((*tree
)->right
);
520 /* Find the correct node to append this section. */
521 if (compare_section (sec
->spec
.sorted
, section
, (*tree
)->section
) < 0)
522 tree
= &((*tree
)->left
);
524 tree
= &((*tree
)->right
);
530 /* Use wild_sort_fast to build a BST to sort sections. */
533 output_section_callback_fast (lang_wild_statement_type
*ptr
,
534 struct wildcard_list
*sec
,
536 struct flag_info
*sflag_list ATTRIBUTE_UNUSED
,
537 lang_input_statement_type
*file
,
540 lang_section_bst_type
*node
;
541 lang_section_bst_type
**tree
;
542 lang_output_section_statement_type
*os
;
544 os
= (lang_output_section_statement_type
*) output
;
546 if (unique_section_p (section
, os
))
549 node
= (lang_section_bst_type
*) xmalloc (sizeof (lang_section_bst_type
));
552 node
->section
= section
;
554 tree
= wild_sort_fast (ptr
, sec
, file
, section
);
559 /* Convert a sorted sections' BST back to list form. */
562 output_section_callback_tree_to_list (lang_wild_statement_type
*ptr
,
563 lang_section_bst_type
*tree
,
567 output_section_callback_tree_to_list (ptr
, tree
->left
, output
);
569 lang_add_section (&ptr
->children
, tree
->section
, NULL
,
570 (lang_output_section_statement_type
*) output
);
573 output_section_callback_tree_to_list (ptr
, tree
->right
, output
);
578 /* Specialized, optimized routines for handling different kinds of
582 walk_wild_section_specs1_wild0 (lang_wild_statement_type
*ptr
,
583 lang_input_statement_type
*file
,
587 /* We can just do a hash lookup for the section with the right name.
588 But if that lookup discovers more than one section with the name
589 (should be rare), we fall back to the general algorithm because
590 we would otherwise have to sort the sections to make sure they
591 get processed in the bfd's order. */
592 bfd_boolean multiple_sections_found
;
593 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
594 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
596 if (multiple_sections_found
)
597 walk_wild_section_general (ptr
, file
, callback
, data
);
599 walk_wild_consider_section (ptr
, file
, s0
, sec0
, callback
, data
);
603 walk_wild_section_specs1_wild1 (lang_wild_statement_type
*ptr
,
604 lang_input_statement_type
*file
,
609 struct wildcard_list
*wildsec0
= ptr
->handler_data
[0];
611 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
613 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
614 bfd_boolean skip
= !match_simple_wild (wildsec0
->spec
.name
, sname
);
617 walk_wild_consider_section (ptr
, file
, s
, wildsec0
, callback
, data
);
622 walk_wild_section_specs2_wild1 (lang_wild_statement_type
*ptr
,
623 lang_input_statement_type
*file
,
628 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
629 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
630 bfd_boolean multiple_sections_found
;
631 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
633 if (multiple_sections_found
)
635 walk_wild_section_general (ptr
, file
, callback
, data
);
639 /* Note that if the section was not found, s0 is NULL and
640 we'll simply never succeed the s == s0 test below. */
641 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
643 /* Recall that in this code path, a section cannot satisfy more
644 than one spec, so if s == s0 then it cannot match
647 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
650 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
651 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
654 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
,
661 walk_wild_section_specs3_wild2 (lang_wild_statement_type
*ptr
,
662 lang_input_statement_type
*file
,
667 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
668 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
669 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
670 bfd_boolean multiple_sections_found
;
671 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
673 if (multiple_sections_found
)
675 walk_wild_section_general (ptr
, file
, callback
, data
);
679 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
682 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
685 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
686 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
689 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
, data
);
692 skip
= !match_simple_wild (wildsec2
->spec
.name
, sname
);
694 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
702 walk_wild_section_specs4_wild2 (lang_wild_statement_type
*ptr
,
703 lang_input_statement_type
*file
,
708 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
709 struct wildcard_list
*sec1
= ptr
->handler_data
[1];
710 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
711 struct wildcard_list
*wildsec3
= ptr
->handler_data
[3];
712 bfd_boolean multiple_sections_found
;
713 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
), *s1
;
715 if (multiple_sections_found
)
717 walk_wild_section_general (ptr
, file
, callback
, data
);
721 s1
= find_section (file
, sec1
, &multiple_sections_found
);
722 if (multiple_sections_found
)
724 walk_wild_section_general (ptr
, file
, callback
, data
);
728 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
731 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
734 walk_wild_consider_section (ptr
, file
, s
, sec1
, callback
, data
);
737 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
738 bfd_boolean skip
= !match_simple_wild (wildsec2
->spec
.name
,
742 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
746 skip
= !match_simple_wild (wildsec3
->spec
.name
, sname
);
748 walk_wild_consider_section (ptr
, file
, s
, wildsec3
,
756 walk_wild_section (lang_wild_statement_type
*ptr
,
757 lang_input_statement_type
*file
,
761 if (file
->flags
.just_syms
)
764 (*ptr
->walk_wild_section_handler
) (ptr
, file
, callback
, data
);
767 /* Returns TRUE when name1 is a wildcard spec that might match
768 something name2 can match. We're conservative: we return FALSE
769 only if the prefixes of name1 and name2 are different up to the
770 first wildcard character. */
773 wild_spec_can_overlap (const char *name1
, const char *name2
)
775 size_t prefix1_len
= strcspn (name1
, "?*[");
776 size_t prefix2_len
= strcspn (name2
, "?*[");
777 size_t min_prefix_len
;
779 /* Note that if there is no wildcard character, then we treat the
780 terminating 0 as part of the prefix. Thus ".text" won't match
781 ".text." or ".text.*", for example. */
782 if (name1
[prefix1_len
] == '\0')
784 if (name2
[prefix2_len
] == '\0')
787 min_prefix_len
= prefix1_len
< prefix2_len
? prefix1_len
: prefix2_len
;
789 return memcmp (name1
, name2
, min_prefix_len
) == 0;
792 /* Select specialized code to handle various kinds of wildcard
796 analyze_walk_wild_section_handler (lang_wild_statement_type
*ptr
)
799 int wild_name_count
= 0;
800 struct wildcard_list
*sec
;
804 ptr
->walk_wild_section_handler
= walk_wild_section_general
;
805 ptr
->handler_data
[0] = NULL
;
806 ptr
->handler_data
[1] = NULL
;
807 ptr
->handler_data
[2] = NULL
;
808 ptr
->handler_data
[3] = NULL
;
811 /* Count how many wildcard_specs there are, and how many of those
812 actually use wildcards in the name. Also, bail out if any of the
813 wildcard names are NULL. (Can this actually happen?
814 walk_wild_section used to test for it.) And bail out if any
815 of the wildcards are more complex than a simple string
816 ending in a single '*'. */
817 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
820 if (sec
->spec
.name
== NULL
)
822 if (wildcardp (sec
->spec
.name
))
825 if (!is_simple_wild (sec
->spec
.name
))
830 /* The zero-spec case would be easy to optimize but it doesn't
831 happen in practice. Likewise, more than 4 specs doesn't
832 happen in practice. */
833 if (sec_count
== 0 || sec_count
> 4)
836 /* Check that no two specs can match the same section. */
837 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
839 struct wildcard_list
*sec2
;
840 for (sec2
= sec
->next
; sec2
!= NULL
; sec2
= sec2
->next
)
842 if (wild_spec_can_overlap (sec
->spec
.name
, sec2
->spec
.name
))
847 signature
= (sec_count
<< 8) + wild_name_count
;
851 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild0
;
854 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild1
;
857 ptr
->walk_wild_section_handler
= walk_wild_section_specs2_wild1
;
860 ptr
->walk_wild_section_handler
= walk_wild_section_specs3_wild2
;
863 ptr
->walk_wild_section_handler
= walk_wild_section_specs4_wild2
;
869 /* Now fill the data array with pointers to the specs, first the
870 specs with non-wildcard names, then the specs with wildcard
871 names. It's OK to process the specs in different order from the
872 given order, because we've already determined that no section
873 will match more than one spec. */
875 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
876 if (!wildcardp (sec
->spec
.name
))
877 ptr
->handler_data
[data_counter
++] = sec
;
878 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
879 if (wildcardp (sec
->spec
.name
))
880 ptr
->handler_data
[data_counter
++] = sec
;
883 /* Handle a wild statement for a single file F. */
886 walk_wild_file (lang_wild_statement_type
*s
,
887 lang_input_statement_type
*f
,
891 if (walk_wild_file_in_exclude_list (s
->exclude_name_list
, f
))
894 if (f
->the_bfd
== NULL
895 || !bfd_check_format (f
->the_bfd
, bfd_archive
))
896 walk_wild_section (s
, f
, callback
, data
);
901 /* This is an archive file. We must map each member of the
902 archive separately. */
903 member
= bfd_openr_next_archived_file (f
->the_bfd
, NULL
);
904 while (member
!= NULL
)
906 /* When lookup_name is called, it will call the add_symbols
907 entry point for the archive. For each element of the
908 archive which is included, BFD will call ldlang_add_file,
909 which will set the usrdata field of the member to the
910 lang_input_statement. */
911 if (member
->usrdata
!= NULL
)
913 walk_wild_section (s
,
914 (lang_input_statement_type
*) member
->usrdata
,
918 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
924 walk_wild (lang_wild_statement_type
*s
, callback_t callback
, void *data
)
926 const char *file_spec
= s
->filename
;
929 if (file_spec
== NULL
)
931 /* Perform the iteration over all files in the list. */
932 LANG_FOR_EACH_INPUT_STATEMENT (f
)
934 walk_wild_file (s
, f
, callback
, data
);
937 else if ((p
= archive_path (file_spec
)) != NULL
)
939 LANG_FOR_EACH_INPUT_STATEMENT (f
)
941 if (input_statement_is_archive_path (file_spec
, p
, f
))
942 walk_wild_file (s
, f
, callback
, data
);
945 else if (wildcardp (file_spec
))
947 LANG_FOR_EACH_INPUT_STATEMENT (f
)
949 if (fnmatch (file_spec
, f
->filename
, 0) == 0)
950 walk_wild_file (s
, f
, callback
, data
);
955 lang_input_statement_type
*f
;
957 /* Perform the iteration over a single file. */
958 f
= lookup_name (file_spec
);
960 walk_wild_file (s
, f
, callback
, data
);
964 /* lang_for_each_statement walks the parse tree and calls the provided
965 function for each node, except those inside output section statements
966 with constraint set to -1. */
969 lang_for_each_statement_worker (void (*func
) (lang_statement_union_type
*),
970 lang_statement_union_type
*s
)
972 for (; s
!= NULL
; s
= s
->header
.next
)
976 switch (s
->header
.type
)
978 case lang_constructors_statement_enum
:
979 lang_for_each_statement_worker (func
, constructor_list
.head
);
981 case lang_output_section_statement_enum
:
982 if (s
->output_section_statement
.constraint
!= -1)
983 lang_for_each_statement_worker
984 (func
, s
->output_section_statement
.children
.head
);
986 case lang_wild_statement_enum
:
987 lang_for_each_statement_worker (func
,
988 s
->wild_statement
.children
.head
);
990 case lang_group_statement_enum
:
991 lang_for_each_statement_worker (func
,
992 s
->group_statement
.children
.head
);
994 case lang_data_statement_enum
:
995 case lang_reloc_statement_enum
:
996 case lang_object_symbols_statement_enum
:
997 case lang_output_statement_enum
:
998 case lang_target_statement_enum
:
999 case lang_input_section_enum
:
1000 case lang_input_statement_enum
:
1001 case lang_assignment_statement_enum
:
1002 case lang_padding_statement_enum
:
1003 case lang_address_statement_enum
:
1004 case lang_fill_statement_enum
:
1005 case lang_insert_statement_enum
:
1015 lang_for_each_statement (void (*func
) (lang_statement_union_type
*))
1017 lang_for_each_statement_worker (func
, statement_list
.head
);
1020 /*----------------------------------------------------------------------*/
1023 lang_list_init (lang_statement_list_type
*list
)
1026 list
->tail
= &list
->head
;
1030 push_stat_ptr (lang_statement_list_type
*new_ptr
)
1032 if (stat_save_ptr
>= stat_save
+ sizeof (stat_save
) / sizeof (stat_save
[0]))
1034 *stat_save_ptr
++ = stat_ptr
;
1041 if (stat_save_ptr
<= stat_save
)
1043 stat_ptr
= *--stat_save_ptr
;
1046 /* Build a new statement node for the parse tree. */
1048 static lang_statement_union_type
*
1049 new_statement (enum statement_enum type
,
1051 lang_statement_list_type
*list
)
1053 lang_statement_union_type
*new_stmt
;
1055 new_stmt
= (lang_statement_union_type
*) stat_alloc (size
);
1056 new_stmt
->header
.type
= type
;
1057 new_stmt
->header
.next
= NULL
;
1058 lang_statement_append (list
, new_stmt
, &new_stmt
->header
.next
);
1062 /* Build a new input file node for the language. There are several
1063 ways in which we treat an input file, eg, we only look at symbols,
1064 or prefix it with a -l etc.
1066 We can be supplied with requests for input files more than once;
1067 they may, for example be split over several lines like foo.o(.text)
1068 foo.o(.data) etc, so when asked for a file we check that we haven't
1069 got it already so we don't duplicate the bfd. */
1071 static lang_input_statement_type
*
1072 new_afile (const char *name
,
1073 lang_input_file_enum_type file_type
,
1075 bfd_boolean add_to_list
)
1077 lang_input_statement_type
*p
;
1079 lang_has_input_file
= TRUE
;
1082 p
= (lang_input_statement_type
*) new_stat (lang_input_statement
, stat_ptr
);
1085 p
= (lang_input_statement_type
*)
1086 stat_alloc (sizeof (lang_input_statement_type
));
1087 p
->header
.type
= lang_input_statement_enum
;
1088 p
->header
.next
= NULL
;
1091 memset (&p
->the_bfd
, 0,
1092 sizeof (*p
) - offsetof (lang_input_statement_type
, the_bfd
));
1094 p
->flags
.dynamic
= input_flags
.dynamic
;
1095 p
->flags
.add_DT_NEEDED_for_dynamic
= input_flags
.add_DT_NEEDED_for_dynamic
;
1096 p
->flags
.add_DT_NEEDED_for_regular
= input_flags
.add_DT_NEEDED_for_regular
;
1097 p
->flags
.whole_archive
= input_flags
.whole_archive
;
1098 p
->flags
.sysrooted
= input_flags
.sysrooted
;
1102 case lang_input_file_is_symbols_only_enum
:
1104 p
->local_sym_name
= name
;
1105 p
->flags
.real
= TRUE
;
1106 p
->flags
.just_syms
= TRUE
;
1108 case lang_input_file_is_fake_enum
:
1110 p
->local_sym_name
= name
;
1112 case lang_input_file_is_l_enum
:
1113 if (name
[0] == ':' && name
[1] != '\0')
1115 p
->filename
= name
+ 1;
1116 p
->flags
.full_name_provided
= TRUE
;
1120 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
1121 p
->flags
.maybe_archive
= TRUE
;
1122 p
->flags
.real
= TRUE
;
1123 p
->flags
.search_dirs
= TRUE
;
1125 case lang_input_file_is_marker_enum
:
1127 p
->local_sym_name
= name
;
1128 p
->flags
.search_dirs
= TRUE
;
1130 case lang_input_file_is_search_file_enum
:
1132 p
->local_sym_name
= name
;
1133 p
->flags
.real
= TRUE
;
1134 p
->flags
.search_dirs
= TRUE
;
1136 case lang_input_file_is_file_enum
:
1138 p
->local_sym_name
= name
;
1139 p
->flags
.real
= TRUE
;
1145 lang_statement_append (&input_file_chain
,
1146 (lang_statement_union_type
*) p
,
1147 &p
->next_real_file
);
1151 lang_input_statement_type
*
1152 lang_add_input_file (const char *name
,
1153 lang_input_file_enum_type file_type
,
1157 && (*name
== '=' || CONST_STRNEQ (name
, "$SYSROOT")))
1159 lang_input_statement_type
*ret
;
1160 char *sysrooted_name
1161 = concat (ld_sysroot
,
1162 name
+ (*name
== '=' ? 1 : strlen ("$SYSROOT")),
1163 (const char *) NULL
);
1165 /* We've now forcibly prepended the sysroot, making the input
1166 file independent of the context. Therefore, temporarily
1167 force a non-sysrooted context for this statement, so it won't
1168 get the sysroot prepended again when opened. (N.B. if it's a
1169 script, any child nodes with input files starting with "/"
1170 will be handled as "sysrooted" as they'll be found to be
1171 within the sysroot subdirectory.) */
1172 unsigned int outer_sysrooted
= input_flags
.sysrooted
;
1173 input_flags
.sysrooted
= 0;
1174 ret
= new_afile (sysrooted_name
, file_type
, target
, TRUE
);
1175 input_flags
.sysrooted
= outer_sysrooted
;
1179 return new_afile (name
, file_type
, target
, TRUE
);
1182 struct out_section_hash_entry
1184 struct bfd_hash_entry root
;
1185 lang_statement_union_type s
;
1188 /* The hash table. */
1190 static struct bfd_hash_table output_section_statement_table
;
1192 /* Support routines for the hash table used by lang_output_section_find,
1193 initialize the table, fill in an entry and remove the table. */
1195 static struct bfd_hash_entry
*
1196 output_section_statement_newfunc (struct bfd_hash_entry
*entry
,
1197 struct bfd_hash_table
*table
,
1200 lang_output_section_statement_type
**nextp
;
1201 struct out_section_hash_entry
*ret
;
1205 entry
= (struct bfd_hash_entry
*) bfd_hash_allocate (table
,
1211 entry
= bfd_hash_newfunc (entry
, table
, string
);
1215 ret
= (struct out_section_hash_entry
*) entry
;
1216 memset (&ret
->s
, 0, sizeof (ret
->s
));
1217 ret
->s
.header
.type
= lang_output_section_statement_enum
;
1218 ret
->s
.output_section_statement
.subsection_alignment
= NULL
;
1219 ret
->s
.output_section_statement
.section_alignment
= NULL
;
1220 ret
->s
.output_section_statement
.block_value
= 1;
1221 lang_list_init (&ret
->s
.output_section_statement
.children
);
1222 lang_statement_append (stat_ptr
, &ret
->s
, &ret
->s
.header
.next
);
1224 /* For every output section statement added to the list, except the
1225 first one, lang_output_section_statement.tail points to the "next"
1226 field of the last element of the list. */
1227 if (lang_output_section_statement
.head
!= NULL
)
1228 ret
->s
.output_section_statement
.prev
1229 = ((lang_output_section_statement_type
*)
1230 ((char *) lang_output_section_statement
.tail
1231 - offsetof (lang_output_section_statement_type
, next
)));
1233 /* GCC's strict aliasing rules prevent us from just casting the
1234 address, so we store the pointer in a variable and cast that
1236 nextp
= &ret
->s
.output_section_statement
.next
;
1237 lang_statement_append (&lang_output_section_statement
,
1239 (lang_statement_union_type
**) nextp
);
1244 output_section_statement_table_init (void)
1246 if (!bfd_hash_table_init_n (&output_section_statement_table
,
1247 output_section_statement_newfunc
,
1248 sizeof (struct out_section_hash_entry
),
1250 einfo (_("%F%P: can not create hash table: %E\n"));
1254 output_section_statement_table_free (void)
1256 bfd_hash_table_free (&output_section_statement_table
);
1259 /* Build enough state so that the parser can build its tree. */
1264 obstack_begin (&stat_obstack
, 1000);
1266 stat_ptr
= &statement_list
;
1268 output_section_statement_table_init ();
1270 lang_list_init (stat_ptr
);
1272 lang_list_init (&input_file_chain
);
1273 lang_list_init (&lang_output_section_statement
);
1274 lang_list_init (&file_chain
);
1275 first_file
= lang_add_input_file (NULL
, lang_input_file_is_marker_enum
,
1277 abs_output_section
=
1278 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
, 0, TRUE
);
1280 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
1282 asneeded_list_head
= NULL
;
1283 asneeded_list_tail
= &asneeded_list_head
;
1289 output_section_statement_table_free ();
1292 /*----------------------------------------------------------------------
1293 A region is an area of memory declared with the
1294 MEMORY { name:org=exp, len=exp ... }
1297 We maintain a list of all the regions here.
1299 If no regions are specified in the script, then the default is used
1300 which is created when looked up to be the entire data space.
1302 If create is true we are creating a region inside a MEMORY block.
1303 In this case it is probably an error to create a region that has
1304 already been created. If we are not inside a MEMORY block it is
1305 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1306 and so we issue a warning.
1308 Each region has at least one name. The first name is either
1309 DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add
1310 alias names to an existing region within a script with
1311 REGION_ALIAS (alias, region_name). Each name corresponds to at most one
1314 static lang_memory_region_type
*lang_memory_region_list
;
1315 static lang_memory_region_type
**lang_memory_region_list_tail
1316 = &lang_memory_region_list
;
1318 lang_memory_region_type
*
1319 lang_memory_region_lookup (const char *const name
, bfd_boolean create
)
1321 lang_memory_region_name
*n
;
1322 lang_memory_region_type
*r
;
1323 lang_memory_region_type
*new_region
;
1325 /* NAME is NULL for LMA memspecs if no region was specified. */
1329 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1330 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1331 if (strcmp (n
->name
, name
) == 0)
1334 einfo (_("%P:%pS: warning: redeclaration of memory region `%s'\n"),
1339 if (!create
&& strcmp (name
, DEFAULT_MEMORY_REGION
))
1340 einfo (_("%P:%pS: warning: memory region `%s' not declared\n"),
1343 new_region
= (lang_memory_region_type
*)
1344 stat_alloc (sizeof (lang_memory_region_type
));
1346 new_region
->name_list
.name
= xstrdup (name
);
1347 new_region
->name_list
.next
= NULL
;
1348 new_region
->next
= NULL
;
1349 new_region
->origin_exp
= NULL
;
1350 new_region
->origin
= 0;
1351 new_region
->length_exp
= NULL
;
1352 new_region
->length
= ~(bfd_size_type
) 0;
1353 new_region
->current
= 0;
1354 new_region
->last_os
= NULL
;
1355 new_region
->flags
= 0;
1356 new_region
->not_flags
= 0;
1357 new_region
->had_full_message
= FALSE
;
1359 *lang_memory_region_list_tail
= new_region
;
1360 lang_memory_region_list_tail
= &new_region
->next
;
1366 lang_memory_region_alias (const char *alias
, const char *region_name
)
1368 lang_memory_region_name
*n
;
1369 lang_memory_region_type
*r
;
1370 lang_memory_region_type
*region
;
1372 /* The default region must be unique. This ensures that it is not necessary
1373 to iterate through the name list if someone wants the check if a region is
1374 the default memory region. */
1375 if (strcmp (region_name
, DEFAULT_MEMORY_REGION
) == 0
1376 || strcmp (alias
, DEFAULT_MEMORY_REGION
) == 0)
1377 einfo (_("%F%P:%pS: error: alias for default memory region\n"), NULL
);
1379 /* Look for the target region and check if the alias is not already
1382 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1383 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1385 if (region
== NULL
&& strcmp (n
->name
, region_name
) == 0)
1387 if (strcmp (n
->name
, alias
) == 0)
1388 einfo (_("%F%P:%pS: error: redefinition of memory region "
1393 /* Check if the target region exists. */
1395 einfo (_("%F%P:%pS: error: memory region `%s' "
1396 "for alias `%s' does not exist\n"),
1397 NULL
, region_name
, alias
);
1399 /* Add alias to region name list. */
1400 n
= (lang_memory_region_name
*) stat_alloc (sizeof (lang_memory_region_name
));
1401 n
->name
= xstrdup (alias
);
1402 n
->next
= region
->name_list
.next
;
1403 region
->name_list
.next
= n
;
1406 static lang_memory_region_type
*
1407 lang_memory_default (asection
*section
)
1409 lang_memory_region_type
*p
;
1411 flagword sec_flags
= section
->flags
;
1413 /* Override SEC_DATA to mean a writable section. */
1414 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
1415 sec_flags
|= SEC_DATA
;
1417 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
1419 if ((p
->flags
& sec_flags
) != 0
1420 && (p
->not_flags
& sec_flags
) == 0)
1425 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
1428 /* Get the output section statement directly from the userdata. */
1430 lang_output_section_statement_type
*
1431 lang_output_section_get (const asection
*output_section
)
1433 return get_userdata (output_section
);
1436 /* Find or create an output_section_statement with the given NAME.
1437 If CONSTRAINT is non-zero match one with that constraint, otherwise
1438 match any non-negative constraint. If CREATE, always make a
1439 new output_section_statement for SPECIAL CONSTRAINT. */
1441 lang_output_section_statement_type
*
1442 lang_output_section_statement_lookup (const char *name
,
1446 struct out_section_hash_entry
*entry
;
1448 entry
= ((struct out_section_hash_entry
*)
1449 bfd_hash_lookup (&output_section_statement_table
, name
,
1454 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1458 if (entry
->s
.output_section_statement
.name
!= NULL
)
1460 /* We have a section of this name, but it might not have the correct
1462 struct out_section_hash_entry
*last_ent
;
1464 name
= entry
->s
.output_section_statement
.name
;
1465 if (create
&& constraint
== SPECIAL
)
1466 /* Not traversing to the end reverses the order of the second
1467 and subsequent SPECIAL sections in the hash table chain,
1468 but that shouldn't matter. */
1473 if (constraint
== entry
->s
.output_section_statement
.constraint
1475 && entry
->s
.output_section_statement
.constraint
>= 0))
1476 return &entry
->s
.output_section_statement
;
1478 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1480 while (entry
!= NULL
1481 && name
== entry
->s
.output_section_statement
.name
);
1487 = ((struct out_section_hash_entry
*)
1488 output_section_statement_newfunc (NULL
,
1489 &output_section_statement_table
,
1493 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1496 entry
->root
= last_ent
->root
;
1497 last_ent
->root
.next
= &entry
->root
;
1500 entry
->s
.output_section_statement
.name
= name
;
1501 entry
->s
.output_section_statement
.constraint
= constraint
;
1502 return &entry
->s
.output_section_statement
;
1505 /* Find the next output_section_statement with the same name as OS.
1506 If CONSTRAINT is non-zero, find one with that constraint otherwise
1507 match any non-negative constraint. */
1509 lang_output_section_statement_type
*
1510 next_matching_output_section_statement (lang_output_section_statement_type
*os
,
1513 /* All output_section_statements are actually part of a
1514 struct out_section_hash_entry. */
1515 struct out_section_hash_entry
*entry
= (struct out_section_hash_entry
*)
1517 - offsetof (struct out_section_hash_entry
, s
.output_section_statement
));
1518 const char *name
= os
->name
;
1520 ASSERT (name
== entry
->root
.string
);
1523 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1525 || name
!= entry
->s
.output_section_statement
.name
)
1528 while (constraint
!= entry
->s
.output_section_statement
.constraint
1530 || entry
->s
.output_section_statement
.constraint
< 0));
1532 return &entry
->s
.output_section_statement
;
1535 /* A variant of lang_output_section_find used by place_orphan.
1536 Returns the output statement that should precede a new output
1537 statement for SEC. If an exact match is found on certain flags,
1540 lang_output_section_statement_type
*
1541 lang_output_section_find_by_flags (const asection
*sec
,
1543 lang_output_section_statement_type
**exact
,
1544 lang_match_sec_type_func match_type
)
1546 lang_output_section_statement_type
*first
, *look
, *found
;
1547 flagword look_flags
, differ
;
1549 /* We know the first statement on this list is *ABS*. May as well
1551 first
= &lang_output_section_statement
.head
->output_section_statement
;
1552 first
= first
->next
;
1554 /* First try for an exact match. */
1556 for (look
= first
; look
; look
= look
->next
)
1558 look_flags
= look
->flags
;
1559 if (look
->bfd_section
!= NULL
)
1561 look_flags
= look
->bfd_section
->flags
;
1562 if (match_type
&& !match_type (link_info
.output_bfd
,
1567 differ
= look_flags
^ sec_flags
;
1568 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1569 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1579 if ((sec_flags
& SEC_CODE
) != 0
1580 && (sec_flags
& SEC_ALLOC
) != 0)
1582 /* Try for a rw code section. */
1583 for (look
= first
; look
; look
= look
->next
)
1585 look_flags
= look
->flags
;
1586 if (look
->bfd_section
!= NULL
)
1588 look_flags
= look
->bfd_section
->flags
;
1589 if (match_type
&& !match_type (link_info
.output_bfd
,
1594 differ
= look_flags
^ sec_flags
;
1595 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1596 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1600 else if ((sec_flags
& SEC_READONLY
) != 0
1601 && (sec_flags
& SEC_ALLOC
) != 0)
1603 /* .rodata can go after .text, .sdata2 after .rodata. */
1604 for (look
= first
; look
; look
= look
->next
)
1606 look_flags
= look
->flags
;
1607 if (look
->bfd_section
!= NULL
)
1609 look_flags
= look
->bfd_section
->flags
;
1610 if (match_type
&& !match_type (link_info
.output_bfd
,
1615 differ
= look_flags
^ sec_flags
;
1616 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1617 | SEC_READONLY
| SEC_SMALL_DATA
))
1618 || (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1620 && !(look_flags
& SEC_SMALL_DATA
)))
1624 else if ((sec_flags
& SEC_THREAD_LOCAL
) != 0
1625 && (sec_flags
& SEC_ALLOC
) != 0)
1627 /* .tdata can go after .data, .tbss after .tdata. Treat .tbss
1628 as if it were a loaded section, and don't use match_type. */
1629 bfd_boolean seen_thread_local
= FALSE
;
1632 for (look
= first
; look
; look
= look
->next
)
1634 look_flags
= look
->flags
;
1635 if (look
->bfd_section
!= NULL
)
1636 look_flags
= look
->bfd_section
->flags
;
1638 differ
= look_flags
^ (sec_flags
| SEC_LOAD
| SEC_HAS_CONTENTS
);
1639 if (!(differ
& (SEC_THREAD_LOCAL
| SEC_ALLOC
)))
1641 /* .tdata and .tbss must be adjacent and in that order. */
1642 if (!(look_flags
& SEC_LOAD
)
1643 && (sec_flags
& SEC_LOAD
))
1644 /* ..so if we're at a .tbss section and we're placing
1645 a .tdata section stop looking and return the
1646 previous section. */
1649 seen_thread_local
= TRUE
;
1651 else if (seen_thread_local
)
1653 else if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
)))
1657 else if ((sec_flags
& SEC_SMALL_DATA
) != 0
1658 && (sec_flags
& SEC_ALLOC
) != 0)
1660 /* .sdata goes after .data, .sbss after .sdata. */
1661 for (look
= first
; look
; look
= look
->next
)
1663 look_flags
= look
->flags
;
1664 if (look
->bfd_section
!= NULL
)
1666 look_flags
= look
->bfd_section
->flags
;
1667 if (match_type
&& !match_type (link_info
.output_bfd
,
1672 differ
= look_flags
^ sec_flags
;
1673 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1674 | SEC_THREAD_LOCAL
))
1675 || ((look_flags
& SEC_SMALL_DATA
)
1676 && !(sec_flags
& SEC_HAS_CONTENTS
)))
1680 else if ((sec_flags
& SEC_HAS_CONTENTS
) != 0
1681 && (sec_flags
& SEC_ALLOC
) != 0)
1683 /* .data goes after .rodata. */
1684 for (look
= first
; look
; look
= look
->next
)
1686 look_flags
= look
->flags
;
1687 if (look
->bfd_section
!= NULL
)
1689 look_flags
= look
->bfd_section
->flags
;
1690 if (match_type
&& !match_type (link_info
.output_bfd
,
1695 differ
= look_flags
^ sec_flags
;
1696 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1697 | SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1701 else if ((sec_flags
& SEC_ALLOC
) != 0)
1703 /* .bss goes after any other alloc section. */
1704 for (look
= first
; look
; look
= look
->next
)
1706 look_flags
= look
->flags
;
1707 if (look
->bfd_section
!= NULL
)
1709 look_flags
= look
->bfd_section
->flags
;
1710 if (match_type
&& !match_type (link_info
.output_bfd
,
1715 differ
= look_flags
^ sec_flags
;
1716 if (!(differ
& SEC_ALLOC
))
1722 /* non-alloc go last. */
1723 for (look
= first
; look
; look
= look
->next
)
1725 look_flags
= look
->flags
;
1726 if (look
->bfd_section
!= NULL
)
1727 look_flags
= look
->bfd_section
->flags
;
1728 differ
= look_flags
^ sec_flags
;
1729 if (!(differ
& SEC_DEBUGGING
))
1735 if (found
|| !match_type
)
1738 return lang_output_section_find_by_flags (sec
, sec_flags
, NULL
, NULL
);
1741 /* Find the last output section before given output statement.
1742 Used by place_orphan. */
1745 output_prev_sec_find (lang_output_section_statement_type
*os
)
1747 lang_output_section_statement_type
*lookup
;
1749 for (lookup
= os
->prev
; lookup
!= NULL
; lookup
= lookup
->prev
)
1751 if (lookup
->constraint
< 0)
1754 if (lookup
->bfd_section
!= NULL
&& lookup
->bfd_section
->owner
!= NULL
)
1755 return lookup
->bfd_section
;
1761 /* Look for a suitable place for a new output section statement. The
1762 idea is to skip over anything that might be inside a SECTIONS {}
1763 statement in a script, before we find another output section
1764 statement. Assignments to "dot" before an output section statement
1765 are assumed to belong to it, except in two cases; The first
1766 assignment to dot, and assignments before non-alloc sections.
1767 Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
1768 similar assignments that set the initial address, or we might
1769 insert non-alloc note sections among assignments setting end of
1772 static lang_statement_union_type
**
1773 insert_os_after (lang_output_section_statement_type
*after
)
1775 lang_statement_union_type
**where
;
1776 lang_statement_union_type
**assign
= NULL
;
1777 bfd_boolean ignore_first
;
1780 = after
== &lang_output_section_statement
.head
->output_section_statement
;
1782 for (where
= &after
->header
.next
;
1784 where
= &(*where
)->header
.next
)
1786 switch ((*where
)->header
.type
)
1788 case lang_assignment_statement_enum
:
1791 lang_assignment_statement_type
*ass
;
1793 ass
= &(*where
)->assignment_statement
;
1794 if (ass
->exp
->type
.node_class
!= etree_assert
1795 && ass
->exp
->assign
.dst
[0] == '.'
1796 && ass
->exp
->assign
.dst
[1] == 0)
1800 ignore_first
= FALSE
;
1804 case lang_wild_statement_enum
:
1805 case lang_input_section_enum
:
1806 case lang_object_symbols_statement_enum
:
1807 case lang_fill_statement_enum
:
1808 case lang_data_statement_enum
:
1809 case lang_reloc_statement_enum
:
1810 case lang_padding_statement_enum
:
1811 case lang_constructors_statement_enum
:
1813 ignore_first
= FALSE
;
1815 case lang_output_section_statement_enum
:
1818 asection
*s
= (*where
)->output_section_statement
.bfd_section
;
1821 || s
->map_head
.s
== NULL
1822 || (s
->flags
& SEC_ALLOC
) != 0)
1826 case lang_input_statement_enum
:
1827 case lang_address_statement_enum
:
1828 case lang_target_statement_enum
:
1829 case lang_output_statement_enum
:
1830 case lang_group_statement_enum
:
1831 case lang_insert_statement_enum
:
1840 lang_output_section_statement_type
*
1841 lang_insert_orphan (asection
*s
,
1842 const char *secname
,
1844 lang_output_section_statement_type
*after
,
1845 struct orphan_save
*place
,
1846 etree_type
*address
,
1847 lang_statement_list_type
*add_child
)
1849 lang_statement_list_type add
;
1850 lang_output_section_statement_type
*os
;
1851 lang_output_section_statement_type
**os_tail
;
1853 /* If we have found an appropriate place for the output section
1854 statements for this orphan, add them to our own private list,
1855 inserting them later into the global statement list. */
1858 lang_list_init (&add
);
1859 push_stat_ptr (&add
);
1862 if (bfd_link_relocatable (&link_info
)
1863 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
1864 address
= exp_intop (0);
1866 os_tail
= ((lang_output_section_statement_type
**)
1867 lang_output_section_statement
.tail
);
1868 os
= lang_enter_output_section_statement (secname
, address
, normal_section
,
1869 NULL
, NULL
, NULL
, constraint
, 0);
1871 if (add_child
== NULL
)
1872 add_child
= &os
->children
;
1873 lang_add_section (add_child
, s
, NULL
, os
);
1875 if (after
&& (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) != 0)
1877 const char *region
= (after
->region
1878 ? after
->region
->name_list
.name
1879 : DEFAULT_MEMORY_REGION
);
1880 const char *lma_region
= (after
->lma_region
1881 ? after
->lma_region
->name_list
.name
1883 lang_leave_output_section_statement (NULL
, region
, after
->phdrs
,
1887 lang_leave_output_section_statement (NULL
, DEFAULT_MEMORY_REGION
, NULL
,
1890 /* Restore the global list pointer. */
1894 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
1896 asection
*snew
, *as
;
1897 bfd_boolean place_after
= place
->stmt
== NULL
;
1898 bfd_boolean insert_after
= TRUE
;
1900 snew
= os
->bfd_section
;
1902 /* Shuffle the bfd section list to make the output file look
1903 neater. This is really only cosmetic. */
1904 if (place
->section
== NULL
1905 && after
!= (&lang_output_section_statement
.head
1906 ->output_section_statement
))
1908 asection
*bfd_section
= after
->bfd_section
;
1910 /* If the output statement hasn't been used to place any input
1911 sections (and thus doesn't have an output bfd_section),
1912 look for the closest prior output statement having an
1914 if (bfd_section
== NULL
)
1915 bfd_section
= output_prev_sec_find (after
);
1917 if (bfd_section
!= NULL
&& bfd_section
!= snew
)
1918 place
->section
= &bfd_section
->next
;
1921 if (place
->section
== NULL
)
1922 place
->section
= &link_info
.output_bfd
->sections
;
1924 as
= *place
->section
;
1928 /* Put the section at the end of the list. */
1930 /* Unlink the section. */
1931 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1933 /* Now tack it back on in the right place. */
1934 bfd_section_list_append (link_info
.output_bfd
, snew
);
1936 else if ((bfd_get_flavour (link_info
.output_bfd
)
1937 == bfd_target_elf_flavour
)
1938 && (bfd_get_flavour (s
->owner
)
1939 == bfd_target_elf_flavour
)
1940 && ((elf_section_type (s
) == SHT_NOTE
1941 && (s
->flags
& SEC_LOAD
) != 0)
1942 || (elf_section_type (as
) == SHT_NOTE
1943 && (as
->flags
& SEC_LOAD
) != 0)))
1945 /* Make sure that output note sections are grouped and sorted
1946 by alignments when inserting a note section or insert a
1947 section after a note section, */
1949 /* A specific section after which the output note section
1950 should be placed. */
1951 asection
*after_sec
;
1952 /* True if we need to insert the orphan section after a
1953 specific section to maintain output note section order. */
1954 bfd_boolean after_sec_note
= FALSE
;
1956 static asection
*first_orphan_note
= NULL
;
1958 /* Group and sort output note section by alignments in
1961 if (elf_section_type (s
) == SHT_NOTE
1962 && (s
->flags
& SEC_LOAD
) != 0)
1964 /* Search from the beginning for the last output note
1965 section with equal or larger alignments. NB: Don't
1966 place orphan note section after non-note sections. */
1968 first_orphan_note
= NULL
;
1969 for (sec
= link_info
.output_bfd
->sections
;
1971 && !bfd_is_abs_section (sec
));
1974 && elf_section_type (sec
) == SHT_NOTE
1975 && (sec
->flags
& SEC_LOAD
) != 0)
1977 if (!first_orphan_note
)
1978 first_orphan_note
= sec
;
1979 if (sec
->alignment_power
>= s
->alignment_power
)
1982 else if (first_orphan_note
)
1984 /* Stop if there is non-note section after the first
1985 orphan note section. */
1989 /* If this will be the first orphan note section, it can
1990 be placed at the default location. */
1991 after_sec_note
= first_orphan_note
!= NULL
;
1992 if (after_sec
== NULL
&& after_sec_note
)
1994 /* If all output note sections have smaller
1995 alignments, place the section before all
1996 output orphan note sections. */
1997 after_sec
= first_orphan_note
;
1998 insert_after
= FALSE
;
2001 else if (first_orphan_note
)
2003 /* Don't place non-note sections in the middle of orphan
2005 after_sec_note
= TRUE
;
2007 for (sec
= as
->next
;
2009 && !bfd_is_abs_section (sec
));
2011 if (elf_section_type (sec
) == SHT_NOTE
2012 && (sec
->flags
& SEC_LOAD
) != 0)
2020 /* Search forward to insert OS after AFTER_SEC output
2022 lang_output_section_statement_type
*stmt
, *next
;
2023 bfd_boolean found
= FALSE
;
2024 for (stmt
= after
; stmt
!= NULL
; stmt
= next
)
2029 if (stmt
->bfd_section
== after_sec
)
2039 /* If INSERT_AFTER is FALSE, place OS before
2040 AFTER_SEC output statement. */
2041 if (next
&& next
->bfd_section
== after_sec
)
2051 /* Search backward to insert OS after AFTER_SEC output
2054 for (stmt
= after
; stmt
!= NULL
; stmt
= stmt
->prev
)
2058 if (stmt
->bfd_section
== after_sec
)
2067 /* If INSERT_AFTER is FALSE, place OS before
2068 AFTER_SEC output statement. */
2069 if (stmt
->next
->bfd_section
== after_sec
)
2079 if (after_sec
== NULL
2080 || (insert_after
&& after_sec
->next
!= snew
)
2081 || (!insert_after
&& after_sec
->prev
!= snew
))
2083 /* Unlink the section. */
2084 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2086 /* Place SNEW after AFTER_SEC. If AFTER_SEC is NULL,
2091 bfd_section_list_insert_after (link_info
.output_bfd
,
2094 bfd_section_list_insert_before (link_info
.output_bfd
,
2098 bfd_section_list_prepend (link_info
.output_bfd
, snew
);
2101 else if (as
!= snew
&& as
->prev
!= snew
)
2103 /* Unlink the section. */
2104 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2106 /* Now tack it back on in the right place. */
2107 bfd_section_list_insert_before (link_info
.output_bfd
,
2111 else if (as
!= snew
&& as
->prev
!= snew
)
2113 /* Unlink the section. */
2114 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2116 /* Now tack it back on in the right place. */
2117 bfd_section_list_insert_before (link_info
.output_bfd
, as
, snew
);
2120 /* Save the end of this list. Further ophans of this type will
2121 follow the one we've just added. */
2122 place
->section
= &snew
->next
;
2124 /* The following is non-cosmetic. We try to put the output
2125 statements in some sort of reasonable order here, because they
2126 determine the final load addresses of the orphan sections.
2127 In addition, placing output statements in the wrong order may
2128 require extra segments. For instance, given a typical
2129 situation of all read-only sections placed in one segment and
2130 following that a segment containing all the read-write
2131 sections, we wouldn't want to place an orphan read/write
2132 section before or amongst the read-only ones. */
2133 if (add
.head
!= NULL
)
2135 lang_output_section_statement_type
*newly_added_os
;
2137 /* Place OS after AFTER if AFTER_NOTE is TRUE. */
2140 lang_statement_union_type
**where
= insert_os_after (after
);
2145 place
->os_tail
= &after
->next
;
2149 /* Put it after the last orphan statement we added. */
2150 *add
.tail
= *place
->stmt
;
2151 *place
->stmt
= add
.head
;
2154 /* Fix the global list pointer if we happened to tack our
2155 new list at the tail. */
2156 if (*stat_ptr
->tail
== add
.head
)
2157 stat_ptr
->tail
= add
.tail
;
2159 /* Save the end of this list. */
2160 place
->stmt
= add
.tail
;
2162 /* Do the same for the list of output section statements. */
2163 newly_added_os
= *os_tail
;
2165 newly_added_os
->prev
= (lang_output_section_statement_type
*)
2166 ((char *) place
->os_tail
2167 - offsetof (lang_output_section_statement_type
, next
));
2168 newly_added_os
->next
= *place
->os_tail
;
2169 if (newly_added_os
->next
!= NULL
)
2170 newly_added_os
->next
->prev
= newly_added_os
;
2171 *place
->os_tail
= newly_added_os
;
2172 place
->os_tail
= &newly_added_os
->next
;
2174 /* Fixing the global list pointer here is a little different.
2175 We added to the list in lang_enter_output_section_statement,
2176 trimmed off the new output_section_statment above when
2177 assigning *os_tail = NULL, but possibly added it back in
2178 the same place when assigning *place->os_tail. */
2179 if (*os_tail
== NULL
)
2180 lang_output_section_statement
.tail
2181 = (lang_statement_union_type
**) os_tail
;
2188 lang_print_asneeded (void)
2190 struct asneeded_minfo
*m
;
2192 if (asneeded_list_head
== NULL
)
2195 minfo (_("\nAs-needed library included to satisfy reference by file (symbol)\n\n"));
2197 for (m
= asneeded_list_head
; m
!= NULL
; m
= m
->next
)
2201 minfo ("%s", m
->soname
);
2202 len
= strlen (m
->soname
);
2216 minfo ("%pB ", m
->ref
);
2217 minfo ("(%pT)\n", m
->name
);
2222 lang_map_flags (flagword flag
)
2224 if (flag
& SEC_ALLOC
)
2227 if (flag
& SEC_CODE
)
2230 if (flag
& SEC_READONLY
)
2233 if (flag
& SEC_DATA
)
2236 if (flag
& SEC_LOAD
)
2243 lang_memory_region_type
*m
;
2244 bfd_boolean dis_header_printed
= FALSE
;
2246 LANG_FOR_EACH_INPUT_STATEMENT (file
)
2250 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
2251 || file
->flags
.just_syms
)
2254 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2255 if ((s
->output_section
== NULL
2256 || s
->output_section
->owner
!= link_info
.output_bfd
)
2257 && (s
->flags
& (SEC_LINKER_CREATED
| SEC_KEEP
)) == 0)
2259 if (!dis_header_printed
)
2261 fprintf (config
.map_file
, _("\nDiscarded input sections\n\n"));
2262 dis_header_printed
= TRUE
;
2265 print_input_section (s
, TRUE
);
2269 minfo (_("\nMemory Configuration\n\n"));
2270 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
2271 _("Name"), _("Origin"), _("Length"), _("Attributes"));
2273 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
2278 fprintf (config
.map_file
, "%-16s ", m
->name_list
.name
);
2280 sprintf_vma (buf
, m
->origin
);
2281 minfo ("0x%s ", buf
);
2289 minfo ("0x%V", m
->length
);
2290 if (m
->flags
|| m
->not_flags
)
2298 lang_map_flags (m
->flags
);
2304 lang_map_flags (m
->not_flags
);
2311 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
2313 if (!link_info
.reduce_memory_overheads
)
2315 obstack_begin (&map_obstack
, 1000);
2316 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
2318 expld
.phase
= lang_fixed_phase_enum
;
2319 lang_statement_iteration
++;
2320 print_statements ();
2322 ldemul_extra_map_file_text (link_info
.output_bfd
, &link_info
,
2327 sort_def_symbol (struct bfd_link_hash_entry
*hash_entry
,
2328 void *info ATTRIBUTE_UNUSED
)
2330 if ((hash_entry
->type
== bfd_link_hash_defined
2331 || hash_entry
->type
== bfd_link_hash_defweak
)
2332 && hash_entry
->u
.def
.section
->owner
!= link_info
.output_bfd
2333 && hash_entry
->u
.def
.section
->owner
!= NULL
)
2335 input_section_userdata_type
*ud
;
2336 struct map_symbol_def
*def
;
2338 ud
= ((input_section_userdata_type
*)
2339 get_userdata (hash_entry
->u
.def
.section
));
2342 ud
= (input_section_userdata_type
*) stat_alloc (sizeof (*ud
));
2343 get_userdata (hash_entry
->u
.def
.section
) = ud
;
2344 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2345 ud
->map_symbol_def_count
= 0;
2347 else if (!ud
->map_symbol_def_tail
)
2348 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2350 def
= (struct map_symbol_def
*) obstack_alloc (&map_obstack
, sizeof *def
);
2351 def
->entry
= hash_entry
;
2352 *(ud
->map_symbol_def_tail
) = def
;
2353 ud
->map_symbol_def_tail
= &def
->next
;
2354 ud
->map_symbol_def_count
++;
2359 /* Initialize an output section. */
2362 init_os (lang_output_section_statement_type
*s
, flagword flags
)
2364 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
2365 einfo (_("%F%P: illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
2367 if (s
->constraint
!= SPECIAL
)
2368 s
->bfd_section
= bfd_get_section_by_name (link_info
.output_bfd
, s
->name
);
2369 if (s
->bfd_section
== NULL
)
2370 s
->bfd_section
= bfd_make_section_anyway_with_flags (link_info
.output_bfd
,
2372 if (s
->bfd_section
== NULL
)
2374 einfo (_("%F%P: output format %s cannot represent section"
2375 " called %s: %E\n"),
2376 link_info
.output_bfd
->xvec
->name
, s
->name
);
2378 s
->bfd_section
->output_section
= s
->bfd_section
;
2379 s
->bfd_section
->output_offset
= 0;
2381 /* Set the userdata of the output section to the output section
2382 statement to avoid lookup. */
2383 get_userdata (s
->bfd_section
) = s
;
2385 /* If there is a base address, make sure that any sections it might
2386 mention are initialized. */
2387 if (s
->addr_tree
!= NULL
)
2388 exp_init_os (s
->addr_tree
);
2390 if (s
->load_base
!= NULL
)
2391 exp_init_os (s
->load_base
);
2393 /* If supplied an alignment, set it. */
2394 if (s
->section_alignment
!= NULL
)
2395 s
->bfd_section
->alignment_power
= exp_get_power (s
->section_alignment
,
2396 "section alignment");
2399 /* Make sure that all output sections mentioned in an expression are
2403 exp_init_os (etree_type
*exp
)
2405 switch (exp
->type
.node_class
)
2409 case etree_provided
:
2410 exp_init_os (exp
->assign
.src
);
2414 exp_init_os (exp
->binary
.lhs
);
2415 exp_init_os (exp
->binary
.rhs
);
2419 exp_init_os (exp
->trinary
.cond
);
2420 exp_init_os (exp
->trinary
.lhs
);
2421 exp_init_os (exp
->trinary
.rhs
);
2425 exp_init_os (exp
->assert_s
.child
);
2429 exp_init_os (exp
->unary
.child
);
2433 switch (exp
->type
.node_code
)
2439 lang_output_section_statement_type
*os
;
2441 os
= lang_output_section_find (exp
->name
.name
);
2442 if (os
!= NULL
&& os
->bfd_section
== NULL
)
2454 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
2456 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
2458 /* If we are only reading symbols from this object, then we want to
2459 discard all sections. */
2460 if (entry
->flags
.just_syms
)
2462 bfd_link_just_syms (abfd
, sec
, &link_info
);
2466 /* Deal with SHF_EXCLUDE ELF sections. */
2467 if (!bfd_link_relocatable (&link_info
)
2468 && (abfd
->flags
& BFD_PLUGIN
) == 0
2469 && (sec
->flags
& (SEC_GROUP
| SEC_KEEP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
2470 sec
->output_section
= bfd_abs_section_ptr
;
2472 if (!(abfd
->flags
& DYNAMIC
))
2473 bfd_section_already_linked (abfd
, sec
, &link_info
);
2477 /* Returns true if SECTION is one we know will be discarded based on its
2478 section flags, otherwise returns false. */
2481 lang_discard_section_p (asection
*section
)
2483 bfd_boolean discard
;
2484 flagword flags
= section
->flags
;
2486 /* Discard sections marked with SEC_EXCLUDE. */
2487 discard
= (flags
& SEC_EXCLUDE
) != 0;
2489 /* Discard the group descriptor sections when we're finally placing the
2490 sections from within the group. */
2491 if ((flags
& SEC_GROUP
) != 0
2492 && link_info
.resolve_section_groups
)
2495 /* Discard debugging sections if we are stripping debugging
2497 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
2498 && (flags
& SEC_DEBUGGING
) != 0)
2504 /* The wild routines.
2506 These expand statements like *(.text) and foo.o to a list of
2507 explicit actions, like foo.o(.text), bar.o(.text) and
2508 foo.o(.text, .data). */
2510 /* Add SECTION to the output section OUTPUT. Do this by creating a
2511 lang_input_section statement which is placed at PTR. */
2514 lang_add_section (lang_statement_list_type
*ptr
,
2516 struct flag_info
*sflag_info
,
2517 lang_output_section_statement_type
*output
)
2519 flagword flags
= section
->flags
;
2521 bfd_boolean discard
;
2522 lang_input_section_type
*new_section
;
2523 bfd
*abfd
= link_info
.output_bfd
;
2525 /* Is this section one we know should be discarded? */
2526 discard
= lang_discard_section_p (section
);
2528 /* Discard input sections which are assigned to a section named
2529 DISCARD_SECTION_NAME. */
2530 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
2535 if (section
->output_section
== NULL
)
2537 /* This prevents future calls from assigning this section. */
2538 section
->output_section
= bfd_abs_section_ptr
;
2547 keep
= bfd_lookup_section_flags (&link_info
, sflag_info
, section
);
2552 if (section
->output_section
!= NULL
)
2555 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2556 to an output section, because we want to be able to include a
2557 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2558 section (I don't know why we want to do this, but we do).
2559 build_link_order in ldwrite.c handles this case by turning
2560 the embedded SEC_NEVER_LOAD section into a fill. */
2561 flags
&= ~ SEC_NEVER_LOAD
;
2563 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2564 already been processed. One reason to do this is that on pe
2565 format targets, .text$foo sections go into .text and it's odd
2566 to see .text with SEC_LINK_ONCE set. */
2567 if ((flags
& (SEC_LINK_ONCE
| SEC_GROUP
)) == (SEC_LINK_ONCE
| SEC_GROUP
))
2569 if (link_info
.resolve_section_groups
)
2570 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2572 flags
&= ~(SEC_LINK_DUPLICATES
| SEC_RELOC
);
2574 else if (!bfd_link_relocatable (&link_info
))
2575 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2577 switch (output
->sectype
)
2579 case normal_section
:
2580 case overlay_section
:
2582 case noalloc_section
:
2583 flags
&= ~SEC_ALLOC
;
2585 case noload_section
:
2587 flags
|= SEC_NEVER_LOAD
;
2588 /* Unfortunately GNU ld has managed to evolve two different
2589 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2590 alloc, no contents section. All others get a noload, noalloc
2592 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
2593 flags
&= ~SEC_HAS_CONTENTS
;
2595 flags
&= ~SEC_ALLOC
;
2599 if (output
->bfd_section
== NULL
)
2600 init_os (output
, flags
);
2602 /* If SEC_READONLY is not set in the input section, then clear
2603 it from the output section. */
2604 output
->bfd_section
->flags
&= flags
| ~SEC_READONLY
;
2606 if (output
->bfd_section
->linker_has_input
)
2608 /* Only set SEC_READONLY flag on the first input section. */
2609 flags
&= ~ SEC_READONLY
;
2611 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2612 if ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2613 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2614 || ((flags
& SEC_MERGE
) != 0
2615 && output
->bfd_section
->entsize
!= section
->entsize
))
2617 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2618 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2621 output
->bfd_section
->flags
|= flags
;
2623 if (!output
->bfd_section
->linker_has_input
)
2625 output
->bfd_section
->linker_has_input
= 1;
2626 /* This must happen after flags have been updated. The output
2627 section may have been created before we saw its first input
2628 section, eg. for a data statement. */
2629 bfd_init_private_section_data (section
->owner
, section
,
2630 link_info
.output_bfd
,
2631 output
->bfd_section
,
2633 if ((flags
& SEC_MERGE
) != 0)
2634 output
->bfd_section
->entsize
= section
->entsize
;
2637 if ((flags
& SEC_TIC54X_BLOCK
) != 0
2638 && bfd_get_arch (section
->owner
) == bfd_arch_tic54x
)
2640 /* FIXME: This value should really be obtained from the bfd... */
2641 output
->block_value
= 128;
2644 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2645 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2647 section
->output_section
= output
->bfd_section
;
2649 if (!map_head_is_link_order
)
2651 asection
*s
= output
->bfd_section
->map_tail
.s
;
2652 output
->bfd_section
->map_tail
.s
= section
;
2653 section
->map_head
.s
= NULL
;
2654 section
->map_tail
.s
= s
;
2656 s
->map_head
.s
= section
;
2658 output
->bfd_section
->map_head
.s
= section
;
2661 /* Add a section reference to the list. */
2662 new_section
= new_stat (lang_input_section
, ptr
);
2663 new_section
->section
= section
;
2666 /* Handle wildcard sorting. This returns the lang_input_section which
2667 should follow the one we are going to create for SECTION and FILE,
2668 based on the sorting requirements of WILD. It returns NULL if the
2669 new section should just go at the end of the current list. */
2671 static lang_statement_union_type
*
2672 wild_sort (lang_wild_statement_type
*wild
,
2673 struct wildcard_list
*sec
,
2674 lang_input_statement_type
*file
,
2677 lang_statement_union_type
*l
;
2679 if (!wild
->filenames_sorted
2680 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
2683 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
2685 lang_input_section_type
*ls
;
2687 if (l
->header
.type
!= lang_input_section_enum
)
2689 ls
= &l
->input_section
;
2691 /* Sorting by filename takes precedence over sorting by section
2694 if (wild
->filenames_sorted
)
2696 const char *fn
, *ln
;
2700 /* The PE support for the .idata section as generated by
2701 dlltool assumes that files will be sorted by the name of
2702 the archive and then the name of the file within the
2705 if (file
->the_bfd
!= NULL
2706 && file
->the_bfd
->my_archive
!= NULL
)
2708 fn
= bfd_get_filename (file
->the_bfd
->my_archive
);
2713 fn
= file
->filename
;
2717 if (ls
->section
->owner
->my_archive
!= NULL
)
2719 ln
= bfd_get_filename (ls
->section
->owner
->my_archive
);
2724 ln
= ls
->section
->owner
->filename
;
2728 i
= filename_cmp (fn
, ln
);
2737 fn
= file
->filename
;
2739 ln
= ls
->section
->owner
->filename
;
2741 i
= filename_cmp (fn
, ln
);
2749 /* Here either the files are not sorted by name, or we are
2750 looking at the sections for this file. */
2753 && sec
->spec
.sorted
!= none
2754 && sec
->spec
.sorted
!= by_none
)
2755 if (compare_section (sec
->spec
.sorted
, section
, ls
->section
) < 0)
2762 /* Expand a wild statement for a particular FILE. SECTION may be
2763 NULL, in which case it is a wild card. */
2766 output_section_callback (lang_wild_statement_type
*ptr
,
2767 struct wildcard_list
*sec
,
2769 struct flag_info
*sflag_info
,
2770 lang_input_statement_type
*file
,
2773 lang_statement_union_type
*before
;
2774 lang_output_section_statement_type
*os
;
2776 os
= (lang_output_section_statement_type
*) output
;
2778 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2779 if (unique_section_p (section
, os
))
2782 before
= wild_sort (ptr
, sec
, file
, section
);
2784 /* Here BEFORE points to the lang_input_section which
2785 should follow the one we are about to add. If BEFORE
2786 is NULL, then the section should just go at the end
2787 of the current list. */
2790 lang_add_section (&ptr
->children
, section
, sflag_info
, os
);
2793 lang_statement_list_type list
;
2794 lang_statement_union_type
**pp
;
2796 lang_list_init (&list
);
2797 lang_add_section (&list
, section
, sflag_info
, os
);
2799 /* If we are discarding the section, LIST.HEAD will
2801 if (list
.head
!= NULL
)
2803 ASSERT (list
.head
->header
.next
== NULL
);
2805 for (pp
= &ptr
->children
.head
;
2807 pp
= &(*pp
)->header
.next
)
2808 ASSERT (*pp
!= NULL
);
2810 list
.head
->header
.next
= *pp
;
2816 /* Check if all sections in a wild statement for a particular FILE
2820 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2821 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2823 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
2824 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2827 lang_output_section_statement_type
*os
;
2829 os
= (lang_output_section_statement_type
*) output
;
2831 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2832 if (unique_section_p (section
, os
))
2835 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2836 os
->all_input_readonly
= FALSE
;
2839 /* This is passed a file name which must have been seen already and
2840 added to the statement tree. We will see if it has been opened
2841 already and had its symbols read. If not then we'll read it. */
2843 static lang_input_statement_type
*
2844 lookup_name (const char *name
)
2846 lang_input_statement_type
*search
;
2848 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
2850 search
= (lang_input_statement_type
*) search
->next_real_file
)
2852 /* Use the local_sym_name as the name of the file that has
2853 already been loaded as filename might have been transformed
2854 via the search directory lookup mechanism. */
2855 const char *filename
= search
->local_sym_name
;
2857 if (filename
!= NULL
2858 && filename_cmp (filename
, name
) == 0)
2863 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2864 default_target
, FALSE
);
2866 /* If we have already added this file, or this file is not real
2867 don't add this file. */
2868 if (search
->flags
.loaded
|| !search
->flags
.real
)
2871 if (!load_symbols (search
, NULL
))
2877 /* Save LIST as a list of libraries whose symbols should not be exported. */
2882 struct excluded_lib
*next
;
2884 static struct excluded_lib
*excluded_libs
;
2887 add_excluded_libs (const char *list
)
2889 const char *p
= list
, *end
;
2893 struct excluded_lib
*entry
;
2894 end
= strpbrk (p
, ",:");
2896 end
= p
+ strlen (p
);
2897 entry
= (struct excluded_lib
*) xmalloc (sizeof (*entry
));
2898 entry
->next
= excluded_libs
;
2899 entry
->name
= (char *) xmalloc (end
- p
+ 1);
2900 memcpy (entry
->name
, p
, end
- p
);
2901 entry
->name
[end
- p
] = '\0';
2902 excluded_libs
= entry
;
2910 check_excluded_libs (bfd
*abfd
)
2912 struct excluded_lib
*lib
= excluded_libs
;
2916 int len
= strlen (lib
->name
);
2917 const char *filename
= lbasename (abfd
->filename
);
2919 if (strcmp (lib
->name
, "ALL") == 0)
2921 abfd
->no_export
= TRUE
;
2925 if (filename_ncmp (lib
->name
, filename
, len
) == 0
2926 && (filename
[len
] == '\0'
2927 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
2928 && filename
[len
+ 2] == '\0')))
2930 abfd
->no_export
= TRUE
;
2938 /* Get the symbols for an input file. */
2941 load_symbols (lang_input_statement_type
*entry
,
2942 lang_statement_list_type
*place
)
2946 if (entry
->flags
.loaded
)
2949 ldfile_open_file (entry
);
2951 /* Do not process further if the file was missing. */
2952 if (entry
->flags
.missing_file
)
2955 if (trace_files
|| verbose
)
2956 info_msg ("%pI\n", entry
);
2958 if (!bfd_check_format (entry
->the_bfd
, bfd_archive
)
2959 && !bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
2962 struct lang_input_statement_flags save_flags
;
2965 err
= bfd_get_error ();
2967 /* See if the emulation has some special knowledge. */
2968 if (ldemul_unrecognized_file (entry
))
2971 if (err
== bfd_error_file_ambiguously_recognized
)
2975 einfo (_("%P: %pB: file not recognized: %E;"
2976 " matching formats:"), entry
->the_bfd
);
2977 for (p
= matching
; *p
!= NULL
; p
++)
2981 else if (err
!= bfd_error_file_not_recognized
2983 einfo (_("%F%P: %pB: file not recognized: %E\n"), entry
->the_bfd
);
2985 bfd_close (entry
->the_bfd
);
2986 entry
->the_bfd
= NULL
;
2988 /* Try to interpret the file as a linker script. */
2989 save_flags
= input_flags
;
2990 ldfile_open_command_file (entry
->filename
);
2992 push_stat_ptr (place
);
2993 input_flags
.add_DT_NEEDED_for_regular
2994 = entry
->flags
.add_DT_NEEDED_for_regular
;
2995 input_flags
.add_DT_NEEDED_for_dynamic
2996 = entry
->flags
.add_DT_NEEDED_for_dynamic
;
2997 input_flags
.whole_archive
= entry
->flags
.whole_archive
;
2998 input_flags
.dynamic
= entry
->flags
.dynamic
;
3000 ldfile_assumed_script
= TRUE
;
3001 parser_input
= input_script
;
3003 ldfile_assumed_script
= FALSE
;
3005 /* missing_file is sticky. sysrooted will already have been
3006 restored when seeing EOF in yyparse, but no harm to restore
3008 save_flags
.missing_file
|= input_flags
.missing_file
;
3009 input_flags
= save_flags
;
3013 entry
->flags
.loaded
= TRUE
;
3018 if (ldemul_recognized_file (entry
))
3021 /* We don't call ldlang_add_file for an archive. Instead, the
3022 add_symbols entry point will call ldlang_add_file, via the
3023 add_archive_element callback, for each element of the archive
3025 switch (bfd_get_format (entry
->the_bfd
))
3031 if (!entry
->flags
.reload
)
3032 ldlang_add_file (entry
);
3036 check_excluded_libs (entry
->the_bfd
);
3038 entry
->the_bfd
->usrdata
= entry
;
3039 if (entry
->flags
.whole_archive
)
3042 bfd_boolean loaded
= TRUE
;
3047 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
3052 if (!bfd_check_format (member
, bfd_object
))
3054 einfo (_("%F%P: %pB: member %pB in archive is not an object\n"),
3055 entry
->the_bfd
, member
);
3060 if (!(*link_info
.callbacks
3061 ->add_archive_element
) (&link_info
, member
,
3062 "--whole-archive", &subsbfd
))
3065 /* Potentially, the add_archive_element hook may have set a
3066 substitute BFD for us. */
3067 if (!bfd_link_add_symbols (subsbfd
, &link_info
))
3069 einfo (_("%F%P: %pB: error adding symbols: %E\n"), member
);
3074 entry
->flags
.loaded
= loaded
;
3080 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
3081 entry
->flags
.loaded
= TRUE
;
3083 einfo (_("%F%P: %pB: error adding symbols: %E\n"), entry
->the_bfd
);
3085 return entry
->flags
.loaded
;
3088 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
3089 may be NULL, indicating that it is a wildcard. Separate
3090 lang_input_section statements are created for each part of the
3091 expansion; they are added after the wild statement S. OUTPUT is
3092 the output section. */
3095 wild (lang_wild_statement_type
*s
,
3096 const char *target ATTRIBUTE_UNUSED
,
3097 lang_output_section_statement_type
*output
)
3099 struct wildcard_list
*sec
;
3101 if (s
->handler_data
[0]
3102 && s
->handler_data
[0]->spec
.sorted
== by_name
3103 && !s
->filenames_sorted
)
3105 lang_section_bst_type
*tree
;
3107 walk_wild (s
, output_section_callback_fast
, output
);
3112 output_section_callback_tree_to_list (s
, tree
, output
);
3117 walk_wild (s
, output_section_callback
, output
);
3119 if (default_common_section
== NULL
)
3120 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
3121 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
3123 /* Remember the section that common is going to in case we
3124 later get something which doesn't know where to put it. */
3125 default_common_section
= output
;
3130 /* Return TRUE iff target is the sought target. */
3133 get_target (const bfd_target
*target
, void *data
)
3135 const char *sought
= (const char *) data
;
3137 return strcmp (target
->name
, sought
) == 0;
3140 /* Like strcpy() but convert to lower case as well. */
3143 stricpy (char *dest
, char *src
)
3147 while ((c
= *src
++) != 0)
3148 *dest
++ = TOLOWER (c
);
3153 /* Remove the first occurrence of needle (if any) in haystack
3157 strcut (char *haystack
, char *needle
)
3159 haystack
= strstr (haystack
, needle
);
3165 for (src
= haystack
+ strlen (needle
); *src
;)
3166 *haystack
++ = *src
++;
3172 /* Compare two target format name strings.
3173 Return a value indicating how "similar" they are. */
3176 name_compare (char *first
, char *second
)
3182 copy1
= (char *) xmalloc (strlen (first
) + 1);
3183 copy2
= (char *) xmalloc (strlen (second
) + 1);
3185 /* Convert the names to lower case. */
3186 stricpy (copy1
, first
);
3187 stricpy (copy2
, second
);
3189 /* Remove size and endian strings from the name. */
3190 strcut (copy1
, "big");
3191 strcut (copy1
, "little");
3192 strcut (copy2
, "big");
3193 strcut (copy2
, "little");
3195 /* Return a value based on how many characters match,
3196 starting from the beginning. If both strings are
3197 the same then return 10 * their length. */
3198 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
3199 if (copy1
[result
] == 0)
3211 /* Set by closest_target_match() below. */
3212 static const bfd_target
*winner
;
3214 /* Scan all the valid bfd targets looking for one that has the endianness
3215 requirement that was specified on the command line, and is the nearest
3216 match to the original output target. */
3219 closest_target_match (const bfd_target
*target
, void *data
)
3221 const bfd_target
*original
= (const bfd_target
*) data
;
3223 if (command_line
.endian
== ENDIAN_BIG
3224 && target
->byteorder
!= BFD_ENDIAN_BIG
)
3227 if (command_line
.endian
== ENDIAN_LITTLE
3228 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
3231 /* Must be the same flavour. */
3232 if (target
->flavour
!= original
->flavour
)
3235 /* Ignore generic big and little endian elf vectors. */
3236 if (strcmp (target
->name
, "elf32-big") == 0
3237 || strcmp (target
->name
, "elf64-big") == 0
3238 || strcmp (target
->name
, "elf32-little") == 0
3239 || strcmp (target
->name
, "elf64-little") == 0)
3242 /* If we have not found a potential winner yet, then record this one. */
3249 /* Oh dear, we now have two potential candidates for a successful match.
3250 Compare their names and choose the better one. */
3251 if (name_compare (target
->name
, original
->name
)
3252 > name_compare (winner
->name
, original
->name
))
3255 /* Keep on searching until wqe have checked them all. */
3259 /* Return the BFD target format of the first input file. */
3262 get_first_input_target (void)
3264 char *target
= NULL
;
3266 LANG_FOR_EACH_INPUT_STATEMENT (s
)
3268 if (s
->header
.type
== lang_input_statement_enum
3271 ldfile_open_file (s
);
3273 if (s
->the_bfd
!= NULL
3274 && bfd_check_format (s
->the_bfd
, bfd_object
))
3276 target
= bfd_get_target (s
->the_bfd
);
3288 lang_get_output_target (void)
3292 /* Has the user told us which output format to use? */
3293 if (output_target
!= NULL
)
3294 return output_target
;
3296 /* No - has the current target been set to something other than
3298 if (current_target
!= default_target
&& current_target
!= NULL
)
3299 return current_target
;
3301 /* No - can we determine the format of the first input file? */
3302 target
= get_first_input_target ();
3306 /* Failed - use the default output target. */
3307 return default_target
;
3310 /* Open the output file. */
3313 open_output (const char *name
)
3315 output_target
= lang_get_output_target ();
3317 /* Has the user requested a particular endianness on the command
3319 if (command_line
.endian
!= ENDIAN_UNSET
)
3321 /* Get the chosen target. */
3322 const bfd_target
*target
3323 = bfd_iterate_over_targets (get_target
, (void *) output_target
);
3325 /* If the target is not supported, we cannot do anything. */
3328 enum bfd_endian desired_endian
;
3330 if (command_line
.endian
== ENDIAN_BIG
)
3331 desired_endian
= BFD_ENDIAN_BIG
;
3333 desired_endian
= BFD_ENDIAN_LITTLE
;
3335 /* See if the target has the wrong endianness. This should
3336 not happen if the linker script has provided big and
3337 little endian alternatives, but some scrips don't do
3339 if (target
->byteorder
!= desired_endian
)
3341 /* If it does, then see if the target provides
3342 an alternative with the correct endianness. */
3343 if (target
->alternative_target
!= NULL
3344 && (target
->alternative_target
->byteorder
== desired_endian
))
3345 output_target
= target
->alternative_target
->name
;
3348 /* Try to find a target as similar as possible to
3349 the default target, but which has the desired
3350 endian characteristic. */
3351 bfd_iterate_over_targets (closest_target_match
,
3354 /* Oh dear - we could not find any targets that
3355 satisfy our requirements. */
3357 einfo (_("%P: warning: could not find any targets"
3358 " that match endianness requirement\n"));
3360 output_target
= winner
->name
;
3366 link_info
.output_bfd
= bfd_openw (name
, output_target
);
3368 if (link_info
.output_bfd
== NULL
)
3370 if (bfd_get_error () == bfd_error_invalid_target
)
3371 einfo (_("%F%P: target %s not found\n"), output_target
);
3373 einfo (_("%F%P: cannot open output file %s: %E\n"), name
);
3376 delete_output_file_on_failure
= TRUE
;
3378 if (!bfd_set_format (link_info
.output_bfd
, bfd_object
))
3379 einfo (_("%F%P: %s: can not make object file: %E\n"), name
);
3380 if (!bfd_set_arch_mach (link_info
.output_bfd
,
3381 ldfile_output_architecture
,
3382 ldfile_output_machine
))
3383 einfo (_("%F%P: %s: can not set architecture: %E\n"), name
);
3385 link_info
.hash
= bfd_link_hash_table_create (link_info
.output_bfd
);
3386 if (link_info
.hash
== NULL
)
3387 einfo (_("%F%P: can not create hash table: %E\n"));
3389 bfd_set_gp_size (link_info
.output_bfd
, g_switch_value
);
3393 ldlang_open_output (lang_statement_union_type
*statement
)
3395 switch (statement
->header
.type
)
3397 case lang_output_statement_enum
:
3398 ASSERT (link_info
.output_bfd
== NULL
);
3399 open_output (statement
->output_statement
.name
);
3400 ldemul_set_output_arch ();
3401 if (config
.magic_demand_paged
3402 && !bfd_link_relocatable (&link_info
))
3403 link_info
.output_bfd
->flags
|= D_PAGED
;
3405 link_info
.output_bfd
->flags
&= ~D_PAGED
;
3406 if (config
.text_read_only
)
3407 link_info
.output_bfd
->flags
|= WP_TEXT
;
3409 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
3410 if (link_info
.traditional_format
)
3411 link_info
.output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
3413 link_info
.output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
3416 case lang_target_statement_enum
:
3417 current_target
= statement
->target_statement
.target
;
3427 unsigned x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3428 ldfile_output_machine
);
3431 while ((x
& 1) == 0)
3439 /* Open all the input files. */
3443 OPEN_BFD_NORMAL
= 0,
3447 #ifdef ENABLE_PLUGINS
3448 static lang_input_statement_type
*plugin_insert
= NULL
;
3452 open_input_bfds (lang_statement_union_type
*s
, enum open_bfd_mode mode
)
3454 for (; s
!= NULL
; s
= s
->header
.next
)
3456 switch (s
->header
.type
)
3458 case lang_constructors_statement_enum
:
3459 open_input_bfds (constructor_list
.head
, mode
);
3461 case lang_output_section_statement_enum
:
3462 open_input_bfds (s
->output_section_statement
.children
.head
, mode
);
3464 case lang_wild_statement_enum
:
3465 /* Maybe we should load the file's symbols. */
3466 if ((mode
& OPEN_BFD_RESCAN
) == 0
3467 && s
->wild_statement
.filename
3468 && !wildcardp (s
->wild_statement
.filename
)
3469 && !archive_path (s
->wild_statement
.filename
))
3470 lookup_name (s
->wild_statement
.filename
);
3471 open_input_bfds (s
->wild_statement
.children
.head
, mode
);
3473 case lang_group_statement_enum
:
3475 struct bfd_link_hash_entry
*undefs
;
3477 /* We must continually search the entries in the group
3478 until no new symbols are added to the list of undefined
3483 undefs
= link_info
.hash
->undefs_tail
;
3484 open_input_bfds (s
->group_statement
.children
.head
,
3485 mode
| OPEN_BFD_FORCE
);
3487 while (undefs
!= link_info
.hash
->undefs_tail
);
3490 case lang_target_statement_enum
:
3491 current_target
= s
->target_statement
.target
;
3493 case lang_input_statement_enum
:
3494 if (s
->input_statement
.flags
.real
)
3496 lang_statement_union_type
**os_tail
;
3497 lang_statement_list_type add
;
3500 s
->input_statement
.target
= current_target
;
3502 /* If we are being called from within a group, and this
3503 is an archive which has already been searched, then
3504 force it to be researched unless the whole archive
3505 has been loaded already. Do the same for a rescan.
3506 Likewise reload --as-needed shared libs. */
3507 if (mode
!= OPEN_BFD_NORMAL
3508 #ifdef ENABLE_PLUGINS
3509 && ((mode
& OPEN_BFD_RESCAN
) == 0
3510 || plugin_insert
== NULL
)
3512 && s
->input_statement
.flags
.loaded
3513 && (abfd
= s
->input_statement
.the_bfd
) != NULL
3514 && ((bfd_get_format (abfd
) == bfd_archive
3515 && !s
->input_statement
.flags
.whole_archive
)
3516 || (bfd_get_format (abfd
) == bfd_object
3517 && ((abfd
->flags
) & DYNAMIC
) != 0
3518 && s
->input_statement
.flags
.add_DT_NEEDED_for_regular
3519 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3520 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)))
3522 s
->input_statement
.flags
.loaded
= FALSE
;
3523 s
->input_statement
.flags
.reload
= TRUE
;
3526 os_tail
= lang_output_section_statement
.tail
;
3527 lang_list_init (&add
);
3529 if (!load_symbols (&s
->input_statement
, &add
))
3530 config
.make_executable
= FALSE
;
3532 if (add
.head
!= NULL
)
3534 /* If this was a script with output sections then
3535 tack any added statements on to the end of the
3536 list. This avoids having to reorder the output
3537 section statement list. Very likely the user
3538 forgot -T, and whatever we do here will not meet
3539 naive user expectations. */
3540 if (os_tail
!= lang_output_section_statement
.tail
)
3542 einfo (_("%P: warning: %s contains output sections;"
3543 " did you forget -T?\n"),
3544 s
->input_statement
.filename
);
3545 *stat_ptr
->tail
= add
.head
;
3546 stat_ptr
->tail
= add
.tail
;
3550 *add
.tail
= s
->header
.next
;
3551 s
->header
.next
= add
.head
;
3555 #ifdef ENABLE_PLUGINS
3556 /* If we have found the point at which a plugin added new
3557 files, clear plugin_insert to enable archive rescan. */
3558 if (&s
->input_statement
== plugin_insert
)
3559 plugin_insert
= NULL
;
3562 case lang_assignment_statement_enum
:
3563 if (s
->assignment_statement
.exp
->type
.node_class
!= etree_assert
)
3564 exp_fold_tree_no_dot (s
->assignment_statement
.exp
);
3571 /* Exit if any of the files were missing. */
3572 if (input_flags
.missing_file
)
3576 /* Add the supplied name to the symbol table as an undefined reference.
3577 This is a two step process as the symbol table doesn't even exist at
3578 the time the ld command line is processed. First we put the name
3579 on a list, then, once the output file has been opened, transfer the
3580 name to the symbol table. */
3582 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3584 #define ldlang_undef_chain_list_head entry_symbol.next
3587 ldlang_add_undef (const char *const name
, bfd_boolean cmdline
)
3589 ldlang_undef_chain_list_type
*new_undef
;
3591 undef_from_cmdline
= undef_from_cmdline
|| cmdline
;
3592 new_undef
= (ldlang_undef_chain_list_type
*) stat_alloc (sizeof (*new_undef
));
3593 new_undef
->next
= ldlang_undef_chain_list_head
;
3594 ldlang_undef_chain_list_head
= new_undef
;
3596 new_undef
->name
= xstrdup (name
);
3598 if (link_info
.output_bfd
!= NULL
)
3599 insert_undefined (new_undef
->name
);
3602 /* Insert NAME as undefined in the symbol table. */
3605 insert_undefined (const char *name
)
3607 struct bfd_link_hash_entry
*h
;
3609 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
3611 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
3612 if (h
->type
== bfd_link_hash_new
)
3614 h
->type
= bfd_link_hash_undefined
;
3615 h
->u
.undef
.abfd
= NULL
;
3616 h
->non_ir_ref_regular
= TRUE
;
3617 if (is_elf_hash_table (link_info
.hash
))
3618 ((struct elf_link_hash_entry
*) h
)->mark
= 1;
3619 bfd_link_add_undef (link_info
.hash
, h
);
3623 /* Run through the list of undefineds created above and place them
3624 into the linker hash table as undefined symbols belonging to the
3628 lang_place_undefineds (void)
3630 ldlang_undef_chain_list_type
*ptr
;
3632 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3633 insert_undefined (ptr
->name
);
3636 /* Structure used to build the list of symbols that the user has required
3639 struct require_defined_symbol
3642 struct require_defined_symbol
*next
;
3645 /* The list of symbols that the user has required be defined. */
3647 static struct require_defined_symbol
*require_defined_symbol_list
;
3649 /* Add a new symbol NAME to the list of symbols that are required to be
3653 ldlang_add_require_defined (const char *const name
)
3655 struct require_defined_symbol
*ptr
;
3657 ldlang_add_undef (name
, TRUE
);
3658 ptr
= (struct require_defined_symbol
*) stat_alloc (sizeof (*ptr
));
3659 ptr
->next
= require_defined_symbol_list
;
3660 ptr
->name
= strdup (name
);
3661 require_defined_symbol_list
= ptr
;
3664 /* Check that all symbols the user required to be defined, are defined,
3665 raise an error if we find a symbol that is not defined. */
3668 ldlang_check_require_defined_symbols (void)
3670 struct require_defined_symbol
*ptr
;
3672 for (ptr
= require_defined_symbol_list
; ptr
!= NULL
; ptr
= ptr
->next
)
3674 struct bfd_link_hash_entry
*h
;
3676 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
,
3677 FALSE
, FALSE
, TRUE
);
3679 || (h
->type
!= bfd_link_hash_defined
3680 && h
->type
!= bfd_link_hash_defweak
))
3681 einfo(_("%X%P: required symbol `%s' not defined\n"), ptr
->name
);
3685 /* Check for all readonly or some readwrite sections. */
3688 check_input_sections
3689 (lang_statement_union_type
*s
,
3690 lang_output_section_statement_type
*output_section_statement
)
3692 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
3694 switch (s
->header
.type
)
3696 case lang_wild_statement_enum
:
3697 walk_wild (&s
->wild_statement
, check_section_callback
,
3698 output_section_statement
);
3699 if (!output_section_statement
->all_input_readonly
)
3702 case lang_constructors_statement_enum
:
3703 check_input_sections (constructor_list
.head
,
3704 output_section_statement
);
3705 if (!output_section_statement
->all_input_readonly
)
3708 case lang_group_statement_enum
:
3709 check_input_sections (s
->group_statement
.children
.head
,
3710 output_section_statement
);
3711 if (!output_section_statement
->all_input_readonly
)
3720 /* Update wildcard statements if needed. */
3723 update_wild_statements (lang_statement_union_type
*s
)
3725 struct wildcard_list
*sec
;
3727 switch (sort_section
)
3737 for (; s
!= NULL
; s
= s
->header
.next
)
3739 switch (s
->header
.type
)
3744 case lang_wild_statement_enum
:
3745 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
3748 switch (sec
->spec
.sorted
)
3751 sec
->spec
.sorted
= sort_section
;
3754 if (sort_section
== by_alignment
)
3755 sec
->spec
.sorted
= by_name_alignment
;
3758 if (sort_section
== by_name
)
3759 sec
->spec
.sorted
= by_alignment_name
;
3767 case lang_constructors_statement_enum
:
3768 update_wild_statements (constructor_list
.head
);
3771 case lang_output_section_statement_enum
:
3772 /* Don't sort .init/.fini sections. */
3773 if (strcmp (s
->output_section_statement
.name
, ".init") != 0
3774 && strcmp (s
->output_section_statement
.name
, ".fini") != 0)
3775 update_wild_statements
3776 (s
->output_section_statement
.children
.head
);
3779 case lang_group_statement_enum
:
3780 update_wild_statements (s
->group_statement
.children
.head
);
3788 /* Open input files and attach to output sections. */
3791 map_input_to_output_sections
3792 (lang_statement_union_type
*s
, const char *target
,
3793 lang_output_section_statement_type
*os
)
3795 for (; s
!= NULL
; s
= s
->header
.next
)
3797 lang_output_section_statement_type
*tos
;
3800 switch (s
->header
.type
)
3802 case lang_wild_statement_enum
:
3803 wild (&s
->wild_statement
, target
, os
);
3805 case lang_constructors_statement_enum
:
3806 map_input_to_output_sections (constructor_list
.head
,
3810 case lang_output_section_statement_enum
:
3811 tos
= &s
->output_section_statement
;
3812 if (tos
->constraint
!= 0)
3814 if (tos
->constraint
!= ONLY_IF_RW
3815 && tos
->constraint
!= ONLY_IF_RO
)
3817 tos
->all_input_readonly
= TRUE
;
3818 check_input_sections (tos
->children
.head
, tos
);
3819 if (tos
->all_input_readonly
!= (tos
->constraint
== ONLY_IF_RO
))
3821 tos
->constraint
= -1;
3825 map_input_to_output_sections (tos
->children
.head
,
3829 case lang_output_statement_enum
:
3831 case lang_target_statement_enum
:
3832 target
= s
->target_statement
.target
;
3834 case lang_group_statement_enum
:
3835 map_input_to_output_sections (s
->group_statement
.children
.head
,
3839 case lang_data_statement_enum
:
3840 /* Make sure that any sections mentioned in the expression
3842 exp_init_os (s
->data_statement
.exp
);
3843 /* The output section gets CONTENTS, ALLOC and LOAD, but
3844 these may be overridden by the script. */
3845 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
;
3846 switch (os
->sectype
)
3848 case normal_section
:
3849 case overlay_section
:
3851 case noalloc_section
:
3852 flags
= SEC_HAS_CONTENTS
;
3854 case noload_section
:
3855 if (bfd_get_flavour (link_info
.output_bfd
)
3856 == bfd_target_elf_flavour
)
3857 flags
= SEC_NEVER_LOAD
| SEC_ALLOC
;
3859 flags
= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
;
3862 if (os
->bfd_section
== NULL
)
3863 init_os (os
, flags
);
3865 os
->bfd_section
->flags
|= flags
;
3867 case lang_input_section_enum
:
3869 case lang_fill_statement_enum
:
3870 case lang_object_symbols_statement_enum
:
3871 case lang_reloc_statement_enum
:
3872 case lang_padding_statement_enum
:
3873 case lang_input_statement_enum
:
3874 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3877 case lang_assignment_statement_enum
:
3878 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3881 /* Make sure that any sections mentioned in the assignment
3883 exp_init_os (s
->assignment_statement
.exp
);
3885 case lang_address_statement_enum
:
3886 /* Mark the specified section with the supplied address.
3887 If this section was actually a segment marker, then the
3888 directive is ignored if the linker script explicitly
3889 processed the segment marker. Originally, the linker
3890 treated segment directives (like -Ttext on the
3891 command-line) as section directives. We honor the
3892 section directive semantics for backwards compatibility;
3893 linker scripts that do not specifically check for
3894 SEGMENT_START automatically get the old semantics. */
3895 if (!s
->address_statement
.segment
3896 || !s
->address_statement
.segment
->used
)
3898 const char *name
= s
->address_statement
.section_name
;
3900 /* Create the output section statement here so that
3901 orphans with a set address will be placed after other
3902 script sections. If we let the orphan placement code
3903 place them in amongst other sections then the address
3904 will affect following script sections, which is
3905 likely to surprise naive users. */
3906 tos
= lang_output_section_statement_lookup (name
, 0, TRUE
);
3907 tos
->addr_tree
= s
->address_statement
.address
;
3908 if (tos
->bfd_section
== NULL
)
3912 case lang_insert_statement_enum
:
3918 /* An insert statement snips out all the linker statements from the
3919 start of the list and places them after the output section
3920 statement specified by the insert. This operation is complicated
3921 by the fact that we keep a doubly linked list of output section
3922 statements as well as the singly linked list of all statements. */
3925 process_insert_statements (void)
3927 lang_statement_union_type
**s
;
3928 lang_output_section_statement_type
*first_os
= NULL
;
3929 lang_output_section_statement_type
*last_os
= NULL
;
3930 lang_output_section_statement_type
*os
;
3932 /* "start of list" is actually the statement immediately after
3933 the special abs_section output statement, so that it isn't
3935 s
= &lang_output_section_statement
.head
;
3936 while (*(s
= &(*s
)->header
.next
) != NULL
)
3938 if ((*s
)->header
.type
== lang_output_section_statement_enum
)
3940 /* Keep pointers to the first and last output section
3941 statement in the sequence we may be about to move. */
3942 os
= &(*s
)->output_section_statement
;
3944 ASSERT (last_os
== NULL
|| last_os
->next
== os
);
3947 /* Set constraint negative so that lang_output_section_find
3948 won't match this output section statement. At this
3949 stage in linking constraint has values in the range
3950 [-1, ONLY_IN_RW]. */
3951 last_os
->constraint
= -2 - last_os
->constraint
;
3952 if (first_os
== NULL
)
3955 else if ((*s
)->header
.type
== lang_insert_statement_enum
)
3957 lang_insert_statement_type
*i
= &(*s
)->insert_statement
;
3958 lang_output_section_statement_type
*where
;
3959 lang_statement_union_type
**ptr
;
3960 lang_statement_union_type
*first
;
3962 where
= lang_output_section_find (i
->where
);
3963 if (where
!= NULL
&& i
->is_before
)
3966 where
= where
->prev
;
3967 while (where
!= NULL
&& where
->constraint
< 0);
3971 einfo (_("%F%P: %s not found for insert\n"), i
->where
);
3975 /* Deal with reordering the output section statement list. */
3976 if (last_os
!= NULL
)
3978 asection
*first_sec
, *last_sec
;
3979 struct lang_output_section_statement_struct
**next
;
3981 /* Snip out the output sections we are moving. */
3982 first_os
->prev
->next
= last_os
->next
;
3983 if (last_os
->next
== NULL
)
3985 next
= &first_os
->prev
->next
;
3986 lang_output_section_statement
.tail
3987 = (lang_statement_union_type
**) next
;
3990 last_os
->next
->prev
= first_os
->prev
;
3991 /* Add them in at the new position. */
3992 last_os
->next
= where
->next
;
3993 if (where
->next
== NULL
)
3995 next
= &last_os
->next
;
3996 lang_output_section_statement
.tail
3997 = (lang_statement_union_type
**) next
;
4000 where
->next
->prev
= last_os
;
4001 first_os
->prev
= where
;
4002 where
->next
= first_os
;
4004 /* Move the bfd sections in the same way. */
4007 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4009 os
->constraint
= -2 - os
->constraint
;
4010 if (os
->bfd_section
!= NULL
4011 && os
->bfd_section
->owner
!= NULL
)
4013 last_sec
= os
->bfd_section
;
4014 if (first_sec
== NULL
)
4015 first_sec
= last_sec
;
4020 if (last_sec
!= NULL
)
4022 asection
*sec
= where
->bfd_section
;
4024 sec
= output_prev_sec_find (where
);
4026 /* The place we want to insert must come after the
4027 sections we are moving. So if we find no
4028 section or if the section is the same as our
4029 last section, then no move is needed. */
4030 if (sec
!= NULL
&& sec
!= last_sec
)
4032 /* Trim them off. */
4033 if (first_sec
->prev
!= NULL
)
4034 first_sec
->prev
->next
= last_sec
->next
;
4036 link_info
.output_bfd
->sections
= last_sec
->next
;
4037 if (last_sec
->next
!= NULL
)
4038 last_sec
->next
->prev
= first_sec
->prev
;
4040 link_info
.output_bfd
->section_last
= first_sec
->prev
;
4042 last_sec
->next
= sec
->next
;
4043 if (sec
->next
!= NULL
)
4044 sec
->next
->prev
= last_sec
;
4046 link_info
.output_bfd
->section_last
= last_sec
;
4047 first_sec
->prev
= sec
;
4048 sec
->next
= first_sec
;
4056 ptr
= insert_os_after (where
);
4057 /* Snip everything after the abs_section output statement we
4058 know is at the start of the list, up to and including
4059 the insert statement we are currently processing. */
4060 first
= lang_output_section_statement
.head
->header
.next
;
4061 lang_output_section_statement
.head
->header
.next
= (*s
)->header
.next
;
4062 /* Add them back where they belong. */
4065 statement_list
.tail
= s
;
4067 s
= &lang_output_section_statement
.head
;
4071 /* Undo constraint twiddling. */
4072 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4074 os
->constraint
= -2 - os
->constraint
;
4080 /* An output section might have been removed after its statement was
4081 added. For example, ldemul_before_allocation can remove dynamic
4082 sections if they turn out to be not needed. Clean them up here. */
4085 strip_excluded_output_sections (void)
4087 lang_output_section_statement_type
*os
;
4089 /* Run lang_size_sections (if not already done). */
4090 if (expld
.phase
!= lang_mark_phase_enum
)
4092 expld
.phase
= lang_mark_phase_enum
;
4093 expld
.dataseg
.phase
= exp_seg_none
;
4094 one_lang_size_sections_pass (NULL
, FALSE
);
4095 lang_reset_memory_regions ();
4098 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
4102 asection
*output_section
;
4103 bfd_boolean exclude
;
4105 if (os
->constraint
< 0)
4108 output_section
= os
->bfd_section
;
4109 if (output_section
== NULL
)
4112 exclude
= (output_section
->rawsize
== 0
4113 && (output_section
->flags
& SEC_KEEP
) == 0
4114 && !bfd_section_removed_from_list (link_info
.output_bfd
,
4117 /* Some sections have not yet been sized, notably .gnu.version,
4118 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
4119 input sections, so don't drop output sections that have such
4120 input sections unless they are also marked SEC_EXCLUDE. */
4121 if (exclude
&& output_section
->map_head
.s
!= NULL
)
4125 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
4126 if ((s
->flags
& SEC_EXCLUDE
) == 0
4127 && ((s
->flags
& SEC_LINKER_CREATED
) != 0
4128 || link_info
.emitrelocations
))
4137 /* We don't set bfd_section to NULL since bfd_section of the
4138 removed output section statement may still be used. */
4139 if (!os
->update_dot
)
4141 output_section
->flags
|= SEC_EXCLUDE
;
4142 bfd_section_list_remove (link_info
.output_bfd
, output_section
);
4143 link_info
.output_bfd
->section_count
--;
4148 /* Called from ldwrite to clear out asection.map_head and
4149 asection.map_tail for use as link_orders in ldwrite. */
4152 lang_clear_os_map (void)
4154 lang_output_section_statement_type
*os
;
4156 if (map_head_is_link_order
)
4159 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
4163 asection
*output_section
;
4165 if (os
->constraint
< 0)
4168 output_section
= os
->bfd_section
;
4169 if (output_section
== NULL
)
4172 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
4173 output_section
->map_head
.link_order
= NULL
;
4174 output_section
->map_tail
.link_order
= NULL
;
4177 /* Stop future calls to lang_add_section from messing with map_head
4178 and map_tail link_order fields. */
4179 map_head_is_link_order
= TRUE
;
4183 print_output_section_statement
4184 (lang_output_section_statement_type
*output_section_statement
)
4186 asection
*section
= output_section_statement
->bfd_section
;
4189 if (output_section_statement
!= abs_output_section
)
4191 minfo ("\n%s", output_section_statement
->name
);
4193 if (section
!= NULL
)
4195 print_dot
= section
->vma
;
4197 len
= strlen (output_section_statement
->name
);
4198 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4203 while (len
< SECTION_NAME_MAP_LENGTH
)
4209 minfo ("0x%V %W", section
->vma
, TO_ADDR (section
->size
));
4211 if (section
->vma
!= section
->lma
)
4212 minfo (_(" load address 0x%V"), section
->lma
);
4214 if (output_section_statement
->update_dot_tree
!= NULL
)
4215 exp_fold_tree (output_section_statement
->update_dot_tree
,
4216 bfd_abs_section_ptr
, &print_dot
);
4222 print_statement_list (output_section_statement
->children
.head
,
4223 output_section_statement
);
4227 print_assignment (lang_assignment_statement_type
*assignment
,
4228 lang_output_section_statement_type
*output_section
)
4235 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4238 if (assignment
->exp
->type
.node_class
== etree_assert
)
4241 tree
= assignment
->exp
->assert_s
.child
;
4245 const char *dst
= assignment
->exp
->assign
.dst
;
4247 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
4248 tree
= assignment
->exp
;
4251 osec
= output_section
->bfd_section
;
4253 osec
= bfd_abs_section_ptr
;
4255 if (assignment
->exp
->type
.node_class
!= etree_provide
)
4256 exp_fold_tree (tree
, osec
, &print_dot
);
4258 expld
.result
.valid_p
= FALSE
;
4260 if (expld
.result
.valid_p
)
4264 if (assignment
->exp
->type
.node_class
== etree_assert
4266 || expld
.assign_name
!= NULL
)
4268 value
= expld
.result
.value
;
4270 if (expld
.result
.section
!= NULL
)
4271 value
+= expld
.result
.section
->vma
;
4273 minfo ("0x%V", value
);
4279 struct bfd_link_hash_entry
*h
;
4281 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
4282 FALSE
, FALSE
, TRUE
);
4284 && (h
->type
== bfd_link_hash_defined
4285 || h
->type
== bfd_link_hash_defweak
))
4287 value
= h
->u
.def
.value
;
4288 value
+= h
->u
.def
.section
->output_section
->vma
;
4289 value
+= h
->u
.def
.section
->output_offset
;
4291 minfo ("[0x%V]", value
);
4294 minfo ("[unresolved]");
4299 if (assignment
->exp
->type
.node_class
== etree_provide
)
4300 minfo ("[!provide]");
4307 expld
.assign_name
= NULL
;
4310 exp_print_tree (assignment
->exp
);
4315 print_input_statement (lang_input_statement_type
*statm
)
4317 if (statm
->filename
!= NULL
4318 && (statm
->the_bfd
== NULL
4319 || (statm
->the_bfd
->flags
& BFD_LINKER_CREATED
) == 0))
4320 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
4323 /* Print all symbols defined in a particular section. This is called
4324 via bfd_link_hash_traverse, or by print_all_symbols. */
4327 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
4329 asection
*sec
= (asection
*) ptr
;
4331 if ((hash_entry
->type
== bfd_link_hash_defined
4332 || hash_entry
->type
== bfd_link_hash_defweak
)
4333 && sec
== hash_entry
->u
.def
.section
)
4337 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4340 (hash_entry
->u
.def
.value
4341 + hash_entry
->u
.def
.section
->output_offset
4342 + hash_entry
->u
.def
.section
->output_section
->vma
));
4344 minfo (" %pT\n", hash_entry
->root
.string
);
4351 hash_entry_addr_cmp (const void *a
, const void *b
)
4353 const struct bfd_link_hash_entry
*l
= *(const struct bfd_link_hash_entry
**)a
;
4354 const struct bfd_link_hash_entry
*r
= *(const struct bfd_link_hash_entry
**)b
;
4356 if (l
->u
.def
.value
< r
->u
.def
.value
)
4358 else if (l
->u
.def
.value
> r
->u
.def
.value
)
4365 print_all_symbols (asection
*sec
)
4367 input_section_userdata_type
*ud
4368 = (input_section_userdata_type
*) get_userdata (sec
);
4369 struct map_symbol_def
*def
;
4370 struct bfd_link_hash_entry
**entries
;
4376 *ud
->map_symbol_def_tail
= 0;
4378 /* Sort the symbols by address. */
4379 entries
= (struct bfd_link_hash_entry
**)
4380 obstack_alloc (&map_obstack
,
4381 ud
->map_symbol_def_count
* sizeof (*entries
));
4383 for (i
= 0, def
= ud
->map_symbol_def_head
; def
; def
= def
->next
, i
++)
4384 entries
[i
] = def
->entry
;
4386 qsort (entries
, ud
->map_symbol_def_count
, sizeof (*entries
),
4387 hash_entry_addr_cmp
);
4389 /* Print the symbols. */
4390 for (i
= 0; i
< ud
->map_symbol_def_count
; i
++)
4391 print_one_symbol (entries
[i
], sec
);
4393 obstack_free (&map_obstack
, entries
);
4396 /* Print information about an input section to the map file. */
4399 print_input_section (asection
*i
, bfd_boolean is_discarded
)
4401 bfd_size_type size
= i
->size
;
4408 minfo ("%s", i
->name
);
4410 len
= 1 + strlen (i
->name
);
4411 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4416 while (len
< SECTION_NAME_MAP_LENGTH
)
4422 if (i
->output_section
!= NULL
4423 && i
->output_section
->owner
== link_info
.output_bfd
)
4424 addr
= i
->output_section
->vma
+ i
->output_offset
;
4432 minfo ("0x%V %W %pB\n", addr
, size
, i
->owner
);
4434 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
4436 len
= SECTION_NAME_MAP_LENGTH
+ 3;
4448 minfo (_("%W (size before relaxing)\n"), i
->rawsize
);
4451 if (i
->output_section
!= NULL
4452 && i
->output_section
->owner
== link_info
.output_bfd
)
4454 if (link_info
.reduce_memory_overheads
)
4455 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, i
);
4457 print_all_symbols (i
);
4459 /* Update print_dot, but make sure that we do not move it
4460 backwards - this could happen if we have overlays and a
4461 later overlay is shorter than an earier one. */
4462 if (addr
+ TO_ADDR (size
) > print_dot
)
4463 print_dot
= addr
+ TO_ADDR (size
);
4468 print_fill_statement (lang_fill_statement_type
*fill
)
4472 fputs (" FILL mask 0x", config
.map_file
);
4473 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
4474 fprintf (config
.map_file
, "%02x", *p
);
4475 fputs ("\n", config
.map_file
);
4479 print_data_statement (lang_data_statement_type
*data
)
4487 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4490 addr
= data
->output_offset
;
4491 if (data
->output_section
!= NULL
)
4492 addr
+= data
->output_section
->vma
;
4520 if (size
< TO_SIZE ((unsigned) 1))
4521 size
= TO_SIZE ((unsigned) 1);
4522 minfo ("0x%V %W %s 0x%v", addr
, TO_ADDR (size
), name
, data
->value
);
4524 if (data
->exp
->type
.node_class
!= etree_value
)
4527 exp_print_tree (data
->exp
);
4532 print_dot
= addr
+ TO_ADDR (size
);
4535 /* Print an address statement. These are generated by options like
4539 print_address_statement (lang_address_statement_type
*address
)
4541 minfo (_("Address of section %s set to "), address
->section_name
);
4542 exp_print_tree (address
->address
);
4546 /* Print a reloc statement. */
4549 print_reloc_statement (lang_reloc_statement_type
*reloc
)
4556 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4559 addr
= reloc
->output_offset
;
4560 if (reloc
->output_section
!= NULL
)
4561 addr
+= reloc
->output_section
->vma
;
4563 size
= bfd_get_reloc_size (reloc
->howto
);
4565 minfo ("0x%V %W RELOC %s ", addr
, TO_ADDR (size
), reloc
->howto
->name
);
4567 if (reloc
->name
!= NULL
)
4568 minfo ("%s+", reloc
->name
);
4570 minfo ("%s+", reloc
->section
->name
);
4572 exp_print_tree (reloc
->addend_exp
);
4576 print_dot
= addr
+ TO_ADDR (size
);
4580 print_padding_statement (lang_padding_statement_type
*s
)
4588 len
= sizeof " *fill*" - 1;
4589 while (len
< SECTION_NAME_MAP_LENGTH
)
4595 addr
= s
->output_offset
;
4596 if (s
->output_section
!= NULL
)
4597 addr
+= s
->output_section
->vma
;
4598 minfo ("0x%V %W ", addr
, TO_ADDR (s
->size
));
4600 if (s
->fill
->size
!= 0)
4604 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
4605 fprintf (config
.map_file
, "%02x", *p
);
4610 print_dot
= addr
+ TO_ADDR (s
->size
);
4614 print_wild_statement (lang_wild_statement_type
*w
,
4615 lang_output_section_statement_type
*os
)
4617 struct wildcard_list
*sec
;
4621 if (w
->exclude_name_list
)
4624 minfo ("EXCLUDE_FILE(%s", w
->exclude_name_list
->name
);
4625 for (tmp
= w
->exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4626 minfo (" %s", tmp
->name
);
4630 if (w
->filenames_sorted
)
4631 minfo ("SORT_BY_NAME(");
4632 if (w
->filename
!= NULL
)
4633 minfo ("%s", w
->filename
);
4636 if (w
->filenames_sorted
)
4640 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
4642 int closing_paren
= 0;
4644 switch (sec
->spec
.sorted
)
4650 minfo ("SORT_BY_NAME(");
4655 minfo ("SORT_BY_ALIGNMENT(");
4659 case by_name_alignment
:
4660 minfo ("SORT_BY_NAME(SORT_BY_ALIGNMENT(");
4664 case by_alignment_name
:
4665 minfo ("SORT_BY_ALIGNMENT(SORT_BY_NAME(");
4670 minfo ("SORT_NONE(");
4674 case by_init_priority
:
4675 minfo ("SORT_BY_INIT_PRIORITY(");
4680 if (sec
->spec
.exclude_name_list
!= NULL
)
4683 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
4684 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4685 minfo (" %s", tmp
->name
);
4688 if (sec
->spec
.name
!= NULL
)
4689 minfo ("%s", sec
->spec
.name
);
4692 for (;closing_paren
> 0; closing_paren
--)
4701 print_statement_list (w
->children
.head
, os
);
4704 /* Print a group statement. */
4707 print_group (lang_group_statement_type
*s
,
4708 lang_output_section_statement_type
*os
)
4710 fprintf (config
.map_file
, "START GROUP\n");
4711 print_statement_list (s
->children
.head
, os
);
4712 fprintf (config
.map_file
, "END GROUP\n");
4715 /* Print the list of statements in S.
4716 This can be called for any statement type. */
4719 print_statement_list (lang_statement_union_type
*s
,
4720 lang_output_section_statement_type
*os
)
4724 print_statement (s
, os
);
4729 /* Print the first statement in statement list S.
4730 This can be called for any statement type. */
4733 print_statement (lang_statement_union_type
*s
,
4734 lang_output_section_statement_type
*os
)
4736 switch (s
->header
.type
)
4739 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
4742 case lang_constructors_statement_enum
:
4743 if (constructor_list
.head
!= NULL
)
4745 if (constructors_sorted
)
4746 minfo (" SORT (CONSTRUCTORS)\n");
4748 minfo (" CONSTRUCTORS\n");
4749 print_statement_list (constructor_list
.head
, os
);
4752 case lang_wild_statement_enum
:
4753 print_wild_statement (&s
->wild_statement
, os
);
4755 case lang_address_statement_enum
:
4756 print_address_statement (&s
->address_statement
);
4758 case lang_object_symbols_statement_enum
:
4759 minfo (" CREATE_OBJECT_SYMBOLS\n");
4761 case lang_fill_statement_enum
:
4762 print_fill_statement (&s
->fill_statement
);
4764 case lang_data_statement_enum
:
4765 print_data_statement (&s
->data_statement
);
4767 case lang_reloc_statement_enum
:
4768 print_reloc_statement (&s
->reloc_statement
);
4770 case lang_input_section_enum
:
4771 print_input_section (s
->input_section
.section
, FALSE
);
4773 case lang_padding_statement_enum
:
4774 print_padding_statement (&s
->padding_statement
);
4776 case lang_output_section_statement_enum
:
4777 print_output_section_statement (&s
->output_section_statement
);
4779 case lang_assignment_statement_enum
:
4780 print_assignment (&s
->assignment_statement
, os
);
4782 case lang_target_statement_enum
:
4783 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
4785 case lang_output_statement_enum
:
4786 minfo ("OUTPUT(%s", s
->output_statement
.name
);
4787 if (output_target
!= NULL
)
4788 minfo (" %s", output_target
);
4791 case lang_input_statement_enum
:
4792 print_input_statement (&s
->input_statement
);
4794 case lang_group_statement_enum
:
4795 print_group (&s
->group_statement
, os
);
4797 case lang_insert_statement_enum
:
4798 minfo ("INSERT %s %s\n",
4799 s
->insert_statement
.is_before
? "BEFORE" : "AFTER",
4800 s
->insert_statement
.where
);
4806 print_statements (void)
4808 print_statement_list (statement_list
.head
, abs_output_section
);
4811 /* Print the first N statements in statement list S to STDERR.
4812 If N == 0, nothing is printed.
4813 If N < 0, the entire list is printed.
4814 Intended to be called from GDB. */
4817 dprint_statement (lang_statement_union_type
*s
, int n
)
4819 FILE *map_save
= config
.map_file
;
4821 config
.map_file
= stderr
;
4824 print_statement_list (s
, abs_output_section
);
4827 while (s
&& --n
>= 0)
4829 print_statement (s
, abs_output_section
);
4834 config
.map_file
= map_save
;
4838 insert_pad (lang_statement_union_type
**ptr
,
4840 bfd_size_type alignment_needed
,
4841 asection
*output_section
,
4844 static fill_type zero_fill
;
4845 lang_statement_union_type
*pad
= NULL
;
4847 if (ptr
!= &statement_list
.head
)
4848 pad
= ((lang_statement_union_type
*)
4849 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
4851 && pad
->header
.type
== lang_padding_statement_enum
4852 && pad
->padding_statement
.output_section
== output_section
)
4854 /* Use the existing pad statement. */
4856 else if ((pad
= *ptr
) != NULL
4857 && pad
->header
.type
== lang_padding_statement_enum
4858 && pad
->padding_statement
.output_section
== output_section
)
4860 /* Use the existing pad statement. */
4864 /* Make a new padding statement, linked into existing chain. */
4865 pad
= (lang_statement_union_type
*)
4866 stat_alloc (sizeof (lang_padding_statement_type
));
4867 pad
->header
.next
= *ptr
;
4869 pad
->header
.type
= lang_padding_statement_enum
;
4870 pad
->padding_statement
.output_section
= output_section
;
4873 pad
->padding_statement
.fill
= fill
;
4875 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
4876 pad
->padding_statement
.size
= alignment_needed
;
4877 if (!(output_section
->flags
& SEC_FIXED_SIZE
))
4878 output_section
->size
= TO_SIZE (dot
+ TO_ADDR (alignment_needed
)
4879 - output_section
->vma
);
4882 /* Work out how much this section will move the dot point. */
4886 (lang_statement_union_type
**this_ptr
,
4887 lang_output_section_statement_type
*output_section_statement
,
4891 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
4892 asection
*i
= is
->section
;
4893 asection
*o
= output_section_statement
->bfd_section
;
4895 if (i
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
4896 i
->output_offset
= i
->vma
- o
->vma
;
4897 else if (((i
->flags
& SEC_EXCLUDE
) != 0)
4898 || output_section_statement
->ignored
)
4899 i
->output_offset
= dot
- o
->vma
;
4902 bfd_size_type alignment_needed
;
4904 /* Align this section first to the input sections requirement,
4905 then to the output section's requirement. If this alignment
4906 is greater than any seen before, then record it too. Perform
4907 the alignment by inserting a magic 'padding' statement. */
4909 if (output_section_statement
->subsection_alignment
!= NULL
)
4911 = exp_get_power (output_section_statement
->subsection_alignment
,
4912 "subsection alignment");
4914 if (o
->alignment_power
< i
->alignment_power
)
4915 o
->alignment_power
= i
->alignment_power
;
4917 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
4919 if (alignment_needed
!= 0)
4921 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
4922 dot
+= alignment_needed
;
4925 /* Remember where in the output section this input section goes. */
4926 i
->output_offset
= dot
- o
->vma
;
4928 /* Mark how big the output section must be to contain this now. */
4929 dot
+= TO_ADDR (i
->size
);
4930 if (!(o
->flags
& SEC_FIXED_SIZE
))
4931 o
->size
= TO_SIZE (dot
- o
->vma
);
4944 sort_sections_by_lma (const void *arg1
, const void *arg2
)
4946 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
4947 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
4949 if (sec1
->lma
< sec2
->lma
)
4951 else if (sec1
->lma
> sec2
->lma
)
4953 else if (sec1
->id
< sec2
->id
)
4955 else if (sec1
->id
> sec2
->id
)
4962 sort_sections_by_vma (const void *arg1
, const void *arg2
)
4964 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
4965 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
4967 if (sec1
->vma
< sec2
->vma
)
4969 else if (sec1
->vma
> sec2
->vma
)
4971 else if (sec1
->id
< sec2
->id
)
4973 else if (sec1
->id
> sec2
->id
)
4979 #define IS_TBSS(s) \
4980 ((s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == SEC_THREAD_LOCAL)
4982 #define IGNORE_SECTION(s) \
4983 ((s->flags & SEC_ALLOC) == 0 || IS_TBSS (s))
4985 /* Check to see if any allocated sections overlap with other allocated
4986 sections. This can happen if a linker script specifies the output
4987 section addresses of the two sections. Also check whether any memory
4988 region has overflowed. */
4991 lang_check_section_addresses (void)
4994 struct check_sec
*sections
;
4999 bfd_vma p_start
= 0;
5001 lang_memory_region_type
*m
;
5002 bfd_boolean overlays
;
5004 /* Detect address space overflow on allocated sections. */
5005 addr_mask
= ((bfd_vma
) 1 <<
5006 (bfd_arch_bits_per_address (link_info
.output_bfd
) - 1)) - 1;
5007 addr_mask
= (addr_mask
<< 1) + 1;
5008 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5009 if ((s
->flags
& SEC_ALLOC
) != 0)
5011 s_end
= (s
->vma
+ s
->size
) & addr_mask
;
5012 if (s_end
!= 0 && s_end
< (s
->vma
& addr_mask
))
5013 einfo (_("%X%P: section %s VMA wraps around address space\n"),
5017 s_end
= (s
->lma
+ s
->size
) & addr_mask
;
5018 if (s_end
!= 0 && s_end
< (s
->lma
& addr_mask
))
5019 einfo (_("%X%P: section %s LMA wraps around address space\n"),
5024 if (bfd_count_sections (link_info
.output_bfd
) <= 1)
5027 count
= bfd_count_sections (link_info
.output_bfd
);
5028 sections
= XNEWVEC (struct check_sec
, count
);
5030 /* Scan all sections in the output list. */
5032 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5034 if (IGNORE_SECTION (s
)
5038 sections
[count
].sec
= s
;
5039 sections
[count
].warned
= FALSE
;
5049 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_lma
);
5051 /* First check section LMAs. There should be no overlap of LMAs on
5052 loadable sections, even with overlays. */
5053 for (p
= NULL
, i
= 0; i
< count
; i
++)
5055 s
= sections
[i
].sec
;
5056 if ((s
->flags
& SEC_LOAD
) != 0)
5059 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5061 /* Look for an overlap. We have sorted sections by lma, so
5062 we know that s_start >= p_start. Besides the obvious
5063 case of overlap when the current section starts before
5064 the previous one ends, we also must have overlap if the
5065 previous section wraps around the address space. */
5067 && (s_start
<= p_end
5068 || p_end
< p_start
))
5070 einfo (_("%X%P: section %s LMA [%V,%V]"
5071 " overlaps section %s LMA [%V,%V]\n"),
5072 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5073 sections
[i
].warned
= TRUE
;
5081 /* If any non-zero size allocated section (excluding tbss) starts at
5082 exactly the same VMA as another such section, then we have
5083 overlays. Overlays generated by the OVERLAY keyword will have
5084 this property. It is possible to intentionally generate overlays
5085 that fail this test, but it would be unusual. */
5086 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_vma
);
5088 p_start
= sections
[0].sec
->vma
;
5089 for (i
= 1; i
< count
; i
++)
5091 s_start
= sections
[i
].sec
->vma
;
5092 if (p_start
== s_start
)
5100 /* Now check section VMAs if no overlays were detected. */
5103 for (p
= NULL
, i
= 0; i
< count
; i
++)
5105 s
= sections
[i
].sec
;
5107 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5110 && !sections
[i
].warned
5111 && (s_start
<= p_end
5112 || p_end
< p_start
))
5113 einfo (_("%X%P: section %s VMA [%V,%V]"
5114 " overlaps section %s VMA [%V,%V]\n"),
5115 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5124 /* If any memory region has overflowed, report by how much.
5125 We do not issue this diagnostic for regions that had sections
5126 explicitly placed outside their bounds; os_region_check's
5127 diagnostics are adequate for that case.
5129 FIXME: It is conceivable that m->current - (m->origin + m->length)
5130 might overflow a 32-bit integer. There is, alas, no way to print
5131 a bfd_vma quantity in decimal. */
5132 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
5133 if (m
->had_full_message
)
5135 unsigned long over
= m
->current
- (m
->origin
+ m
->length
);
5136 einfo (ngettext ("%X%P: region `%s' overflowed by %lu byte\n",
5137 "%X%P: region `%s' overflowed by %lu bytes\n",
5139 m
->name_list
.name
, over
);
5143 /* Make sure the new address is within the region. We explicitly permit the
5144 current address to be at the exact end of the region when the address is
5145 non-zero, in case the region is at the end of addressable memory and the
5146 calculation wraps around. */
5149 os_region_check (lang_output_section_statement_type
*os
,
5150 lang_memory_region_type
*region
,
5154 if ((region
->current
< region
->origin
5155 || (region
->current
- region
->origin
> region
->length
))
5156 && ((region
->current
!= region
->origin
+ region
->length
)
5161 einfo (_("%X%P: address 0x%v of %pB section `%s'"
5162 " is not within region `%s'\n"),
5164 os
->bfd_section
->owner
,
5165 os
->bfd_section
->name
,
5166 region
->name_list
.name
);
5168 else if (!region
->had_full_message
)
5170 region
->had_full_message
= TRUE
;
5172 einfo (_("%X%P: %pB section `%s' will not fit in region `%s'\n"),
5173 os
->bfd_section
->owner
,
5174 os
->bfd_section
->name
,
5175 region
->name_list
.name
);
5181 ldlang_check_relro_region (lang_statement_union_type
*s
,
5182 seg_align_type
*seg
)
5184 if (seg
->relro
== exp_seg_relro_start
)
5186 if (!seg
->relro_start_stat
)
5187 seg
->relro_start_stat
= s
;
5190 ASSERT (seg
->relro_start_stat
== s
);
5193 else if (seg
->relro
== exp_seg_relro_end
)
5195 if (!seg
->relro_end_stat
)
5196 seg
->relro_end_stat
= s
;
5199 ASSERT (seg
->relro_end_stat
== s
);
5204 /* Set the sizes for all the output sections. */
5207 lang_size_sections_1
5208 (lang_statement_union_type
**prev
,
5209 lang_output_section_statement_type
*output_section_statement
,
5213 bfd_boolean check_regions
)
5215 lang_statement_union_type
*s
;
5217 /* Size up the sections from their constituent parts. */
5218 for (s
= *prev
; s
!= NULL
; s
= s
->header
.next
)
5220 switch (s
->header
.type
)
5222 case lang_output_section_statement_enum
:
5224 bfd_vma newdot
, after
, dotdelta
;
5225 lang_output_section_statement_type
*os
;
5226 lang_memory_region_type
*r
;
5227 int section_alignment
= 0;
5229 os
= &s
->output_section_statement
;
5230 if (os
->constraint
== -1)
5233 /* FIXME: We shouldn't need to zero section vmas for ld -r
5234 here, in lang_insert_orphan, or in the default linker scripts.
5235 This is covering for coff backend linker bugs. See PR6945. */
5236 if (os
->addr_tree
== NULL
5237 && bfd_link_relocatable (&link_info
)
5238 && (bfd_get_flavour (link_info
.output_bfd
)
5239 == bfd_target_coff_flavour
))
5240 os
->addr_tree
= exp_intop (0);
5241 if (os
->addr_tree
!= NULL
)
5243 os
->processed_vma
= FALSE
;
5244 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
5246 if (expld
.result
.valid_p
)
5248 dot
= expld
.result
.value
;
5249 if (expld
.result
.section
!= NULL
)
5250 dot
+= expld
.result
.section
->vma
;
5252 else if (expld
.phase
!= lang_mark_phase_enum
)
5253 einfo (_("%F%P:%pS: non constant or forward reference"
5254 " address expression for section %s\n"),
5255 os
->addr_tree
, os
->name
);
5258 if (os
->bfd_section
== NULL
)
5259 /* This section was removed or never actually created. */
5262 /* If this is a COFF shared library section, use the size and
5263 address from the input section. FIXME: This is COFF
5264 specific; it would be cleaner if there were some other way
5265 to do this, but nothing simple comes to mind. */
5266 if (((bfd_get_flavour (link_info
.output_bfd
)
5267 == bfd_target_ecoff_flavour
)
5268 || (bfd_get_flavour (link_info
.output_bfd
)
5269 == bfd_target_coff_flavour
))
5270 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
5274 if (os
->children
.head
== NULL
5275 || os
->children
.head
->header
.next
!= NULL
5276 || (os
->children
.head
->header
.type
5277 != lang_input_section_enum
))
5278 einfo (_("%X%P: internal error on COFF shared library"
5279 " section %s\n"), os
->name
);
5281 input
= os
->children
.head
->input_section
.section
;
5282 bfd_set_section_vma (os
->bfd_section
->owner
,
5284 bfd_section_vma (input
->owner
, input
));
5285 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5286 os
->bfd_section
->size
= input
->size
;
5292 if (bfd_is_abs_section (os
->bfd_section
))
5294 /* No matter what happens, an abs section starts at zero. */
5295 ASSERT (os
->bfd_section
->vma
== 0);
5299 if (os
->addr_tree
== NULL
)
5301 /* No address specified for this section, get one
5302 from the region specification. */
5303 if (os
->region
== NULL
5304 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
5305 && os
->region
->name_list
.name
[0] == '*'
5306 && strcmp (os
->region
->name_list
.name
,
5307 DEFAULT_MEMORY_REGION
) == 0))
5309 os
->region
= lang_memory_default (os
->bfd_section
);
5312 /* If a loadable section is using the default memory
5313 region, and some non default memory regions were
5314 defined, issue an error message. */
5316 && !IGNORE_SECTION (os
->bfd_section
)
5317 && !bfd_link_relocatable (&link_info
)
5319 && strcmp (os
->region
->name_list
.name
,
5320 DEFAULT_MEMORY_REGION
) == 0
5321 && lang_memory_region_list
!= NULL
5322 && (strcmp (lang_memory_region_list
->name_list
.name
,
5323 DEFAULT_MEMORY_REGION
) != 0
5324 || lang_memory_region_list
->next
!= NULL
)
5325 && expld
.phase
!= lang_mark_phase_enum
)
5327 /* By default this is an error rather than just a
5328 warning because if we allocate the section to the
5329 default memory region we can end up creating an
5330 excessively large binary, or even seg faulting when
5331 attempting to perform a negative seek. See
5332 sources.redhat.com/ml/binutils/2003-04/msg00423.html
5333 for an example of this. This behaviour can be
5334 overridden by the using the --no-check-sections
5336 if (command_line
.check_section_addresses
)
5337 einfo (_("%F%P: error: no memory region specified"
5338 " for loadable section `%s'\n"),
5339 bfd_get_section_name (link_info
.output_bfd
,
5342 einfo (_("%P: warning: no memory region specified"
5343 " for loadable section `%s'\n"),
5344 bfd_get_section_name (link_info
.output_bfd
,
5348 newdot
= os
->region
->current
;
5349 section_alignment
= os
->bfd_section
->alignment_power
;
5352 section_alignment
= exp_get_power (os
->section_alignment
,
5353 "section alignment");
5355 /* Align to what the section needs. */
5356 if (section_alignment
> 0)
5358 bfd_vma savedot
= newdot
;
5359 newdot
= align_power (newdot
, section_alignment
);
5361 dotdelta
= newdot
- savedot
;
5363 && (config
.warn_section_align
5364 || os
->addr_tree
!= NULL
)
5365 && expld
.phase
!= lang_mark_phase_enum
)
5366 einfo (ngettext ("%P: warning: changing start of "
5367 "section %s by %lu byte\n",
5368 "%P: warning: changing start of "
5369 "section %s by %lu bytes\n",
5370 (unsigned long) dotdelta
),
5371 os
->name
, (unsigned long) dotdelta
);
5374 bfd_set_section_vma (0, os
->bfd_section
, newdot
);
5376 os
->bfd_section
->output_offset
= 0;
5379 lang_size_sections_1 (&os
->children
.head
, os
,
5380 os
->fill
, newdot
, relax
, check_regions
);
5382 os
->processed_vma
= TRUE
;
5384 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5385 /* Except for some special linker created sections,
5386 no output section should change from zero size
5387 after strip_excluded_output_sections. A non-zero
5388 size on an ignored section indicates that some
5389 input section was not sized early enough. */
5390 ASSERT (os
->bfd_section
->size
== 0);
5393 dot
= os
->bfd_section
->vma
;
5395 /* Put the section within the requested block size, or
5396 align at the block boundary. */
5398 + TO_ADDR (os
->bfd_section
->size
)
5399 + os
->block_value
- 1)
5400 & - (bfd_vma
) os
->block_value
);
5402 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5403 os
->bfd_section
->size
= TO_SIZE (after
5404 - os
->bfd_section
->vma
);
5407 /* Set section lma. */
5410 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
5414 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
5415 os
->bfd_section
->lma
= lma
;
5417 else if (os
->lma_region
!= NULL
)
5419 bfd_vma lma
= os
->lma_region
->current
;
5421 if (os
->align_lma_with_input
)
5425 /* When LMA_REGION is the same as REGION, align the LMA
5426 as we did for the VMA, possibly including alignment
5427 from the bfd section. If a different region, then
5428 only align according to the value in the output
5430 if (os
->lma_region
!= os
->region
)
5431 section_alignment
= exp_get_power (os
->section_alignment
,
5432 "section alignment");
5433 if (section_alignment
> 0)
5434 lma
= align_power (lma
, section_alignment
);
5436 os
->bfd_section
->lma
= lma
;
5438 else if (r
->last_os
!= NULL
5439 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5444 last
= r
->last_os
->output_section_statement
.bfd_section
;
5446 /* A backwards move of dot should be accompanied by
5447 an explicit assignment to the section LMA (ie.
5448 os->load_base set) because backwards moves can
5449 create overlapping LMAs. */
5451 && os
->bfd_section
->size
!= 0
5452 && dot
+ TO_ADDR (os
->bfd_section
->size
) <= last
->vma
)
5454 /* If dot moved backwards then leave lma equal to
5455 vma. This is the old default lma, which might
5456 just happen to work when the backwards move is
5457 sufficiently large. Nag if this changes anything,
5458 so people can fix their linker scripts. */
5460 if (last
->vma
!= last
->lma
)
5461 einfo (_("%P: warning: dot moved backwards "
5462 "before `%s'\n"), os
->name
);
5466 /* If this is an overlay, set the current lma to that
5467 at the end of the previous section. */
5468 if (os
->sectype
== overlay_section
)
5469 lma
= last
->lma
+ TO_ADDR (last
->size
);
5471 /* Otherwise, keep the same lma to vma relationship
5472 as the previous section. */
5474 lma
= dot
+ last
->lma
- last
->vma
;
5476 if (section_alignment
> 0)
5477 lma
= align_power (lma
, section_alignment
);
5478 os
->bfd_section
->lma
= lma
;
5481 os
->processed_lma
= TRUE
;
5483 /* Keep track of normal sections using the default
5484 lma region. We use this to set the lma for
5485 following sections. Overlays or other linker
5486 script assignment to lma might mean that the
5487 default lma == vma is incorrect.
5488 To avoid warnings about dot moving backwards when using
5489 -Ttext, don't start tracking sections until we find one
5490 of non-zero size or with lma set differently to vma.
5491 Do this tracking before we short-cut the loop so that we
5492 track changes for the case where the section size is zero,
5493 but the lma is set differently to the vma. This is
5494 important, if an orphan section is placed after an
5495 otherwise empty output section that has an explicit lma
5496 set, we want that lma reflected in the orphans lma. */
5497 if (!IGNORE_SECTION (os
->bfd_section
)
5498 && (os
->bfd_section
->size
!= 0
5499 || (r
->last_os
== NULL
5500 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
5501 || (r
->last_os
!= NULL
5502 && dot
>= (r
->last_os
->output_section_statement
5503 .bfd_section
->vma
)))
5504 && os
->lma_region
== NULL
5505 && !bfd_link_relocatable (&link_info
))
5508 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5511 /* .tbss sections effectively have zero size. */
5512 if (!IS_TBSS (os
->bfd_section
)
5513 || bfd_link_relocatable (&link_info
))
5514 dotdelta
= TO_ADDR (os
->bfd_section
->size
);
5519 if (os
->update_dot_tree
!= 0)
5520 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5522 /* Update dot in the region ?
5523 We only do this if the section is going to be allocated,
5524 since unallocated sections do not contribute to the region's
5525 overall size in memory. */
5526 if (os
->region
!= NULL
5527 && (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)))
5529 os
->region
->current
= dot
;
5532 /* Make sure the new address is within the region. */
5533 os_region_check (os
, os
->region
, os
->addr_tree
,
5534 os
->bfd_section
->vma
);
5536 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
5537 && ((os
->bfd_section
->flags
& SEC_LOAD
)
5538 || os
->align_lma_with_input
))
5540 os
->lma_region
->current
= os
->bfd_section
->lma
+ dotdelta
;
5543 os_region_check (os
, os
->lma_region
, NULL
,
5544 os
->bfd_section
->lma
);
5550 case lang_constructors_statement_enum
:
5551 dot
= lang_size_sections_1 (&constructor_list
.head
,
5552 output_section_statement
,
5553 fill
, dot
, relax
, check_regions
);
5556 case lang_data_statement_enum
:
5558 unsigned int size
= 0;
5560 s
->data_statement
.output_offset
=
5561 dot
- output_section_statement
->bfd_section
->vma
;
5562 s
->data_statement
.output_section
=
5563 output_section_statement
->bfd_section
;
5565 /* We might refer to provided symbols in the expression, and
5566 need to mark them as needed. */
5567 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5569 switch (s
->data_statement
.type
)
5587 if (size
< TO_SIZE ((unsigned) 1))
5588 size
= TO_SIZE ((unsigned) 1);
5589 dot
+= TO_ADDR (size
);
5590 if (!(output_section_statement
->bfd_section
->flags
5592 output_section_statement
->bfd_section
->size
5593 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5598 case lang_reloc_statement_enum
:
5602 s
->reloc_statement
.output_offset
=
5603 dot
- output_section_statement
->bfd_section
->vma
;
5604 s
->reloc_statement
.output_section
=
5605 output_section_statement
->bfd_section
;
5606 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
5607 dot
+= TO_ADDR (size
);
5608 if (!(output_section_statement
->bfd_section
->flags
5610 output_section_statement
->bfd_section
->size
5611 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5615 case lang_wild_statement_enum
:
5616 dot
= lang_size_sections_1 (&s
->wild_statement
.children
.head
,
5617 output_section_statement
,
5618 fill
, dot
, relax
, check_regions
);
5621 case lang_object_symbols_statement_enum
:
5622 link_info
.create_object_symbols_section
=
5623 output_section_statement
->bfd_section
;
5626 case lang_output_statement_enum
:
5627 case lang_target_statement_enum
:
5630 case lang_input_section_enum
:
5634 i
= s
->input_section
.section
;
5639 if (!bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
5640 einfo (_("%F%P: can't relax section: %E\n"));
5644 dot
= size_input_section (prev
, output_section_statement
,
5649 case lang_input_statement_enum
:
5652 case lang_fill_statement_enum
:
5653 s
->fill_statement
.output_section
=
5654 output_section_statement
->bfd_section
;
5656 fill
= s
->fill_statement
.fill
;
5659 case lang_assignment_statement_enum
:
5661 bfd_vma newdot
= dot
;
5662 etree_type
*tree
= s
->assignment_statement
.exp
;
5664 expld
.dataseg
.relro
= exp_seg_relro_none
;
5666 exp_fold_tree (tree
,
5667 output_section_statement
->bfd_section
,
5670 ldlang_check_relro_region (s
, &expld
.dataseg
);
5672 expld
.dataseg
.relro
= exp_seg_relro_none
;
5674 /* This symbol may be relative to this section. */
5675 if ((tree
->type
.node_class
== etree_provided
5676 || tree
->type
.node_class
== etree_assign
)
5677 && (tree
->assign
.dst
[0] != '.'
5678 || tree
->assign
.dst
[1] != '\0'))
5679 output_section_statement
->update_dot
= 1;
5681 if (!output_section_statement
->ignored
)
5683 if (output_section_statement
== abs_output_section
)
5685 /* If we don't have an output section, then just adjust
5686 the default memory address. */
5687 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
5688 FALSE
)->current
= newdot
;
5690 else if (newdot
!= dot
)
5692 /* Insert a pad after this statement. We can't
5693 put the pad before when relaxing, in case the
5694 assignment references dot. */
5695 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
5696 output_section_statement
->bfd_section
, dot
);
5698 /* Don't neuter the pad below when relaxing. */
5701 /* If dot is advanced, this implies that the section
5702 should have space allocated to it, unless the
5703 user has explicitly stated that the section
5704 should not be allocated. */
5705 if (output_section_statement
->sectype
!= noalloc_section
5706 && (output_section_statement
->sectype
!= noload_section
5707 || (bfd_get_flavour (link_info
.output_bfd
)
5708 == bfd_target_elf_flavour
)))
5709 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
5716 case lang_padding_statement_enum
:
5717 /* If this is the first time lang_size_sections is called,
5718 we won't have any padding statements. If this is the
5719 second or later passes when relaxing, we should allow
5720 padding to shrink. If padding is needed on this pass, it
5721 will be added back in. */
5722 s
->padding_statement
.size
= 0;
5724 /* Make sure output_offset is valid. If relaxation shrinks
5725 the section and this pad isn't needed, it's possible to
5726 have output_offset larger than the final size of the
5727 section. bfd_set_section_contents will complain even for
5728 a pad size of zero. */
5729 s
->padding_statement
.output_offset
5730 = dot
- output_section_statement
->bfd_section
->vma
;
5733 case lang_group_statement_enum
:
5734 dot
= lang_size_sections_1 (&s
->group_statement
.children
.head
,
5735 output_section_statement
,
5736 fill
, dot
, relax
, check_regions
);
5739 case lang_insert_statement_enum
:
5742 /* We can only get here when relaxing is turned on. */
5743 case lang_address_statement_enum
:
5750 prev
= &s
->header
.next
;
5755 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
5756 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
5757 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
5758 segments. We are allowed an opportunity to override this decision. */
5761 ldlang_override_segment_assignment (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5762 bfd
*abfd ATTRIBUTE_UNUSED
,
5763 asection
*current_section
,
5764 asection
*previous_section
,
5765 bfd_boolean new_segment
)
5767 lang_output_section_statement_type
*cur
;
5768 lang_output_section_statement_type
*prev
;
5770 /* The checks below are only necessary when the BFD library has decided
5771 that the two sections ought to be placed into the same segment. */
5775 /* Paranoia checks. */
5776 if (current_section
== NULL
|| previous_section
== NULL
)
5779 /* If this flag is set, the target never wants code and non-code
5780 sections comingled in the same segment. */
5781 if (config
.separate_code
5782 && ((current_section
->flags
^ previous_section
->flags
) & SEC_CODE
))
5785 /* Find the memory regions associated with the two sections.
5786 We call lang_output_section_find() here rather than scanning the list
5787 of output sections looking for a matching section pointer because if
5788 we have a large number of sections then a hash lookup is faster. */
5789 cur
= lang_output_section_find (current_section
->name
);
5790 prev
= lang_output_section_find (previous_section
->name
);
5792 /* More paranoia. */
5793 if (cur
== NULL
|| prev
== NULL
)
5796 /* If the regions are different then force the sections to live in
5797 different segments. See the email thread starting at the following
5798 URL for the reasons why this is necessary:
5799 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
5800 return cur
->region
!= prev
->region
;
5804 one_lang_size_sections_pass (bfd_boolean
*relax
, bfd_boolean check_regions
)
5806 lang_statement_iteration
++;
5807 lang_size_sections_1 (&statement_list
.head
, abs_output_section
,
5808 0, 0, relax
, check_regions
);
5812 lang_size_segment (seg_align_type
*seg
)
5814 /* If XXX_SEGMENT_ALIGN XXX_SEGMENT_END pair was seen, check whether
5815 a page could be saved in the data segment. */
5816 bfd_vma first
, last
;
5818 first
= -seg
->base
& (seg
->pagesize
- 1);
5819 last
= seg
->end
& (seg
->pagesize
- 1);
5821 && ((seg
->base
& ~(seg
->pagesize
- 1))
5822 != (seg
->end
& ~(seg
->pagesize
- 1)))
5823 && first
+ last
<= seg
->pagesize
)
5825 seg
->phase
= exp_seg_adjust
;
5829 seg
->phase
= exp_seg_done
;
5834 lang_size_relro_segment_1 (seg_align_type
*seg
)
5836 bfd_vma relro_end
, desired_end
;
5839 /* Compute the expected PT_GNU_RELRO/PT_LOAD segment end. */
5840 relro_end
= ((seg
->relro_end
+ seg
->pagesize
- 1)
5841 & ~(seg
->pagesize
- 1));
5843 /* Adjust by the offset arg of XXX_SEGMENT_RELRO_END. */
5844 desired_end
= relro_end
- seg
->relro_offset
;
5846 /* For sections in the relro segment.. */
5847 for (sec
= link_info
.output_bfd
->section_last
; sec
; sec
= sec
->prev
)
5848 if ((sec
->flags
& SEC_ALLOC
) != 0
5849 && sec
->vma
>= seg
->base
5850 && sec
->vma
< seg
->relro_end
- seg
->relro_offset
)
5852 /* Where do we want to put this section so that it ends as
5854 bfd_vma start
, end
, bump
;
5856 end
= start
= sec
->vma
;
5858 end
+= TO_ADDR (sec
->size
);
5859 bump
= desired_end
- end
;
5860 /* We'd like to increase START by BUMP, but we must heed
5861 alignment so the increase might be less than optimum. */
5863 start
&= ~(((bfd_vma
) 1 << sec
->alignment_power
) - 1);
5864 /* This is now the desired end for the previous section. */
5865 desired_end
= start
;
5868 seg
->phase
= exp_seg_relro_adjust
;
5869 ASSERT (desired_end
>= seg
->base
);
5870 seg
->base
= desired_end
;
5875 lang_size_relro_segment (bfd_boolean
*relax
, bfd_boolean check_regions
)
5877 bfd_boolean do_reset
= FALSE
;
5878 bfd_boolean do_data_relro
;
5879 bfd_vma data_initial_base
, data_relro_end
;
5881 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
5883 do_data_relro
= TRUE
;
5884 data_initial_base
= expld
.dataseg
.base
;
5885 data_relro_end
= lang_size_relro_segment_1 (&expld
.dataseg
);
5889 do_data_relro
= FALSE
;
5890 data_initial_base
= data_relro_end
= 0;
5895 lang_reset_memory_regions ();
5896 one_lang_size_sections_pass (relax
, check_regions
);
5898 /* Assignments to dot, or to output section address in a user
5899 script have increased padding over the original. Revert. */
5900 if (do_data_relro
&& expld
.dataseg
.relro_end
> data_relro_end
)
5902 expld
.dataseg
.base
= data_initial_base
;;
5907 if (!do_data_relro
&& lang_size_segment (&expld
.dataseg
))
5914 lang_size_sections (bfd_boolean
*relax
, bfd_boolean check_regions
)
5916 expld
.phase
= lang_allocating_phase_enum
;
5917 expld
.dataseg
.phase
= exp_seg_none
;
5919 one_lang_size_sections_pass (relax
, check_regions
);
5921 if (expld
.dataseg
.phase
!= exp_seg_end_seen
)
5922 expld
.dataseg
.phase
= exp_seg_done
;
5924 if (expld
.dataseg
.phase
== exp_seg_end_seen
)
5926 bfd_boolean do_reset
5927 = lang_size_relro_segment (relax
, check_regions
);
5931 lang_reset_memory_regions ();
5932 one_lang_size_sections_pass (relax
, check_regions
);
5935 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
5937 link_info
.relro_start
= expld
.dataseg
.base
;
5938 link_info
.relro_end
= expld
.dataseg
.relro_end
;
5943 static lang_output_section_statement_type
*current_section
;
5944 static lang_assignment_statement_type
*current_assign
;
5945 static bfd_boolean prefer_next_section
;
5947 /* Worker function for lang_do_assignments. Recursiveness goes here. */
5950 lang_do_assignments_1 (lang_statement_union_type
*s
,
5951 lang_output_section_statement_type
*current_os
,
5954 bfd_boolean
*found_end
)
5956 for (; s
!= NULL
; s
= s
->header
.next
)
5958 switch (s
->header
.type
)
5960 case lang_constructors_statement_enum
:
5961 dot
= lang_do_assignments_1 (constructor_list
.head
,
5962 current_os
, fill
, dot
, found_end
);
5965 case lang_output_section_statement_enum
:
5967 lang_output_section_statement_type
*os
;
5970 os
= &(s
->output_section_statement
);
5971 os
->after_end
= *found_end
;
5972 if (os
->bfd_section
!= NULL
&& !os
->ignored
)
5974 if ((os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5976 current_section
= os
;
5977 prefer_next_section
= FALSE
;
5979 dot
= os
->bfd_section
->vma
;
5981 newdot
= lang_do_assignments_1 (os
->children
.head
,
5982 os
, os
->fill
, dot
, found_end
);
5985 if (os
->bfd_section
!= NULL
)
5987 /* .tbss sections effectively have zero size. */
5988 if (!IS_TBSS (os
->bfd_section
)
5989 || bfd_link_relocatable (&link_info
))
5990 dot
+= TO_ADDR (os
->bfd_section
->size
);
5992 if (os
->update_dot_tree
!= NULL
)
5993 exp_fold_tree (os
->update_dot_tree
,
5994 bfd_abs_section_ptr
, &dot
);
6002 case lang_wild_statement_enum
:
6004 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
6005 current_os
, fill
, dot
, found_end
);
6008 case lang_object_symbols_statement_enum
:
6009 case lang_output_statement_enum
:
6010 case lang_target_statement_enum
:
6013 case lang_data_statement_enum
:
6014 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
6015 if (expld
.result
.valid_p
)
6017 s
->data_statement
.value
= expld
.result
.value
;
6018 if (expld
.result
.section
!= NULL
)
6019 s
->data_statement
.value
+= expld
.result
.section
->vma
;
6021 else if (expld
.phase
== lang_final_phase_enum
)
6022 einfo (_("%F%P: invalid data statement\n"));
6025 switch (s
->data_statement
.type
)
6043 if (size
< TO_SIZE ((unsigned) 1))
6044 size
= TO_SIZE ((unsigned) 1);
6045 dot
+= TO_ADDR (size
);
6049 case lang_reloc_statement_enum
:
6050 exp_fold_tree (s
->reloc_statement
.addend_exp
,
6051 bfd_abs_section_ptr
, &dot
);
6052 if (expld
.result
.valid_p
)
6053 s
->reloc_statement
.addend_value
= expld
.result
.value
;
6054 else if (expld
.phase
== lang_final_phase_enum
)
6055 einfo (_("%F%P: invalid reloc statement\n"));
6056 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
6059 case lang_input_section_enum
:
6061 asection
*in
= s
->input_section
.section
;
6063 if ((in
->flags
& SEC_EXCLUDE
) == 0)
6064 dot
+= TO_ADDR (in
->size
);
6068 case lang_input_statement_enum
:
6071 case lang_fill_statement_enum
:
6072 fill
= s
->fill_statement
.fill
;
6075 case lang_assignment_statement_enum
:
6076 current_assign
= &s
->assignment_statement
;
6077 if (current_assign
->exp
->type
.node_class
!= etree_assert
)
6079 const char *p
= current_assign
->exp
->assign
.dst
;
6081 if (current_os
== abs_output_section
&& p
[0] == '.' && p
[1] == 0)
6082 prefer_next_section
= TRUE
;
6086 if (strcmp (p
, "end") == 0)
6089 exp_fold_tree (s
->assignment_statement
.exp
,
6090 (current_os
->bfd_section
!= NULL
6091 ? current_os
->bfd_section
: bfd_und_section_ptr
),
6095 case lang_padding_statement_enum
:
6096 dot
+= TO_ADDR (s
->padding_statement
.size
);
6099 case lang_group_statement_enum
:
6100 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
6101 current_os
, fill
, dot
, found_end
);
6104 case lang_insert_statement_enum
:
6107 case lang_address_statement_enum
:
6119 lang_do_assignments (lang_phase_type phase
)
6121 bfd_boolean found_end
= FALSE
;
6123 current_section
= NULL
;
6124 prefer_next_section
= FALSE
;
6125 expld
.phase
= phase
;
6126 lang_statement_iteration
++;
6127 lang_do_assignments_1 (statement_list
.head
,
6128 abs_output_section
, NULL
, 0, &found_end
);
6131 /* For an assignment statement outside of an output section statement,
6132 choose the best of neighbouring output sections to use for values
6136 section_for_dot (void)
6140 /* Assignments belong to the previous output section, unless there
6141 has been an assignment to "dot", in which case following
6142 assignments belong to the next output section. (The assumption
6143 is that an assignment to "dot" is setting up the address for the
6144 next output section.) Except that past the assignment to "_end"
6145 we always associate with the previous section. This exception is
6146 for targets like SH that define an alloc .stack or other
6147 weirdness after non-alloc sections. */
6148 if (current_section
== NULL
|| prefer_next_section
)
6150 lang_statement_union_type
*stmt
;
6151 lang_output_section_statement_type
*os
;
6153 for (stmt
= (lang_statement_union_type
*) current_assign
;
6155 stmt
= stmt
->header
.next
)
6156 if (stmt
->header
.type
== lang_output_section_statement_enum
)
6159 os
= &stmt
->output_section_statement
;
6162 && (os
->bfd_section
== NULL
6163 || (os
->bfd_section
->flags
& SEC_EXCLUDE
) != 0
6164 || bfd_section_removed_from_list (link_info
.output_bfd
,
6168 if (current_section
== NULL
|| os
== NULL
|| !os
->after_end
)
6171 s
= os
->bfd_section
;
6173 s
= link_info
.output_bfd
->section_last
;
6175 && ((s
->flags
& SEC_ALLOC
) == 0
6176 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6181 return bfd_abs_section_ptr
;
6185 s
= current_section
->bfd_section
;
6187 /* The section may have been stripped. */
6189 && ((s
->flags
& SEC_EXCLUDE
) != 0
6190 || (s
->flags
& SEC_ALLOC
) == 0
6191 || (s
->flags
& SEC_THREAD_LOCAL
) != 0
6192 || bfd_section_removed_from_list (link_info
.output_bfd
, s
)))
6195 s
= link_info
.output_bfd
->sections
;
6197 && ((s
->flags
& SEC_ALLOC
) == 0
6198 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6203 return bfd_abs_section_ptr
;
6206 /* Array of __start/__stop/.startof./.sizeof/ symbols. */
6208 static struct bfd_link_hash_entry
**start_stop_syms
;
6209 static size_t start_stop_count
= 0;
6210 static size_t start_stop_alloc
= 0;
6212 /* Give start/stop SYMBOL for SEC a preliminary definition, and add it
6213 to start_stop_syms. */
6216 lang_define_start_stop (const char *symbol
, asection
*sec
)
6218 struct bfd_link_hash_entry
*h
;
6220 h
= bfd_define_start_stop (link_info
.output_bfd
, &link_info
, symbol
, sec
);
6223 if (start_stop_count
== start_stop_alloc
)
6225 start_stop_alloc
= 2 * start_stop_alloc
+ 10;
6227 = xrealloc (start_stop_syms
,
6228 start_stop_alloc
* sizeof (*start_stop_syms
));
6230 start_stop_syms
[start_stop_count
++] = h
;
6234 /* Check for input sections whose names match references to
6235 __start_SECNAME or __stop_SECNAME symbols. Give the symbols
6236 preliminary definitions. */
6239 lang_init_start_stop (void)
6243 char leading_char
= bfd_get_symbol_leading_char (link_info
.output_bfd
);
6245 for (abfd
= link_info
.input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6246 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6249 const char *secname
= s
->name
;
6251 for (ps
= secname
; *ps
!= '\0'; ps
++)
6252 if (!ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
6256 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6258 symbol
[0] = leading_char
;
6259 sprintf (symbol
+ (leading_char
!= 0), "__start_%s", secname
);
6260 lang_define_start_stop (symbol
, s
);
6262 symbol
[1] = leading_char
;
6263 memcpy (symbol
+ 1 + (leading_char
!= 0), "__stop", 6);
6264 lang_define_start_stop (symbol
+ 1, s
);
6271 /* Iterate over start_stop_syms. */
6274 foreach_start_stop (void (*func
) (struct bfd_link_hash_entry
*))
6278 for (i
= 0; i
< start_stop_count
; ++i
)
6279 func (start_stop_syms
[i
]);
6282 /* __start and __stop symbols are only supposed to be defined by the
6283 linker for orphan sections, but we now extend that to sections that
6284 map to an output section of the same name. The symbols were
6285 defined early for --gc-sections, before we mapped input to output
6286 sections, so undo those that don't satisfy this rule. */
6289 undef_start_stop (struct bfd_link_hash_entry
*h
)
6291 if (h
->ldscript_def
)
6294 if (h
->u
.def
.section
->output_section
== NULL
6295 || h
->u
.def
.section
->output_section
->owner
!= link_info
.output_bfd
6296 || strcmp (h
->u
.def
.section
->name
,
6297 h
->u
.def
.section
->output_section
->name
) != 0)
6299 asection
*sec
= bfd_get_section_by_name (link_info
.output_bfd
,
6300 h
->u
.def
.section
->name
);
6303 /* When there are more than one input sections with the same
6304 section name, SECNAME, linker picks the first one to define
6305 __start_SECNAME and __stop_SECNAME symbols. When the first
6306 input section is removed by comdat group, we need to check
6307 if there is still an output section with section name
6310 for (i
= sec
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
6311 if (strcmp (h
->u
.def
.section
->name
, i
->name
) == 0)
6313 h
->u
.def
.section
= i
;
6317 h
->type
= bfd_link_hash_undefined
;
6318 h
->u
.undef
.abfd
= NULL
;
6323 lang_undef_start_stop (void)
6325 foreach_start_stop (undef_start_stop
);
6328 /* Check for output sections whose names match references to
6329 .startof.SECNAME or .sizeof.SECNAME symbols. Give the symbols
6330 preliminary definitions. */
6333 lang_init_startof_sizeof (void)
6337 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6339 const char *secname
= s
->name
;
6340 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6342 sprintf (symbol
, ".startof.%s", secname
);
6343 lang_define_start_stop (symbol
, s
);
6345 memcpy (symbol
+ 1, ".size", 5);
6346 lang_define_start_stop (symbol
+ 1, s
);
6351 /* Set .startof., .sizeof., __start and __stop symbols final values. */
6354 set_start_stop (struct bfd_link_hash_entry
*h
)
6357 || h
->type
!= bfd_link_hash_defined
)
6360 if (h
->root
.string
[0] == '.')
6362 /* .startof. or .sizeof. symbol.
6363 .startof. already has final value. */
6364 if (h
->root
.string
[2] == 'i')
6367 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6368 h
->u
.def
.section
= bfd_abs_section_ptr
;
6373 /* __start or __stop symbol. */
6374 int has_lead
= bfd_get_symbol_leading_char (link_info
.output_bfd
) != 0;
6376 h
->u
.def
.section
= h
->u
.def
.section
->output_section
;
6377 if (h
->root
.string
[4 + has_lead
] == 'o')
6380 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6386 lang_finalize_start_stop (void)
6388 foreach_start_stop (set_start_stop
);
6394 struct bfd_link_hash_entry
*h
;
6397 if ((bfd_link_relocatable (&link_info
) && !link_info
.gc_sections
)
6398 || bfd_link_dll (&link_info
))
6399 warn
= entry_from_cmdline
;
6403 /* Force the user to specify a root when generating a relocatable with
6404 --gc-sections, unless --gc-keep-exported was also given. */
6405 if (bfd_link_relocatable (&link_info
)
6406 && link_info
.gc_sections
6407 && !link_info
.gc_keep_exported
6408 && !(entry_from_cmdline
|| undef_from_cmdline
))
6409 einfo (_("%F%P: gc-sections requires either an entry or "
6410 "an undefined symbol\n"));
6412 if (entry_symbol
.name
== NULL
)
6414 /* No entry has been specified. Look for the default entry, but
6415 don't warn if we don't find it. */
6416 entry_symbol
.name
= entry_symbol_default
;
6420 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
6421 FALSE
, FALSE
, TRUE
);
6423 && (h
->type
== bfd_link_hash_defined
6424 || h
->type
== bfd_link_hash_defweak
)
6425 && h
->u
.def
.section
->output_section
!= NULL
)
6429 val
= (h
->u
.def
.value
6430 + bfd_get_section_vma (link_info
.output_bfd
,
6431 h
->u
.def
.section
->output_section
)
6432 + h
->u
.def
.section
->output_offset
);
6433 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6434 einfo (_("%F%P: %s: can't set start address\n"), entry_symbol
.name
);
6441 /* We couldn't find the entry symbol. Try parsing it as a
6443 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
6446 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6447 einfo (_("%F%P: can't set start address\n"));
6453 /* Can't find the entry symbol, and it's not a number. Use
6454 the first address in the text section. */
6455 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
6459 einfo (_("%P: warning: cannot find entry symbol %s;"
6460 " defaulting to %V\n"),
6462 bfd_get_section_vma (link_info
.output_bfd
, ts
));
6463 if (!(bfd_set_start_address
6464 (link_info
.output_bfd
,
6465 bfd_get_section_vma (link_info
.output_bfd
, ts
))))
6466 einfo (_("%F%P: can't set start address\n"));
6471 einfo (_("%P: warning: cannot find entry symbol %s;"
6472 " not setting start address\n"),
6479 /* This is a small function used when we want to ignore errors from
6483 ignore_bfd_errors (const char *fmt ATTRIBUTE_UNUSED
,
6484 va_list ap ATTRIBUTE_UNUSED
)
6486 /* Don't do anything. */
6489 /* Check that the architecture of all the input files is compatible
6490 with the output file. Also call the backend to let it do any
6491 other checking that is needed. */
6496 lang_statement_union_type
*file
;
6498 const bfd_arch_info_type
*compatible
;
6500 for (file
= file_chain
.head
; file
!= NULL
; file
= file
->input_statement
.next
)
6502 #ifdef ENABLE_PLUGINS
6503 /* Don't check format of files claimed by plugin. */
6504 if (file
->input_statement
.flags
.claimed
)
6506 #endif /* ENABLE_PLUGINS */
6507 input_bfd
= file
->input_statement
.the_bfd
;
6509 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
6510 command_line
.accept_unknown_input_arch
);
6512 /* In general it is not possible to perform a relocatable
6513 link between differing object formats when the input
6514 file has relocations, because the relocations in the
6515 input format may not have equivalent representations in
6516 the output format (and besides BFD does not translate
6517 relocs for other link purposes than a final link). */
6518 if ((bfd_link_relocatable (&link_info
)
6519 || link_info
.emitrelocations
)
6520 && (compatible
== NULL
6521 || (bfd_get_flavour (input_bfd
)
6522 != bfd_get_flavour (link_info
.output_bfd
)))
6523 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
6525 einfo (_("%F%P: relocatable linking with relocations from"
6526 " format %s (%pB) to format %s (%pB) is not supported\n"),
6527 bfd_get_target (input_bfd
), input_bfd
,
6528 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
6529 /* einfo with %F exits. */
6532 if (compatible
== NULL
)
6534 if (command_line
.warn_mismatch
)
6535 einfo (_("%X%P: %s architecture of input file `%pB'"
6536 " is incompatible with %s output\n"),
6537 bfd_printable_name (input_bfd
), input_bfd
,
6538 bfd_printable_name (link_info
.output_bfd
));
6540 else if (bfd_count_sections (input_bfd
))
6542 /* If the input bfd has no contents, it shouldn't set the
6543 private data of the output bfd. */
6545 bfd_error_handler_type pfn
= NULL
;
6547 /* If we aren't supposed to warn about mismatched input
6548 files, temporarily set the BFD error handler to a
6549 function which will do nothing. We still want to call
6550 bfd_merge_private_bfd_data, since it may set up
6551 information which is needed in the output file. */
6552 if (!command_line
.warn_mismatch
)
6553 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
6554 if (!bfd_merge_private_bfd_data (input_bfd
, &link_info
))
6556 if (command_line
.warn_mismatch
)
6557 einfo (_("%X%P: failed to merge target specific data"
6558 " of file %pB\n"), input_bfd
);
6560 if (!command_line
.warn_mismatch
)
6561 bfd_set_error_handler (pfn
);
6566 /* Look through all the global common symbols and attach them to the
6567 correct section. The -sort-common command line switch may be used
6568 to roughly sort the entries by alignment. */
6573 if (link_info
.inhibit_common_definition
)
6575 if (bfd_link_relocatable (&link_info
)
6576 && !command_line
.force_common_definition
)
6579 if (!config
.sort_common
)
6580 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
6585 if (config
.sort_common
== sort_descending
)
6587 for (power
= 4; power
> 0; power
--)
6588 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6591 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6595 for (power
= 0; power
<= 4; power
++)
6596 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6598 power
= (unsigned int) -1;
6599 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6604 /* Place one common symbol in the correct section. */
6607 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
6609 unsigned int power_of_two
;
6613 if (h
->type
!= bfd_link_hash_common
)
6617 power_of_two
= h
->u
.c
.p
->alignment_power
;
6619 if (config
.sort_common
== sort_descending
6620 && power_of_two
< *(unsigned int *) info
)
6622 else if (config
.sort_common
== sort_ascending
6623 && power_of_two
> *(unsigned int *) info
)
6626 section
= h
->u
.c
.p
->section
;
6627 if (!bfd_define_common_symbol (link_info
.output_bfd
, &link_info
, h
))
6628 einfo (_("%F%P: could not define common symbol `%pT': %E\n"),
6631 if (config
.map_file
!= NULL
)
6633 static bfd_boolean header_printed
;
6638 if (!header_printed
)
6640 minfo (_("\nAllocating common symbols\n"));
6641 minfo (_("Common symbol size file\n\n"));
6642 header_printed
= TRUE
;
6645 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
6646 DMGL_ANSI
| DMGL_PARAMS
);
6649 minfo ("%s", h
->root
.string
);
6650 len
= strlen (h
->root
.string
);
6655 len
= strlen (name
);
6671 if (size
<= 0xffffffff)
6672 sprintf (buf
, "%lx", (unsigned long) size
);
6674 sprintf_vma (buf
, size
);
6684 minfo ("%pB\n", section
->owner
);
6690 /* Handle a single orphan section S, placing the orphan into an appropriate
6691 output section. The effects of the --orphan-handling command line
6692 option are handled here. */
6695 ldlang_place_orphan (asection
*s
)
6697 if (config
.orphan_handling
== orphan_handling_discard
)
6699 lang_output_section_statement_type
*os
;
6700 os
= lang_output_section_statement_lookup (DISCARD_SECTION_NAME
, 0,
6702 if (os
->addr_tree
== NULL
6703 && (bfd_link_relocatable (&link_info
)
6704 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6705 os
->addr_tree
= exp_intop (0);
6706 lang_add_section (&os
->children
, s
, NULL
, os
);
6710 lang_output_section_statement_type
*os
;
6711 const char *name
= s
->name
;
6714 if (config
.orphan_handling
== orphan_handling_error
)
6715 einfo (_("%X%P: error: unplaced orphan section `%pA' from `%pB'\n"),
6718 if (config
.unique_orphan_sections
|| unique_section_p (s
, NULL
))
6719 constraint
= SPECIAL
;
6721 os
= ldemul_place_orphan (s
, name
, constraint
);
6724 os
= lang_output_section_statement_lookup (name
, constraint
, TRUE
);
6725 if (os
->addr_tree
== NULL
6726 && (bfd_link_relocatable (&link_info
)
6727 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6728 os
->addr_tree
= exp_intop (0);
6729 lang_add_section (&os
->children
, s
, NULL
, os
);
6732 if (config
.orphan_handling
== orphan_handling_warn
)
6733 einfo (_("%P: warning: orphan section `%pA' from `%pB' being "
6734 "placed in section `%s'\n"),
6735 s
, s
->owner
, os
->name
);
6739 /* Run through the input files and ensure that every input section has
6740 somewhere to go. If one is found without a destination then create
6741 an input request and place it into the statement tree. */
6744 lang_place_orphans (void)
6746 LANG_FOR_EACH_INPUT_STATEMENT (file
)
6750 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6752 if (s
->output_section
== NULL
)
6754 /* This section of the file is not attached, root
6755 around for a sensible place for it to go. */
6757 if (file
->flags
.just_syms
)
6758 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
6759 else if (lang_discard_section_p (s
))
6760 s
->output_section
= bfd_abs_section_ptr
;
6761 else if (strcmp (s
->name
, "COMMON") == 0)
6763 /* This is a lonely common section which must have
6764 come from an archive. We attach to the section
6765 with the wildcard. */
6766 if (!bfd_link_relocatable (&link_info
)
6767 || command_line
.force_common_definition
)
6769 if (default_common_section
== NULL
)
6770 default_common_section
6771 = lang_output_section_statement_lookup (".bss", 0,
6773 lang_add_section (&default_common_section
->children
, s
,
6774 NULL
, default_common_section
);
6778 ldlang_place_orphan (s
);
6785 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
6787 flagword
*ptr_flags
;
6789 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
6795 /* PR 17900: An exclamation mark in the attributes reverses
6796 the sense of any of the attributes that follow. */
6799 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
6803 *ptr_flags
|= SEC_ALLOC
;
6807 *ptr_flags
|= SEC_READONLY
;
6811 *ptr_flags
|= SEC_DATA
;
6815 *ptr_flags
|= SEC_CODE
;
6820 *ptr_flags
|= SEC_LOAD
;
6824 einfo (_("%F%P: invalid character %c (%d) in flags\n"),
6832 /* Call a function on each input file. This function will be called
6833 on an archive, but not on the elements. */
6836 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
6838 lang_input_statement_type
*f
;
6840 for (f
= &input_file_chain
.head
->input_statement
;
6842 f
= &f
->next_real_file
->input_statement
)
6846 /* Call a function on each file. The function will be called on all
6847 the elements of an archive which are included in the link, but will
6848 not be called on the archive file itself. */
6851 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
6853 LANG_FOR_EACH_INPUT_STATEMENT (f
)
6860 ldlang_add_file (lang_input_statement_type
*entry
)
6862 lang_statement_append (&file_chain
,
6863 (lang_statement_union_type
*) entry
,
6866 /* The BFD linker needs to have a list of all input BFDs involved in
6868 ASSERT (entry
->the_bfd
->link
.next
== NULL
);
6869 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
6871 *link_info
.input_bfds_tail
= entry
->the_bfd
;
6872 link_info
.input_bfds_tail
= &entry
->the_bfd
->link
.next
;
6873 entry
->the_bfd
->usrdata
= entry
;
6874 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
6876 /* Look through the sections and check for any which should not be
6877 included in the link. We need to do this now, so that we can
6878 notice when the backend linker tries to report multiple
6879 definition errors for symbols which are in sections we aren't
6880 going to link. FIXME: It might be better to entirely ignore
6881 symbols which are defined in sections which are going to be
6882 discarded. This would require modifying the backend linker for
6883 each backend which might set the SEC_LINK_ONCE flag. If we do
6884 this, we should probably handle SEC_EXCLUDE in the same way. */
6886 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
6890 lang_add_output (const char *name
, int from_script
)
6892 /* Make -o on command line override OUTPUT in script. */
6893 if (!had_output_filename
|| !from_script
)
6895 output_filename
= name
;
6896 had_output_filename
= TRUE
;
6900 lang_output_section_statement_type
*
6901 lang_enter_output_section_statement (const char *output_section_statement_name
,
6902 etree_type
*address_exp
,
6903 enum section_type sectype
,
6905 etree_type
*subalign
,
6908 int align_with_input
)
6910 lang_output_section_statement_type
*os
;
6912 os
= lang_output_section_statement_lookup (output_section_statement_name
,
6914 current_section
= os
;
6916 if (os
->addr_tree
== NULL
)
6918 os
->addr_tree
= address_exp
;
6920 os
->sectype
= sectype
;
6921 if (sectype
!= noload_section
)
6922 os
->flags
= SEC_NO_FLAGS
;
6924 os
->flags
= SEC_NEVER_LOAD
;
6925 os
->block_value
= 1;
6927 /* Make next things chain into subchain of this. */
6928 push_stat_ptr (&os
->children
);
6930 os
->align_lma_with_input
= align_with_input
== ALIGN_WITH_INPUT
;
6931 if (os
->align_lma_with_input
&& align
!= NULL
)
6932 einfo (_("%F%P:%pS: error: align with input and explicit align specified\n"),
6935 os
->subsection_alignment
= subalign
;
6936 os
->section_alignment
= align
;
6938 os
->load_base
= ebase
;
6945 lang_output_statement_type
*new_stmt
;
6947 new_stmt
= new_stat (lang_output_statement
, stat_ptr
);
6948 new_stmt
->name
= output_filename
;
6951 /* Reset the current counters in the regions. */
6954 lang_reset_memory_regions (void)
6956 lang_memory_region_type
*p
= lang_memory_region_list
;
6958 lang_output_section_statement_type
*os
;
6960 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
6962 p
->current
= p
->origin
;
6966 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
6970 os
->processed_vma
= FALSE
;
6971 os
->processed_lma
= FALSE
;
6974 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6976 /* Save the last size for possible use by bfd_relax_section. */
6977 o
->rawsize
= o
->size
;
6978 if (!(o
->flags
& SEC_FIXED_SIZE
))
6983 /* Worker for lang_gc_sections_1. */
6986 gc_section_callback (lang_wild_statement_type
*ptr
,
6987 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
6989 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
6990 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
6991 void *data ATTRIBUTE_UNUSED
)
6993 /* If the wild pattern was marked KEEP, the member sections
6994 should be as well. */
6995 if (ptr
->keep_sections
)
6996 section
->flags
|= SEC_KEEP
;
6999 /* Iterate over sections marking them against GC. */
7002 lang_gc_sections_1 (lang_statement_union_type
*s
)
7004 for (; s
!= NULL
; s
= s
->header
.next
)
7006 switch (s
->header
.type
)
7008 case lang_wild_statement_enum
:
7009 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
7011 case lang_constructors_statement_enum
:
7012 lang_gc_sections_1 (constructor_list
.head
);
7014 case lang_output_section_statement_enum
:
7015 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
7017 case lang_group_statement_enum
:
7018 lang_gc_sections_1 (s
->group_statement
.children
.head
);
7027 lang_gc_sections (void)
7029 /* Keep all sections so marked in the link script. */
7030 lang_gc_sections_1 (statement_list
.head
);
7032 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
7033 the special case of debug info. (See bfd/stabs.c)
7034 Twiddle the flag here, to simplify later linker code. */
7035 if (bfd_link_relocatable (&link_info
))
7037 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7040 #ifdef ENABLE_PLUGINS
7041 if (f
->flags
.claimed
)
7044 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7045 if ((sec
->flags
& SEC_DEBUGGING
) == 0)
7046 sec
->flags
&= ~SEC_EXCLUDE
;
7050 if (link_info
.gc_sections
)
7051 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
7054 /* Worker for lang_find_relro_sections_1. */
7057 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
7058 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7060 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
7061 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7064 /* Discarded, excluded and ignored sections effectively have zero
7066 if (section
->output_section
!= NULL
7067 && section
->output_section
->owner
== link_info
.output_bfd
7068 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
7069 && !IGNORE_SECTION (section
)
7070 && section
->size
!= 0)
7072 bfd_boolean
*has_relro_section
= (bfd_boolean
*) data
;
7073 *has_relro_section
= TRUE
;
7077 /* Iterate over sections for relro sections. */
7080 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
7081 seg_align_type
*seg
,
7082 bfd_boolean
*has_relro_section
)
7084 if (*has_relro_section
)
7087 for (; s
!= NULL
; s
= s
->header
.next
)
7089 if (s
== seg
->relro_end_stat
)
7092 switch (s
->header
.type
)
7094 case lang_wild_statement_enum
:
7095 walk_wild (&s
->wild_statement
,
7096 find_relro_section_callback
,
7099 case lang_constructors_statement_enum
:
7100 lang_find_relro_sections_1 (constructor_list
.head
,
7101 seg
, has_relro_section
);
7103 case lang_output_section_statement_enum
:
7104 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
7105 seg
, has_relro_section
);
7107 case lang_group_statement_enum
:
7108 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
7109 seg
, has_relro_section
);
7118 lang_find_relro_sections (void)
7120 bfd_boolean has_relro_section
= FALSE
;
7122 /* Check all sections in the link script. */
7124 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
7125 &expld
.dataseg
, &has_relro_section
);
7127 if (!has_relro_section
)
7128 link_info
.relro
= FALSE
;
7131 /* Relax all sections until bfd_relax_section gives up. */
7134 lang_relax_sections (bfd_boolean need_layout
)
7136 if (RELAXATION_ENABLED
)
7138 /* We may need more than one relaxation pass. */
7139 int i
= link_info
.relax_pass
;
7141 /* The backend can use it to determine the current pass. */
7142 link_info
.relax_pass
= 0;
7146 /* Keep relaxing until bfd_relax_section gives up. */
7147 bfd_boolean relax_again
;
7149 link_info
.relax_trip
= -1;
7152 link_info
.relax_trip
++;
7154 /* Note: pe-dll.c does something like this also. If you find
7155 you need to change this code, you probably need to change
7156 pe-dll.c also. DJ */
7158 /* Do all the assignments with our current guesses as to
7160 lang_do_assignments (lang_assigning_phase_enum
);
7162 /* We must do this after lang_do_assignments, because it uses
7164 lang_reset_memory_regions ();
7166 /* Perform another relax pass - this time we know where the
7167 globals are, so can make a better guess. */
7168 relax_again
= FALSE
;
7169 lang_size_sections (&relax_again
, FALSE
);
7171 while (relax_again
);
7173 link_info
.relax_pass
++;
7180 /* Final extra sizing to report errors. */
7181 lang_do_assignments (lang_assigning_phase_enum
);
7182 lang_reset_memory_regions ();
7183 lang_size_sections (NULL
, TRUE
);
7187 #ifdef ENABLE_PLUGINS
7188 /* Find the insert point for the plugin's replacement files. We
7189 place them after the first claimed real object file, or if the
7190 first claimed object is an archive member, after the last real
7191 object file immediately preceding the archive. In the event
7192 no objects have been claimed at all, we return the first dummy
7193 object file on the list as the insert point; that works, but
7194 the callee must be careful when relinking the file_chain as it
7195 is not actually on that chain, only the statement_list and the
7196 input_file list; in that case, the replacement files must be
7197 inserted at the head of the file_chain. */
7199 static lang_input_statement_type
*
7200 find_replacements_insert_point (void)
7202 lang_input_statement_type
*claim1
, *lastobject
;
7203 lastobject
= &input_file_chain
.head
->input_statement
;
7204 for (claim1
= &file_chain
.head
->input_statement
;
7206 claim1
= &claim1
->next
->input_statement
)
7208 if (claim1
->flags
.claimed
)
7209 return claim1
->flags
.claim_archive
? lastobject
: claim1
;
7210 /* Update lastobject if this is a real object file. */
7211 if (claim1
->the_bfd
!= NULL
&& claim1
->the_bfd
->my_archive
== NULL
)
7212 lastobject
= claim1
;
7214 /* No files were claimed by the plugin. Choose the last object
7215 file found on the list (maybe the first, dummy entry) as the
7220 /* Find where to insert ADD, an archive element or shared library
7221 added during a rescan. */
7223 static lang_statement_union_type
**
7224 find_rescan_insertion (lang_input_statement_type
*add
)
7226 bfd
*add_bfd
= add
->the_bfd
;
7227 lang_input_statement_type
*f
;
7228 lang_input_statement_type
*last_loaded
= NULL
;
7229 lang_input_statement_type
*before
= NULL
;
7230 lang_statement_union_type
**iter
= NULL
;
7232 if (add_bfd
->my_archive
!= NULL
)
7233 add_bfd
= add_bfd
->my_archive
;
7235 /* First look through the input file chain, to find an object file
7236 before the one we've rescanned. Normal object files always
7237 appear on both the input file chain and the file chain, so this
7238 lets us get quickly to somewhere near the correct place on the
7239 file chain if it is full of archive elements. Archives don't
7240 appear on the file chain, but if an element has been extracted
7241 then their input_statement->next points at it. */
7242 for (f
= &input_file_chain
.head
->input_statement
;
7244 f
= &f
->next_real_file
->input_statement
)
7246 if (f
->the_bfd
== add_bfd
)
7248 before
= last_loaded
;
7249 if (f
->next
!= NULL
)
7250 return &f
->next
->input_statement
.next
;
7252 if (f
->the_bfd
!= NULL
&& f
->next
!= NULL
)
7256 for (iter
= before
? &before
->next
: &file_chain
.head
->input_statement
.next
;
7258 iter
= &(*iter
)->input_statement
.next
)
7259 if (!(*iter
)->input_statement
.flags
.claim_archive
7260 && (*iter
)->input_statement
.the_bfd
->my_archive
== NULL
)
7266 /* Insert SRCLIST into DESTLIST after given element by chaining
7267 on FIELD as the next-pointer. (Counterintuitively does not need
7268 a pointer to the actual after-node itself, just its chain field.) */
7271 lang_list_insert_after (lang_statement_list_type
*destlist
,
7272 lang_statement_list_type
*srclist
,
7273 lang_statement_union_type
**field
)
7275 *(srclist
->tail
) = *field
;
7276 *field
= srclist
->head
;
7277 if (destlist
->tail
== field
)
7278 destlist
->tail
= srclist
->tail
;
7281 /* Detach new nodes added to DESTLIST since the time ORIGLIST
7282 was taken as a copy of it and leave them in ORIGLIST. */
7285 lang_list_remove_tail (lang_statement_list_type
*destlist
,
7286 lang_statement_list_type
*origlist
)
7288 union lang_statement_union
**savetail
;
7289 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
7290 ASSERT (origlist
->head
== destlist
->head
);
7291 savetail
= origlist
->tail
;
7292 origlist
->head
= *(savetail
);
7293 origlist
->tail
= destlist
->tail
;
7294 destlist
->tail
= savetail
;
7297 #endif /* ENABLE_PLUGINS */
7299 /* Add NAME to the list of garbage collection entry points. */
7302 lang_add_gc_name (const char *name
)
7304 struct bfd_sym_chain
*sym
;
7309 sym
= (struct bfd_sym_chain
*) stat_alloc (sizeof (*sym
));
7311 sym
->next
= link_info
.gc_sym_list
;
7313 link_info
.gc_sym_list
= sym
;
7316 /* Check relocations. */
7319 lang_check_relocs (void)
7321 if (link_info
.check_relocs_after_open_input
)
7325 for (abfd
= link_info
.input_bfds
;
7326 abfd
!= (bfd
*) NULL
; abfd
= abfd
->link
.next
)
7327 if (!bfd_link_check_relocs (abfd
, &link_info
))
7329 /* No object output, fail return. */
7330 config
.make_executable
= FALSE
;
7331 /* Note: we do not abort the loop, but rather
7332 continue the scan in case there are other
7333 bad relocations to report. */
7338 /* Look through all output sections looking for places where we can
7339 propagate forward the lma region. */
7342 lang_propagate_lma_regions (void)
7344 lang_output_section_statement_type
*os
;
7346 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
7350 if (os
->prev
!= NULL
7351 && os
->lma_region
== NULL
7352 && os
->load_base
== NULL
7353 && os
->addr_tree
== NULL
7354 && os
->region
== os
->prev
->region
)
7355 os
->lma_region
= os
->prev
->lma_region
;
7362 /* Finalize dynamic list. */
7363 if (link_info
.dynamic_list
)
7364 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
7366 current_target
= default_target
;
7368 /* Open the output file. */
7369 lang_for_each_statement (ldlang_open_output
);
7372 ldemul_create_output_section_statements ();
7374 /* Add to the hash table all undefineds on the command line. */
7375 lang_place_undefineds ();
7377 if (!bfd_section_already_linked_table_init ())
7378 einfo (_("%F%P: can not create hash table: %E\n"));
7380 /* Create a bfd for each input file. */
7381 current_target
= default_target
;
7382 lang_statement_iteration
++;
7383 open_input_bfds (statement_list
.head
, OPEN_BFD_NORMAL
);
7384 /* open_input_bfds also handles assignments, so we can give values
7385 to symbolic origin/length now. */
7386 lang_do_memory_regions ();
7388 #ifdef ENABLE_PLUGINS
7389 if (link_info
.lto_plugin_active
)
7391 lang_statement_list_type added
;
7392 lang_statement_list_type files
, inputfiles
;
7394 /* Now all files are read, let the plugin(s) decide if there
7395 are any more to be added to the link before we call the
7396 emulation's after_open hook. We create a private list of
7397 input statements for this purpose, which we will eventually
7398 insert into the global statement list after the first claimed
7401 /* We need to manipulate all three chains in synchrony. */
7403 inputfiles
= input_file_chain
;
7404 if (plugin_call_all_symbols_read ())
7405 einfo (_("%F%P: %s: plugin reported error after all symbols read\n"),
7406 plugin_error_plugin ());
7407 /* Open any newly added files, updating the file chains. */
7408 open_input_bfds (*added
.tail
, OPEN_BFD_NORMAL
);
7409 /* Restore the global list pointer now they have all been added. */
7410 lang_list_remove_tail (stat_ptr
, &added
);
7411 /* And detach the fresh ends of the file lists. */
7412 lang_list_remove_tail (&file_chain
, &files
);
7413 lang_list_remove_tail (&input_file_chain
, &inputfiles
);
7414 /* Were any new files added? */
7415 if (added
.head
!= NULL
)
7417 /* If so, we will insert them into the statement list immediately
7418 after the first input file that was claimed by the plugin. */
7419 plugin_insert
= find_replacements_insert_point ();
7420 /* If a plugin adds input files without having claimed any, we
7421 don't really have a good idea where to place them. Just putting
7422 them at the start or end of the list is liable to leave them
7423 outside the crtbegin...crtend range. */
7424 ASSERT (plugin_insert
!= NULL
);
7425 /* Splice the new statement list into the old one. */
7426 lang_list_insert_after (stat_ptr
, &added
,
7427 &plugin_insert
->header
.next
);
7428 /* Likewise for the file chains. */
7429 lang_list_insert_after (&input_file_chain
, &inputfiles
,
7430 &plugin_insert
->next_real_file
);
7431 /* We must be careful when relinking file_chain; we may need to
7432 insert the new files at the head of the list if the insert
7433 point chosen is the dummy first input file. */
7434 if (plugin_insert
->filename
)
7435 lang_list_insert_after (&file_chain
, &files
, &plugin_insert
->next
);
7437 lang_list_insert_after (&file_chain
, &files
, &file_chain
.head
);
7439 /* Rescan archives in case new undefined symbols have appeared. */
7441 lang_statement_iteration
++;
7442 open_input_bfds (statement_list
.head
, OPEN_BFD_RESCAN
);
7443 lang_list_remove_tail (&file_chain
, &files
);
7444 while (files
.head
!= NULL
)
7446 lang_statement_union_type
**insert
;
7447 lang_statement_union_type
**iter
, *temp
;
7450 insert
= find_rescan_insertion (&files
.head
->input_statement
);
7451 /* All elements from an archive can be added at once. */
7452 iter
= &files
.head
->input_statement
.next
;
7453 my_arch
= files
.head
->input_statement
.the_bfd
->my_archive
;
7454 if (my_arch
!= NULL
)
7455 for (; *iter
!= NULL
; iter
= &(*iter
)->input_statement
.next
)
7456 if ((*iter
)->input_statement
.the_bfd
->my_archive
!= my_arch
)
7459 *insert
= files
.head
;
7462 if (my_arch
!= NULL
)
7464 lang_input_statement_type
*parent
= my_arch
->usrdata
;
7466 parent
->next
= (lang_statement_union_type
*)
7468 - offsetof (lang_input_statement_type
, next
));
7473 #endif /* ENABLE_PLUGINS */
7475 /* Make sure that nobody has tried to add a symbol to this list
7477 ASSERT (link_info
.gc_sym_list
== NULL
);
7479 link_info
.gc_sym_list
= &entry_symbol
;
7481 if (entry_symbol
.name
== NULL
)
7483 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
7485 /* entry_symbol is normally initialied by a ENTRY definition in the
7486 linker script or the -e command line option. But if neither of
7487 these have been used, the target specific backend may still have
7488 provided an entry symbol via a call to lang_default_entry().
7489 Unfortunately this value will not be processed until lang_end()
7490 is called, long after this function has finished. So detect this
7491 case here and add the target's entry symbol to the list of starting
7492 points for garbage collection resolution. */
7493 lang_add_gc_name (entry_symbol_default
);
7496 lang_add_gc_name (link_info
.init_function
);
7497 lang_add_gc_name (link_info
.fini_function
);
7499 ldemul_after_open ();
7500 if (config
.map_file
!= NULL
)
7501 lang_print_asneeded ();
7503 bfd_section_already_linked_table_free ();
7505 /* Make sure that we're not mixing architectures. We call this
7506 after all the input files have been opened, but before we do any
7507 other processing, so that any operations merge_private_bfd_data
7508 does on the output file will be known during the rest of the
7512 /* Handle .exports instead of a version script if we're told to do so. */
7513 if (command_line
.version_exports_section
)
7514 lang_do_version_exports_section ();
7516 /* Build all sets based on the information gathered from the input
7518 ldctor_build_sets ();
7520 /* Give initial values for __start and __stop symbols, so that ELF
7521 gc_sections will keep sections referenced by these symbols. Must
7522 be done before lang_do_assignments below. */
7523 if (config
.build_constructors
)
7524 lang_init_start_stop ();
7526 /* PR 13683: We must rerun the assignments prior to running garbage
7527 collection in order to make sure that all symbol aliases are resolved. */
7528 lang_do_assignments (lang_mark_phase_enum
);
7529 expld
.phase
= lang_first_phase_enum
;
7531 /* Size up the common data. */
7534 /* Remove unreferenced sections if asked to. */
7535 lang_gc_sections ();
7537 /* Check relocations. */
7538 lang_check_relocs ();
7540 ldemul_after_check_relocs ();
7542 /* Update wild statements. */
7543 update_wild_statements (statement_list
.head
);
7545 /* Run through the contours of the script and attach input sections
7546 to the correct output sections. */
7547 lang_statement_iteration
++;
7548 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
7550 process_insert_statements ();
7552 /* Find any sections not attached explicitly and handle them. */
7553 lang_place_orphans ();
7555 if (!bfd_link_relocatable (&link_info
))
7559 /* Merge SEC_MERGE sections. This has to be done after GC of
7560 sections, so that GCed sections are not merged, but before
7561 assigning dynamic symbols, since removing whole input sections
7563 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
7565 /* Look for a text section and set the readonly attribute in it. */
7566 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
7570 if (config
.text_read_only
)
7571 found
->flags
|= SEC_READONLY
;
7573 found
->flags
&= ~SEC_READONLY
;
7577 /* Copy forward lma regions for output sections in same lma region. */
7578 lang_propagate_lma_regions ();
7580 /* Defining __start/__stop symbols early for --gc-sections to work
7581 around a glibc build problem can result in these symbols being
7582 defined when they should not be. Fix them now. */
7583 if (config
.build_constructors
)
7584 lang_undef_start_stop ();
7586 /* Define .startof./.sizeof. symbols with preliminary values before
7587 dynamic symbols are created. */
7588 if (!bfd_link_relocatable (&link_info
))
7589 lang_init_startof_sizeof ();
7591 /* Do anything special before sizing sections. This is where ELF
7592 and other back-ends size dynamic sections. */
7593 ldemul_before_allocation ();
7595 /* We must record the program headers before we try to fix the
7596 section positions, since they will affect SIZEOF_HEADERS. */
7597 lang_record_phdrs ();
7599 /* Check relro sections. */
7600 if (link_info
.relro
&& !bfd_link_relocatable (&link_info
))
7601 lang_find_relro_sections ();
7603 /* Size up the sections. */
7604 lang_size_sections (NULL
, !RELAXATION_ENABLED
);
7606 /* See if anything special should be done now we know how big
7607 everything is. This is where relaxation is done. */
7608 ldemul_after_allocation ();
7610 /* Fix any __start, __stop, .startof. or .sizeof. symbols. */
7611 lang_finalize_start_stop ();
7613 /* Do all the assignments again, to report errors. Assignment
7614 statements are processed multiple times, updating symbols; In
7615 open_input_bfds, lang_do_assignments, and lang_size_sections.
7616 Since lang_relax_sections calls lang_do_assignments, symbols are
7617 also updated in ldemul_after_allocation. */
7618 lang_do_assignments (lang_final_phase_enum
);
7622 /* Convert absolute symbols to section relative. */
7623 ldexp_finalize_syms ();
7625 /* Make sure that the section addresses make sense. */
7626 if (command_line
.check_section_addresses
)
7627 lang_check_section_addresses ();
7629 /* Check any required symbols are known. */
7630 ldlang_check_require_defined_symbols ();
7635 /* EXPORTED TO YACC */
7638 lang_add_wild (struct wildcard_spec
*filespec
,
7639 struct wildcard_list
*section_list
,
7640 bfd_boolean keep_sections
)
7642 struct wildcard_list
*curr
, *next
;
7643 lang_wild_statement_type
*new_stmt
;
7645 /* Reverse the list as the parser puts it back to front. */
7646 for (curr
= section_list
, section_list
= NULL
;
7648 section_list
= curr
, curr
= next
)
7651 curr
->next
= section_list
;
7654 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
7656 if (strcmp (filespec
->name
, "*") == 0)
7657 filespec
->name
= NULL
;
7658 else if (!wildcardp (filespec
->name
))
7659 lang_has_input_file
= TRUE
;
7662 new_stmt
= new_stat (lang_wild_statement
, stat_ptr
);
7663 new_stmt
->filename
= NULL
;
7664 new_stmt
->filenames_sorted
= FALSE
;
7665 new_stmt
->section_flag_list
= NULL
;
7666 new_stmt
->exclude_name_list
= NULL
;
7667 if (filespec
!= NULL
)
7669 new_stmt
->filename
= filespec
->name
;
7670 new_stmt
->filenames_sorted
= filespec
->sorted
== by_name
;
7671 new_stmt
->section_flag_list
= filespec
->section_flag_list
;
7672 new_stmt
->exclude_name_list
= filespec
->exclude_name_list
;
7674 new_stmt
->section_list
= section_list
;
7675 new_stmt
->keep_sections
= keep_sections
;
7676 lang_list_init (&new_stmt
->children
);
7677 analyze_walk_wild_section_handler (new_stmt
);
7681 lang_section_start (const char *name
, etree_type
*address
,
7682 const segment_type
*segment
)
7684 lang_address_statement_type
*ad
;
7686 ad
= new_stat (lang_address_statement
, stat_ptr
);
7687 ad
->section_name
= name
;
7688 ad
->address
= address
;
7689 ad
->segment
= segment
;
7692 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
7693 because of a -e argument on the command line, or zero if this is
7694 called by ENTRY in a linker script. Command line arguments take
7698 lang_add_entry (const char *name
, bfd_boolean cmdline
)
7700 if (entry_symbol
.name
== NULL
7702 || !entry_from_cmdline
)
7704 entry_symbol
.name
= name
;
7705 entry_from_cmdline
= cmdline
;
7709 /* Set the default start symbol to NAME. .em files should use this,
7710 not lang_add_entry, to override the use of "start" if neither the
7711 linker script nor the command line specifies an entry point. NAME
7712 must be permanently allocated. */
7714 lang_default_entry (const char *name
)
7716 entry_symbol_default
= name
;
7720 lang_add_target (const char *name
)
7722 lang_target_statement_type
*new_stmt
;
7724 new_stmt
= new_stat (lang_target_statement
, stat_ptr
);
7725 new_stmt
->target
= name
;
7729 lang_add_map (const char *name
)
7736 map_option_f
= TRUE
;
7744 lang_add_fill (fill_type
*fill
)
7746 lang_fill_statement_type
*new_stmt
;
7748 new_stmt
= new_stat (lang_fill_statement
, stat_ptr
);
7749 new_stmt
->fill
= fill
;
7753 lang_add_data (int type
, union etree_union
*exp
)
7755 lang_data_statement_type
*new_stmt
;
7757 new_stmt
= new_stat (lang_data_statement
, stat_ptr
);
7758 new_stmt
->exp
= exp
;
7759 new_stmt
->type
= type
;
7762 /* Create a new reloc statement. RELOC is the BFD relocation type to
7763 generate. HOWTO is the corresponding howto structure (we could
7764 look this up, but the caller has already done so). SECTION is the
7765 section to generate a reloc against, or NAME is the name of the
7766 symbol to generate a reloc against. Exactly one of SECTION and
7767 NAME must be NULL. ADDEND is an expression for the addend. */
7770 lang_add_reloc (bfd_reloc_code_real_type reloc
,
7771 reloc_howto_type
*howto
,
7774 union etree_union
*addend
)
7776 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
7780 p
->section
= section
;
7782 p
->addend_exp
= addend
;
7784 p
->addend_value
= 0;
7785 p
->output_section
= NULL
;
7786 p
->output_offset
= 0;
7789 lang_assignment_statement_type
*
7790 lang_add_assignment (etree_type
*exp
)
7792 lang_assignment_statement_type
*new_stmt
;
7794 new_stmt
= new_stat (lang_assignment_statement
, stat_ptr
);
7795 new_stmt
->exp
= exp
;
7800 lang_add_attribute (enum statement_enum attribute
)
7802 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
7806 lang_startup (const char *name
)
7808 if (first_file
->filename
!= NULL
)
7810 einfo (_("%F%P: multiple STARTUP files\n"));
7812 first_file
->filename
= name
;
7813 first_file
->local_sym_name
= name
;
7814 first_file
->flags
.real
= TRUE
;
7818 lang_float (bfd_boolean maybe
)
7820 lang_float_flag
= maybe
;
7824 /* Work out the load- and run-time regions from a script statement, and
7825 store them in *LMA_REGION and *REGION respectively.
7827 MEMSPEC is the name of the run-time region, or the value of
7828 DEFAULT_MEMORY_REGION if the statement didn't specify one.
7829 LMA_MEMSPEC is the name of the load-time region, or null if the
7830 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
7831 had an explicit load address.
7833 It is an error to specify both a load region and a load address. */
7836 lang_get_regions (lang_memory_region_type
**region
,
7837 lang_memory_region_type
**lma_region
,
7838 const char *memspec
,
7839 const char *lma_memspec
,
7840 bfd_boolean have_lma
,
7841 bfd_boolean have_vma
)
7843 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
7845 /* If no runtime region or VMA has been specified, but the load region
7846 has been specified, then use the load region for the runtime region
7848 if (lma_memspec
!= NULL
7850 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
7851 *region
= *lma_region
;
7853 *region
= lang_memory_region_lookup (memspec
, FALSE
);
7855 if (have_lma
&& lma_memspec
!= 0)
7856 einfo (_("%X%P:%pS: section has both a load address and a load region\n"),
7861 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
7862 lang_output_section_phdr_list
*phdrs
,
7863 const char *lma_memspec
)
7865 lang_get_regions (¤t_section
->region
,
7866 ¤t_section
->lma_region
,
7867 memspec
, lma_memspec
,
7868 current_section
->load_base
!= NULL
,
7869 current_section
->addr_tree
!= NULL
);
7871 current_section
->fill
= fill
;
7872 current_section
->phdrs
= phdrs
;
7877 lang_statement_append (lang_statement_list_type
*list
,
7878 lang_statement_union_type
*element
,
7879 lang_statement_union_type
**field
)
7881 *(list
->tail
) = element
;
7885 /* Set the output format type. -oformat overrides scripts. */
7888 lang_add_output_format (const char *format
,
7893 if (output_target
== NULL
|| !from_script
)
7895 if (command_line
.endian
== ENDIAN_BIG
7898 else if (command_line
.endian
== ENDIAN_LITTLE
7902 output_target
= format
;
7907 lang_add_insert (const char *where
, int is_before
)
7909 lang_insert_statement_type
*new_stmt
;
7911 new_stmt
= new_stat (lang_insert_statement
, stat_ptr
);
7912 new_stmt
->where
= where
;
7913 new_stmt
->is_before
= is_before
;
7914 saved_script_handle
= previous_script_handle
;
7917 /* Enter a group. This creates a new lang_group_statement, and sets
7918 stat_ptr to build new statements within the group. */
7921 lang_enter_group (void)
7923 lang_group_statement_type
*g
;
7925 g
= new_stat (lang_group_statement
, stat_ptr
);
7926 lang_list_init (&g
->children
);
7927 push_stat_ptr (&g
->children
);
7930 /* Leave a group. This just resets stat_ptr to start writing to the
7931 regular list of statements again. Note that this will not work if
7932 groups can occur inside anything else which can adjust stat_ptr,
7933 but currently they can't. */
7936 lang_leave_group (void)
7941 /* Add a new program header. This is called for each entry in a PHDRS
7942 command in a linker script. */
7945 lang_new_phdr (const char *name
,
7947 bfd_boolean filehdr
,
7952 struct lang_phdr
*n
, **pp
;
7955 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
7958 n
->type
= exp_get_vma (type
, 0, "program header type");
7959 n
->filehdr
= filehdr
;
7964 hdrs
= n
->type
== 1 && (phdrs
|| filehdr
);
7966 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
7969 && !((*pp
)->filehdr
|| (*pp
)->phdrs
))
7971 einfo (_("%X%P:%pS: PHDRS and FILEHDR are not supported"
7972 " when prior PT_LOAD headers lack them\n"), NULL
);
7979 /* Record the program header information in the output BFD. FIXME: We
7980 should not be calling an ELF specific function here. */
7983 lang_record_phdrs (void)
7987 lang_output_section_phdr_list
*last
;
7988 struct lang_phdr
*l
;
7989 lang_output_section_statement_type
*os
;
7992 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
7995 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
8002 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
8006 lang_output_section_phdr_list
*pl
;
8008 if (os
->constraint
< 0)
8016 if (os
->sectype
== noload_section
8017 || os
->bfd_section
== NULL
8018 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
8021 /* Don't add orphans to PT_INTERP header. */
8027 lang_output_section_statement_type
*tmp_os
;
8029 /* If we have not run across a section with a program
8030 header assigned to it yet, then scan forwards to find
8031 one. This prevents inconsistencies in the linker's
8032 behaviour when a script has specified just a single
8033 header and there are sections in that script which are
8034 not assigned to it, and which occur before the first
8035 use of that header. See here for more details:
8036 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
8037 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
8040 last
= tmp_os
->phdrs
;
8044 einfo (_("%F%P: no sections assigned to phdrs\n"));
8049 if (os
->bfd_section
== NULL
)
8052 for (; pl
!= NULL
; pl
= pl
->next
)
8054 if (strcmp (pl
->name
, l
->name
) == 0)
8059 secs
= (asection
**) xrealloc (secs
,
8060 alc
* sizeof (asection
*));
8062 secs
[c
] = os
->bfd_section
;
8069 if (l
->flags
== NULL
)
8072 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
8077 at
= exp_get_vma (l
->at
, 0, "phdr load address");
8079 if (!bfd_record_phdr (link_info
.output_bfd
, l
->type
,
8080 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
8081 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
8082 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
8087 /* Make sure all the phdr assignments succeeded. */
8088 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
8092 lang_output_section_phdr_list
*pl
;
8094 if (os
->constraint
< 0
8095 || os
->bfd_section
== NULL
)
8098 for (pl
= os
->phdrs
;
8101 if (!pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
8102 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
8103 os
->name
, pl
->name
);
8107 /* Record a list of sections which may not be cross referenced. */
8110 lang_add_nocrossref (lang_nocrossref_type
*l
)
8112 struct lang_nocrossrefs
*n
;
8114 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
8115 n
->next
= nocrossref_list
;
8117 n
->onlyfirst
= FALSE
;
8118 nocrossref_list
= n
;
8120 /* Set notice_all so that we get informed about all symbols. */
8121 link_info
.notice_all
= TRUE
;
8124 /* Record a section that cannot be referenced from a list of sections. */
8127 lang_add_nocrossref_to (lang_nocrossref_type
*l
)
8129 lang_add_nocrossref (l
);
8130 nocrossref_list
->onlyfirst
= TRUE
;
8133 /* Overlay handling. We handle overlays with some static variables. */
8135 /* The overlay virtual address. */
8136 static etree_type
*overlay_vma
;
8137 /* And subsection alignment. */
8138 static etree_type
*overlay_subalign
;
8140 /* An expression for the maximum section size seen so far. */
8141 static etree_type
*overlay_max
;
8143 /* A list of all the sections in this overlay. */
8145 struct overlay_list
{
8146 struct overlay_list
*next
;
8147 lang_output_section_statement_type
*os
;
8150 static struct overlay_list
*overlay_list
;
8152 /* Start handling an overlay. */
8155 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
8157 /* The grammar should prevent nested overlays from occurring. */
8158 ASSERT (overlay_vma
== NULL
8159 && overlay_subalign
== NULL
8160 && overlay_max
== NULL
);
8162 overlay_vma
= vma_expr
;
8163 overlay_subalign
= subalign
;
8166 /* Start a section in an overlay. We handle this by calling
8167 lang_enter_output_section_statement with the correct VMA.
8168 lang_leave_overlay sets up the LMA and memory regions. */
8171 lang_enter_overlay_section (const char *name
)
8173 struct overlay_list
*n
;
8176 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
8177 0, overlay_subalign
, 0, 0, 0);
8179 /* If this is the first section, then base the VMA of future
8180 sections on this one. This will work correctly even if `.' is
8181 used in the addresses. */
8182 if (overlay_list
== NULL
)
8183 overlay_vma
= exp_nameop (ADDR
, name
);
8185 /* Remember the section. */
8186 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
8187 n
->os
= current_section
;
8188 n
->next
= overlay_list
;
8191 size
= exp_nameop (SIZEOF
, name
);
8193 /* Arrange to work out the maximum section end address. */
8194 if (overlay_max
== NULL
)
8197 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
8200 /* Finish a section in an overlay. There isn't any special to do
8204 lang_leave_overlay_section (fill_type
*fill
,
8205 lang_output_section_phdr_list
*phdrs
)
8212 name
= current_section
->name
;
8214 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
8215 region and that no load-time region has been specified. It doesn't
8216 really matter what we say here, since lang_leave_overlay will
8218 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
8220 /* Define the magic symbols. */
8222 clean
= (char *) xmalloc (strlen (name
) + 1);
8224 for (s1
= name
; *s1
!= '\0'; s1
++)
8225 if (ISALNUM (*s1
) || *s1
== '_')
8229 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_start_");
8230 sprintf (buf
, "__load_start_%s", clean
);
8231 lang_add_assignment (exp_provide (buf
,
8232 exp_nameop (LOADADDR
, name
),
8235 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_stop_");
8236 sprintf (buf
, "__load_stop_%s", clean
);
8237 lang_add_assignment (exp_provide (buf
,
8239 exp_nameop (LOADADDR
, name
),
8240 exp_nameop (SIZEOF
, name
)),
8246 /* Finish an overlay. If there are any overlay wide settings, this
8247 looks through all the sections in the overlay and sets them. */
8250 lang_leave_overlay (etree_type
*lma_expr
,
8253 const char *memspec
,
8254 lang_output_section_phdr_list
*phdrs
,
8255 const char *lma_memspec
)
8257 lang_memory_region_type
*region
;
8258 lang_memory_region_type
*lma_region
;
8259 struct overlay_list
*l
;
8260 lang_nocrossref_type
*nocrossref
;
8262 lang_get_regions (®ion
, &lma_region
,
8263 memspec
, lma_memspec
,
8264 lma_expr
!= NULL
, FALSE
);
8268 /* After setting the size of the last section, set '.' to end of the
8270 if (overlay_list
!= NULL
)
8272 overlay_list
->os
->update_dot
= 1;
8273 overlay_list
->os
->update_dot_tree
8274 = exp_assign (".", exp_binop ('+', overlay_vma
, overlay_max
), FALSE
);
8280 struct overlay_list
*next
;
8282 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
8285 l
->os
->region
= region
;
8286 l
->os
->lma_region
= lma_region
;
8288 /* The first section has the load address specified in the
8289 OVERLAY statement. The rest are worked out from that.
8290 The base address is not needed (and should be null) if
8291 an LMA region was specified. */
8294 l
->os
->load_base
= lma_expr
;
8295 l
->os
->sectype
= normal_section
;
8297 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
8298 l
->os
->phdrs
= phdrs
;
8302 lang_nocrossref_type
*nc
;
8304 nc
= (lang_nocrossref_type
*) xmalloc (sizeof *nc
);
8305 nc
->name
= l
->os
->name
;
8306 nc
->next
= nocrossref
;
8315 if (nocrossref
!= NULL
)
8316 lang_add_nocrossref (nocrossref
);
8319 overlay_list
= NULL
;
8321 overlay_subalign
= NULL
;
8324 /* Version handling. This is only useful for ELF. */
8326 /* If PREV is NULL, return first version pattern matching particular symbol.
8327 If PREV is non-NULL, return first version pattern matching particular
8328 symbol after PREV (previously returned by lang_vers_match). */
8330 static struct bfd_elf_version_expr
*
8331 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
8332 struct bfd_elf_version_expr
*prev
,
8336 const char *cxx_sym
= sym
;
8337 const char *java_sym
= sym
;
8338 struct bfd_elf_version_expr
*expr
= NULL
;
8339 enum demangling_styles curr_style
;
8341 curr_style
= CURRENT_DEMANGLING_STYLE
;
8342 cplus_demangle_set_style (no_demangling
);
8343 c_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_NO_OPTS
);
8346 cplus_demangle_set_style (curr_style
);
8348 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8350 cxx_sym
= bfd_demangle (link_info
.output_bfd
, sym
,
8351 DMGL_PARAMS
| DMGL_ANSI
);
8355 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8357 java_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_JAVA
);
8362 if (head
->htab
&& (prev
== NULL
|| prev
->literal
))
8364 struct bfd_elf_version_expr e
;
8366 switch (prev
? prev
->mask
: 0)
8369 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
8372 expr
= (struct bfd_elf_version_expr
*)
8373 htab_find ((htab_t
) head
->htab
, &e
);
8374 while (expr
&& strcmp (expr
->pattern
, c_sym
) == 0)
8375 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
8381 case BFD_ELF_VERSION_C_TYPE
:
8382 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8384 e
.pattern
= cxx_sym
;
8385 expr
= (struct bfd_elf_version_expr
*)
8386 htab_find ((htab_t
) head
->htab
, &e
);
8387 while (expr
&& strcmp (expr
->pattern
, cxx_sym
) == 0)
8388 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
8394 case BFD_ELF_VERSION_CXX_TYPE
:
8395 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8397 e
.pattern
= java_sym
;
8398 expr
= (struct bfd_elf_version_expr
*)
8399 htab_find ((htab_t
) head
->htab
, &e
);
8400 while (expr
&& strcmp (expr
->pattern
, java_sym
) == 0)
8401 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8412 /* Finally, try the wildcards. */
8413 if (prev
== NULL
|| prev
->literal
)
8414 expr
= head
->remaining
;
8417 for (; expr
; expr
= expr
->next
)
8424 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
8427 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8429 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
8433 if (fnmatch (expr
->pattern
, s
, 0) == 0)
8439 free ((char *) c_sym
);
8441 free ((char *) cxx_sym
);
8442 if (java_sym
!= sym
)
8443 free ((char *) java_sym
);
8447 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
8448 return a pointer to the symbol name with any backslash quotes removed. */
8451 realsymbol (const char *pattern
)
8454 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
8455 char *s
, *symbol
= (char *) xmalloc (strlen (pattern
) + 1);
8457 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
8459 /* It is a glob pattern only if there is no preceding
8463 /* Remove the preceding backslash. */
8470 if (*p
== '?' || *p
== '*' || *p
== '[')
8477 backslash
= *p
== '\\';
8493 /* This is called for each variable name or match expression. NEW_NAME is
8494 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
8495 pattern to be matched against symbol names. */
8497 struct bfd_elf_version_expr
*
8498 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
8499 const char *new_name
,
8501 bfd_boolean literal_p
)
8503 struct bfd_elf_version_expr
*ret
;
8505 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
8509 ret
->literal
= TRUE
;
8510 ret
->pattern
= literal_p
? new_name
: realsymbol (new_name
);
8511 if (ret
->pattern
== NULL
)
8513 ret
->pattern
= new_name
;
8514 ret
->literal
= FALSE
;
8517 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
8518 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
8519 else if (strcasecmp (lang
, "C++") == 0)
8520 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
8521 else if (strcasecmp (lang
, "Java") == 0)
8522 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
8525 einfo (_("%X%P: unknown language `%s' in version information\n"),
8527 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
8530 return ldemul_new_vers_pattern (ret
);
8533 /* This is called for each set of variable names and match
8536 struct bfd_elf_version_tree
*
8537 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
8538 struct bfd_elf_version_expr
*locals
)
8540 struct bfd_elf_version_tree
*ret
;
8542 ret
= (struct bfd_elf_version_tree
*) xcalloc (1, sizeof *ret
);
8543 ret
->globals
.list
= globals
;
8544 ret
->locals
.list
= locals
;
8545 ret
->match
= lang_vers_match
;
8546 ret
->name_indx
= (unsigned int) -1;
8550 /* This static variable keeps track of version indices. */
8552 static int version_index
;
8555 version_expr_head_hash (const void *p
)
8557 const struct bfd_elf_version_expr
*e
=
8558 (const struct bfd_elf_version_expr
*) p
;
8560 return htab_hash_string (e
->pattern
);
8564 version_expr_head_eq (const void *p1
, const void *p2
)
8566 const struct bfd_elf_version_expr
*e1
=
8567 (const struct bfd_elf_version_expr
*) p1
;
8568 const struct bfd_elf_version_expr
*e2
=
8569 (const struct bfd_elf_version_expr
*) p2
;
8571 return strcmp (e1
->pattern
, e2
->pattern
) == 0;
8575 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
8578 struct bfd_elf_version_expr
*e
, *next
;
8579 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
8581 for (e
= head
->list
; e
; e
= e
->next
)
8585 head
->mask
|= e
->mask
;
8590 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
8591 version_expr_head_eq
, NULL
);
8592 list_loc
= &head
->list
;
8593 remaining_loc
= &head
->remaining
;
8594 for (e
= head
->list
; e
; e
= next
)
8600 remaining_loc
= &e
->next
;
8604 void **loc
= htab_find_slot ((htab_t
) head
->htab
, e
, INSERT
);
8608 struct bfd_elf_version_expr
*e1
, *last
;
8610 e1
= (struct bfd_elf_version_expr
*) *loc
;
8614 if (e1
->mask
== e
->mask
)
8622 while (e1
&& strcmp (e1
->pattern
, e
->pattern
) == 0);
8626 /* This is a duplicate. */
8627 /* FIXME: Memory leak. Sometimes pattern is not
8628 xmalloced alone, but in larger chunk of memory. */
8629 /* free (e->pattern); */
8634 e
->next
= last
->next
;
8642 list_loc
= &e
->next
;
8646 *remaining_loc
= NULL
;
8647 *list_loc
= head
->remaining
;
8650 head
->remaining
= head
->list
;
8653 /* This is called when we know the name and dependencies of the
8657 lang_register_vers_node (const char *name
,
8658 struct bfd_elf_version_tree
*version
,
8659 struct bfd_elf_version_deps
*deps
)
8661 struct bfd_elf_version_tree
*t
, **pp
;
8662 struct bfd_elf_version_expr
*e1
;
8667 if (link_info
.version_info
!= NULL
8668 && (name
[0] == '\0' || link_info
.version_info
->name
[0] == '\0'))
8670 einfo (_("%X%P: anonymous version tag cannot be combined"
8671 " with other version tags\n"));
8676 /* Make sure this node has a unique name. */
8677 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8678 if (strcmp (t
->name
, name
) == 0)
8679 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
8681 lang_finalize_version_expr_head (&version
->globals
);
8682 lang_finalize_version_expr_head (&version
->locals
);
8684 /* Check the global and local match names, and make sure there
8685 aren't any duplicates. */
8687 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
8689 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8691 struct bfd_elf_version_expr
*e2
;
8693 if (t
->locals
.htab
&& e1
->literal
)
8695 e2
= (struct bfd_elf_version_expr
*)
8696 htab_find ((htab_t
) t
->locals
.htab
, e1
);
8697 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
8699 if (e1
->mask
== e2
->mask
)
8700 einfo (_("%X%P: duplicate expression `%s'"
8701 " in version information\n"), e1
->pattern
);
8705 else if (!e1
->literal
)
8706 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
8707 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
8708 && e1
->mask
== e2
->mask
)
8709 einfo (_("%X%P: duplicate expression `%s'"
8710 " in version information\n"), e1
->pattern
);
8714 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
8716 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8718 struct bfd_elf_version_expr
*e2
;
8720 if (t
->globals
.htab
&& e1
->literal
)
8722 e2
= (struct bfd_elf_version_expr
*)
8723 htab_find ((htab_t
) t
->globals
.htab
, e1
);
8724 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
8726 if (e1
->mask
== e2
->mask
)
8727 einfo (_("%X%P: duplicate expression `%s'"
8728 " in version information\n"),
8733 else if (!e1
->literal
)
8734 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
8735 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
8736 && e1
->mask
== e2
->mask
)
8737 einfo (_("%X%P: duplicate expression `%s'"
8738 " in version information\n"), e1
->pattern
);
8742 version
->deps
= deps
;
8743 version
->name
= name
;
8744 if (name
[0] != '\0')
8747 version
->vernum
= version_index
;
8750 version
->vernum
= 0;
8752 for (pp
= &link_info
.version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
8757 /* This is called when we see a version dependency. */
8759 struct bfd_elf_version_deps
*
8760 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
8762 struct bfd_elf_version_deps
*ret
;
8763 struct bfd_elf_version_tree
*t
;
8765 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
8768 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8770 if (strcmp (t
->name
, name
) == 0)
8772 ret
->version_needed
= t
;
8777 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
8779 ret
->version_needed
= NULL
;
8784 lang_do_version_exports_section (void)
8786 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
8788 LANG_FOR_EACH_INPUT_STATEMENT (is
)
8790 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
8798 contents
= (char *) xmalloc (len
);
8799 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
8800 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
8803 while (p
< contents
+ len
)
8805 greg
= lang_new_vers_pattern (greg
, p
, NULL
, FALSE
);
8806 p
= strchr (p
, '\0') + 1;
8809 /* Do not free the contents, as we used them creating the regex. */
8811 /* Do not include this section in the link. */
8812 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
8815 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, FALSE
);
8816 lang_register_vers_node (command_line
.version_exports_section
,
8817 lang_new_vers_node (greg
, lreg
), NULL
);
8820 /* Evaluate LENGTH and ORIGIN parts of MEMORY spec */
8823 lang_do_memory_regions (void)
8825 lang_memory_region_type
*r
= lang_memory_region_list
;
8827 for (; r
!= NULL
; r
= r
->next
)
8831 exp_fold_tree_no_dot (r
->origin_exp
);
8832 if (expld
.result
.valid_p
)
8834 r
->origin
= expld
.result
.value
;
8835 r
->current
= r
->origin
;
8838 einfo (_("%F%P: invalid origin for memory region %s\n"),
8843 exp_fold_tree_no_dot (r
->length_exp
);
8844 if (expld
.result
.valid_p
)
8845 r
->length
= expld
.result
.value
;
8847 einfo (_("%F%P: invalid length for memory region %s\n"),
8854 lang_add_unique (const char *name
)
8856 struct unique_sections
*ent
;
8858 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
8859 if (strcmp (ent
->name
, name
) == 0)
8862 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
8863 ent
->name
= xstrdup (name
);
8864 ent
->next
= unique_section_list
;
8865 unique_section_list
= ent
;
8868 /* Append the list of dynamic symbols to the existing one. */
8871 lang_append_dynamic_list (struct bfd_elf_version_expr
*dynamic
)
8873 if (link_info
.dynamic_list
)
8875 struct bfd_elf_version_expr
*tail
;
8876 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
8878 tail
->next
= link_info
.dynamic_list
->head
.list
;
8879 link_info
.dynamic_list
->head
.list
= dynamic
;
8883 struct bfd_elf_dynamic_list
*d
;
8885 d
= (struct bfd_elf_dynamic_list
*) xcalloc (1, sizeof *d
);
8886 d
->head
.list
= dynamic
;
8887 d
->match
= lang_vers_match
;
8888 link_info
.dynamic_list
= d
;
8892 /* Append the list of C++ typeinfo dynamic symbols to the existing
8896 lang_append_dynamic_list_cpp_typeinfo (void)
8898 const char *symbols
[] =
8900 "typeinfo name for*",
8903 struct bfd_elf_version_expr
*dynamic
= NULL
;
8906 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
8907 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
8910 lang_append_dynamic_list (dynamic
);
8913 /* Append the list of C++ operator new and delete dynamic symbols to the
8917 lang_append_dynamic_list_cpp_new (void)
8919 const char *symbols
[] =
8924 struct bfd_elf_version_expr
*dynamic
= NULL
;
8927 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
8928 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
8931 lang_append_dynamic_list (dynamic
);
8934 /* Scan a space and/or comma separated string of features. */
8937 lang_ld_feature (char *str
)
8945 while (*p
== ',' || ISSPACE (*p
))
8950 while (*q
&& *q
!= ',' && !ISSPACE (*q
))
8954 if (strcasecmp (p
, "SANE_EXPR") == 0)
8955 config
.sane_expr
= TRUE
;
8957 einfo (_("%X%P: unknown feature `%s'\n"), p
);
8963 /* Pretty print memory amount. */
8966 lang_print_memory_size (bfd_vma sz
)
8968 if ((sz
& 0x3fffffff) == 0)
8969 printf ("%10" BFD_VMA_FMT
"u GB", sz
>> 30);
8970 else if ((sz
& 0xfffff) == 0)
8971 printf ("%10" BFD_VMA_FMT
"u MB", sz
>> 20);
8972 else if ((sz
& 0x3ff) == 0)
8973 printf ("%10" BFD_VMA_FMT
"u KB", sz
>> 10);
8975 printf (" %10" BFD_VMA_FMT
"u B", sz
);
8978 /* Implement --print-memory-usage: disply per region memory usage. */
8981 lang_print_memory_usage (void)
8983 lang_memory_region_type
*r
;
8985 printf ("Memory region Used Size Region Size %%age Used\n");
8986 for (r
= lang_memory_region_list
; r
->next
!= NULL
; r
= r
->next
)
8988 bfd_vma used_length
= r
->current
- r
->origin
;
8991 printf ("%16s: ",r
->name_list
.name
);
8992 lang_print_memory_size (used_length
);
8993 lang_print_memory_size ((bfd_vma
) r
->length
);
8995 percent
= used_length
* 100.0 / r
->length
;
8997 printf (" %6.2f%%\n", percent
);