1 /* Linker command language support.
2 Copyright (C) 1991-2019 Free Software Foundation, Inc.
4 This file is part of the GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
23 #include "libiberty.h"
24 #include "filenames.h"
25 #include "safe-ctype.h"
45 #endif /* ENABLE_PLUGINS */
48 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
51 /* Convert between addresses in bytes and sizes in octets.
52 For currently supported targets, octets_per_byte is always a power
53 of two, so we can use shifts. */
54 #define TO_ADDR(X) ((X) >> opb_shift)
55 #define TO_SIZE(X) ((X) << opb_shift)
57 /* Local variables. */
58 static struct obstack stat_obstack
;
59 static struct obstack map_obstack
;
61 #define obstack_chunk_alloc xmalloc
62 #define obstack_chunk_free free
63 static const char *entry_symbol_default
= "start";
64 static bfd_boolean map_head_is_link_order
= FALSE
;
65 static lang_output_section_statement_type
*default_common_section
;
66 static bfd_boolean map_option_f
;
67 static bfd_vma print_dot
;
68 static lang_input_statement_type
*first_file
;
69 static const char *current_target
;
70 /* Header for list of statements corresponding to any files involved in the
71 link, either specified from the command-line or added implicitely (eg.
72 archive member used to resolved undefined symbol, wildcard statement from
73 linker script, etc.). Next pointer is in next field of a
74 lang_statement_header_type (reached via header field in a
75 lang_statement_union). */
76 static lang_statement_list_type statement_list
;
77 static lang_statement_list_type
*stat_save
[10];
78 static lang_statement_list_type
**stat_save_ptr
= &stat_save
[0];
79 static struct unique_sections
*unique_section_list
;
80 static struct asneeded_minfo
*asneeded_list_head
;
81 static unsigned int opb_shift
= 0;
83 /* Forward declarations. */
84 static void exp_init_os (etree_type
*);
85 static lang_input_statement_type
*lookup_name (const char *);
86 static void insert_undefined (const char *);
87 static bfd_boolean
sort_def_symbol (struct bfd_link_hash_entry
*, void *);
88 static void print_statement (lang_statement_union_type
*,
89 lang_output_section_statement_type
*);
90 static void print_statement_list (lang_statement_union_type
*,
91 lang_output_section_statement_type
*);
92 static void print_statements (void);
93 static void print_input_section (asection
*, bfd_boolean
);
94 static bfd_boolean
lang_one_common (struct bfd_link_hash_entry
*, void *);
95 static void lang_record_phdrs (void);
96 static void lang_do_version_exports_section (void);
97 static void lang_finalize_version_expr_head
98 (struct bfd_elf_version_expr_head
*);
99 static void lang_do_memory_regions (void);
101 /* Exported variables. */
102 const char *output_target
;
103 lang_output_section_statement_type
*abs_output_section
;
104 lang_statement_list_type lang_os_list
;
105 lang_statement_list_type
*stat_ptr
= &statement_list
;
106 /* Header for list of statements corresponding to files used in the final
107 executable. This can be either object file specified on the command-line
108 or library member resolving an undefined reference. Next pointer is in next
109 field of a lang_input_statement_type (reached via input_statement field in a
110 lang_statement_union). */
111 lang_statement_list_type file_chain
= { NULL
, NULL
};
112 /* Header for list of statements corresponding to files specified on the
113 command-line for linking. It thus contains real object files and archive
114 but not archive members. Next pointer is in next_real_file field of a
115 lang_input_statement_type statement (reached via input_statement field in a
116 lang_statement_union). */
117 lang_statement_list_type input_file_chain
;
118 struct bfd_sym_chain entry_symbol
= { NULL
, NULL
};
119 const char *entry_section
= ".text";
120 struct lang_input_statement_flags input_flags
;
121 bfd_boolean entry_from_cmdline
;
122 bfd_boolean undef_from_cmdline
;
123 bfd_boolean lang_has_input_file
= FALSE
;
124 bfd_boolean had_output_filename
= FALSE
;
125 bfd_boolean lang_float_flag
= FALSE
;
126 bfd_boolean delete_output_file_on_failure
= FALSE
;
127 struct lang_phdr
*lang_phdr_list
;
128 struct lang_nocrossrefs
*nocrossref_list
;
129 struct asneeded_minfo
**asneeded_list_tail
;
131 /* Functions that traverse the linker script and might evaluate
132 DEFINED() need to increment this at the start of the traversal. */
133 int lang_statement_iteration
= 0;
135 /* Return TRUE if the PATTERN argument is a wildcard pattern.
136 Although backslashes are treated specially if a pattern contains
137 wildcards, we do not consider the mere presence of a backslash to
138 be enough to cause the pattern to be treated as a wildcard.
139 That lets us handle DOS filenames more naturally. */
140 #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
142 #define new_stat(x, y) \
143 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
145 #define outside_section_address(q) \
146 ((q)->output_offset + (q)->output_section->vma)
148 #define outside_symbol_address(q) \
149 ((q)->value + outside_section_address (q->section))
151 #define SECTION_NAME_MAP_LENGTH (16)
154 stat_alloc (size_t size
)
156 return obstack_alloc (&stat_obstack
, size
);
160 name_match (const char *pattern
, const char *name
)
162 if (wildcardp (pattern
))
163 return fnmatch (pattern
, name
, 0);
164 return strcmp (pattern
, name
);
167 /* If PATTERN is of the form archive:file, return a pointer to the
168 separator. If not, return NULL. */
171 archive_path (const char *pattern
)
175 if (link_info
.path_separator
== 0)
178 p
= strchr (pattern
, link_info
.path_separator
);
179 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
180 if (p
== NULL
|| link_info
.path_separator
!= ':')
183 /* Assume a match on the second char is part of drive specifier,
184 as in "c:\silly.dos". */
185 if (p
== pattern
+ 1 && ISALPHA (*pattern
))
186 p
= strchr (p
+ 1, link_info
.path_separator
);
191 /* Given that FILE_SPEC results in a non-NULL SEP result from archive_path,
192 return whether F matches FILE_SPEC. */
195 input_statement_is_archive_path (const char *file_spec
, char *sep
,
196 lang_input_statement_type
*f
)
198 bfd_boolean match
= FALSE
;
201 || name_match (sep
+ 1, f
->filename
) == 0)
202 && ((sep
!= file_spec
)
203 == (f
->the_bfd
!= NULL
&& f
->the_bfd
->my_archive
!= NULL
)))
207 if (sep
!= file_spec
)
209 const char *aname
= f
->the_bfd
->my_archive
->filename
;
211 match
= name_match (file_spec
, aname
) == 0;
212 *sep
= link_info
.path_separator
;
219 unique_section_p (const asection
*sec
,
220 const lang_output_section_statement_type
*os
)
222 struct unique_sections
*unam
;
225 if (!link_info
.resolve_section_groups
226 && sec
->owner
!= NULL
227 && bfd_is_group_section (sec
->owner
, sec
))
229 && strcmp (os
->name
, DISCARD_SECTION_NAME
) == 0);
232 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
233 if (name_match (unam
->name
, secnam
) == 0)
239 /* Generic traversal routines for finding matching sections. */
241 /* Return true if FILE matches a pattern in EXCLUDE_LIST, otherwise return
245 walk_wild_file_in_exclude_list (struct name_list
*exclude_list
,
246 lang_input_statement_type
*file
)
248 struct name_list
*list_tmp
;
250 for (list_tmp
= exclude_list
;
252 list_tmp
= list_tmp
->next
)
254 char *p
= archive_path (list_tmp
->name
);
258 if (input_statement_is_archive_path (list_tmp
->name
, p
, file
))
262 else if (name_match (list_tmp
->name
, file
->filename
) == 0)
265 /* FIXME: Perhaps remove the following at some stage? Matching
266 unadorned archives like this was never documented and has
267 been superceded by the archive:path syntax. */
268 else if (file
->the_bfd
!= NULL
269 && file
->the_bfd
->my_archive
!= NULL
270 && name_match (list_tmp
->name
,
271 file
->the_bfd
->my_archive
->filename
) == 0)
278 /* Try processing a section against a wildcard. This just calls
279 the callback unless the filename exclusion list is present
280 and excludes the file. It's hardly ever present so this
281 function is very fast. */
284 walk_wild_consider_section (lang_wild_statement_type
*ptr
,
285 lang_input_statement_type
*file
,
287 struct wildcard_list
*sec
,
291 /* Don't process sections from files which were excluded. */
292 if (walk_wild_file_in_exclude_list (sec
->spec
.exclude_name_list
, file
))
295 (*callback
) (ptr
, sec
, s
, ptr
->section_flag_list
, file
, data
);
298 /* Lowest common denominator routine that can handle everything correctly,
302 walk_wild_section_general (lang_wild_statement_type
*ptr
,
303 lang_input_statement_type
*file
,
308 struct wildcard_list
*sec
;
310 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
312 sec
= ptr
->section_list
;
314 (*callback
) (ptr
, sec
, s
, ptr
->section_flag_list
, file
, data
);
318 bfd_boolean skip
= FALSE
;
320 if (sec
->spec
.name
!= NULL
)
322 const char *sname
= bfd_section_name (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
:
455 ainit_priority
= get_init_priority (bfd_section_name (asec
));
456 binit_priority
= get_init_priority (bfd_section_name (bsec
));
457 if (ainit_priority
== 0 || binit_priority
== 0)
459 ret
= ainit_priority
- binit_priority
;
465 case by_alignment_name
:
466 ret
= bfd_section_alignment (bsec
) - bfd_section_alignment (asec
);
473 ret
= strcmp (bfd_section_name (asec
), bfd_section_name (bsec
));
476 case by_name_alignment
:
477 ret
= strcmp (bfd_section_name (asec
), bfd_section_name (bsec
));
483 ret
= bfd_section_alignment (bsec
) - bfd_section_alignment (asec
);
490 /* Build a Binary Search Tree to sort sections, unlike insertion sort
491 used in wild_sort(). BST is considerably faster if the number of
492 of sections are large. */
494 static lang_section_bst_type
**
495 wild_sort_fast (lang_wild_statement_type
*wild
,
496 struct wildcard_list
*sec
,
497 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
500 lang_section_bst_type
**tree
;
503 if (!wild
->filenames_sorted
504 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
506 /* Append at the right end of tree. */
508 tree
= &((*tree
)->right
);
514 /* Find the correct node to append this section. */
515 if (compare_section (sec
->spec
.sorted
, section
, (*tree
)->section
) < 0)
516 tree
= &((*tree
)->left
);
518 tree
= &((*tree
)->right
);
524 /* Use wild_sort_fast to build a BST to sort sections. */
527 output_section_callback_fast (lang_wild_statement_type
*ptr
,
528 struct wildcard_list
*sec
,
530 struct flag_info
*sflag_list ATTRIBUTE_UNUSED
,
531 lang_input_statement_type
*file
,
534 lang_section_bst_type
*node
;
535 lang_section_bst_type
**tree
;
536 lang_output_section_statement_type
*os
;
538 os
= (lang_output_section_statement_type
*) output
;
540 if (unique_section_p (section
, os
))
543 node
= (lang_section_bst_type
*) xmalloc (sizeof (lang_section_bst_type
));
546 node
->section
= section
;
548 tree
= wild_sort_fast (ptr
, sec
, file
, section
);
553 /* Convert a sorted sections' BST back to list form. */
556 output_section_callback_tree_to_list (lang_wild_statement_type
*ptr
,
557 lang_section_bst_type
*tree
,
561 output_section_callback_tree_to_list (ptr
, tree
->left
, output
);
563 lang_add_section (&ptr
->children
, tree
->section
, NULL
,
564 (lang_output_section_statement_type
*) output
);
567 output_section_callback_tree_to_list (ptr
, tree
->right
, output
);
572 /* Specialized, optimized routines for handling different kinds of
576 walk_wild_section_specs1_wild0 (lang_wild_statement_type
*ptr
,
577 lang_input_statement_type
*file
,
581 /* We can just do a hash lookup for the section with the right name.
582 But if that lookup discovers more than one section with the name
583 (should be rare), we fall back to the general algorithm because
584 we would otherwise have to sort the sections to make sure they
585 get processed in the bfd's order. */
586 bfd_boolean multiple_sections_found
;
587 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
588 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
590 if (multiple_sections_found
)
591 walk_wild_section_general (ptr
, file
, callback
, data
);
593 walk_wild_consider_section (ptr
, file
, s0
, sec0
, callback
, data
);
597 walk_wild_section_specs1_wild1 (lang_wild_statement_type
*ptr
,
598 lang_input_statement_type
*file
,
603 struct wildcard_list
*wildsec0
= ptr
->handler_data
[0];
605 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
607 const char *sname
= bfd_section_name (s
);
608 bfd_boolean skip
= !match_simple_wild (wildsec0
->spec
.name
, sname
);
611 walk_wild_consider_section (ptr
, file
, s
, wildsec0
, callback
, data
);
616 walk_wild_section_specs2_wild1 (lang_wild_statement_type
*ptr
,
617 lang_input_statement_type
*file
,
622 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
623 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
624 bfd_boolean multiple_sections_found
;
625 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
627 if (multiple_sections_found
)
629 walk_wild_section_general (ptr
, file
, callback
, data
);
633 /* Note that if the section was not found, s0 is NULL and
634 we'll simply never succeed the s == s0 test below. */
635 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
637 /* Recall that in this code path, a section cannot satisfy more
638 than one spec, so if s == s0 then it cannot match
641 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
644 const char *sname
= bfd_section_name (s
);
645 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
648 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
,
655 walk_wild_section_specs3_wild2 (lang_wild_statement_type
*ptr
,
656 lang_input_statement_type
*file
,
661 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
662 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
663 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
664 bfd_boolean multiple_sections_found
;
665 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
667 if (multiple_sections_found
)
669 walk_wild_section_general (ptr
, file
, callback
, data
);
673 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
676 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
679 const char *sname
= bfd_section_name (s
);
680 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
683 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
, data
);
686 skip
= !match_simple_wild (wildsec2
->spec
.name
, sname
);
688 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
696 walk_wild_section_specs4_wild2 (lang_wild_statement_type
*ptr
,
697 lang_input_statement_type
*file
,
702 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
703 struct wildcard_list
*sec1
= ptr
->handler_data
[1];
704 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
705 struct wildcard_list
*wildsec3
= ptr
->handler_data
[3];
706 bfd_boolean multiple_sections_found
;
707 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
), *s1
;
709 if (multiple_sections_found
)
711 walk_wild_section_general (ptr
, file
, callback
, data
);
715 s1
= find_section (file
, sec1
, &multiple_sections_found
);
716 if (multiple_sections_found
)
718 walk_wild_section_general (ptr
, file
, callback
, data
);
722 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
725 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
728 walk_wild_consider_section (ptr
, file
, s
, sec1
, callback
, data
);
731 const char *sname
= bfd_section_name (s
);
732 bfd_boolean skip
= !match_simple_wild (wildsec2
->spec
.name
,
736 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
740 skip
= !match_simple_wild (wildsec3
->spec
.name
, sname
);
742 walk_wild_consider_section (ptr
, file
, s
, wildsec3
,
750 walk_wild_section (lang_wild_statement_type
*ptr
,
751 lang_input_statement_type
*file
,
755 if (file
->flags
.just_syms
)
758 (*ptr
->walk_wild_section_handler
) (ptr
, file
, callback
, data
);
761 /* Returns TRUE when name1 is a wildcard spec that might match
762 something name2 can match. We're conservative: we return FALSE
763 only if the prefixes of name1 and name2 are different up to the
764 first wildcard character. */
767 wild_spec_can_overlap (const char *name1
, const char *name2
)
769 size_t prefix1_len
= strcspn (name1
, "?*[");
770 size_t prefix2_len
= strcspn (name2
, "?*[");
771 size_t min_prefix_len
;
773 /* Note that if there is no wildcard character, then we treat the
774 terminating 0 as part of the prefix. Thus ".text" won't match
775 ".text." or ".text.*", for example. */
776 if (name1
[prefix1_len
] == '\0')
778 if (name2
[prefix2_len
] == '\0')
781 min_prefix_len
= prefix1_len
< prefix2_len
? prefix1_len
: prefix2_len
;
783 return memcmp (name1
, name2
, min_prefix_len
) == 0;
786 /* Select specialized code to handle various kinds of wildcard
790 analyze_walk_wild_section_handler (lang_wild_statement_type
*ptr
)
793 int wild_name_count
= 0;
794 struct wildcard_list
*sec
;
798 ptr
->walk_wild_section_handler
= walk_wild_section_general
;
799 ptr
->handler_data
[0] = NULL
;
800 ptr
->handler_data
[1] = NULL
;
801 ptr
->handler_data
[2] = NULL
;
802 ptr
->handler_data
[3] = NULL
;
805 /* Count how many wildcard_specs there are, and how many of those
806 actually use wildcards in the name. Also, bail out if any of the
807 wildcard names are NULL. (Can this actually happen?
808 walk_wild_section used to test for it.) And bail out if any
809 of the wildcards are more complex than a simple string
810 ending in a single '*'. */
811 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
814 if (sec
->spec
.name
== NULL
)
816 if (wildcardp (sec
->spec
.name
))
819 if (!is_simple_wild (sec
->spec
.name
))
824 /* The zero-spec case would be easy to optimize but it doesn't
825 happen in practice. Likewise, more than 4 specs doesn't
826 happen in practice. */
827 if (sec_count
== 0 || sec_count
> 4)
830 /* Check that no two specs can match the same section. */
831 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
833 struct wildcard_list
*sec2
;
834 for (sec2
= sec
->next
; sec2
!= NULL
; sec2
= sec2
->next
)
836 if (wild_spec_can_overlap (sec
->spec
.name
, sec2
->spec
.name
))
841 signature
= (sec_count
<< 8) + wild_name_count
;
845 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild0
;
848 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild1
;
851 ptr
->walk_wild_section_handler
= walk_wild_section_specs2_wild1
;
854 ptr
->walk_wild_section_handler
= walk_wild_section_specs3_wild2
;
857 ptr
->walk_wild_section_handler
= walk_wild_section_specs4_wild2
;
863 /* Now fill the data array with pointers to the specs, first the
864 specs with non-wildcard names, then the specs with wildcard
865 names. It's OK to process the specs in different order from the
866 given order, because we've already determined that no section
867 will match more than one spec. */
869 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
870 if (!wildcardp (sec
->spec
.name
))
871 ptr
->handler_data
[data_counter
++] = sec
;
872 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
873 if (wildcardp (sec
->spec
.name
))
874 ptr
->handler_data
[data_counter
++] = sec
;
877 /* Handle a wild statement for a single file F. */
880 walk_wild_file (lang_wild_statement_type
*s
,
881 lang_input_statement_type
*f
,
885 if (walk_wild_file_in_exclude_list (s
->exclude_name_list
, f
))
888 if (f
->the_bfd
== NULL
889 || !bfd_check_format (f
->the_bfd
, bfd_archive
))
890 walk_wild_section (s
, f
, callback
, data
);
895 /* This is an archive file. We must map each member of the
896 archive separately. */
897 member
= bfd_openr_next_archived_file (f
->the_bfd
, NULL
);
898 while (member
!= NULL
)
900 /* When lookup_name is called, it will call the add_symbols
901 entry point for the archive. For each element of the
902 archive which is included, BFD will call ldlang_add_file,
903 which will set the usrdata field of the member to the
904 lang_input_statement. */
905 if (bfd_usrdata (member
) != NULL
)
906 walk_wild_section (s
, bfd_usrdata (member
), callback
, data
);
908 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
914 walk_wild (lang_wild_statement_type
*s
, callback_t callback
, void *data
)
916 const char *file_spec
= s
->filename
;
919 if (file_spec
== NULL
)
921 /* Perform the iteration over all files in the list. */
922 LANG_FOR_EACH_INPUT_STATEMENT (f
)
924 walk_wild_file (s
, f
, callback
, data
);
927 else if ((p
= archive_path (file_spec
)) != NULL
)
929 LANG_FOR_EACH_INPUT_STATEMENT (f
)
931 if (input_statement_is_archive_path (file_spec
, p
, f
))
932 walk_wild_file (s
, f
, callback
, data
);
935 else if (wildcardp (file_spec
))
937 LANG_FOR_EACH_INPUT_STATEMENT (f
)
939 if (fnmatch (file_spec
, f
->filename
, 0) == 0)
940 walk_wild_file (s
, f
, callback
, data
);
945 lang_input_statement_type
*f
;
947 /* Perform the iteration over a single file. */
948 f
= lookup_name (file_spec
);
950 walk_wild_file (s
, f
, callback
, data
);
954 /* lang_for_each_statement walks the parse tree and calls the provided
955 function for each node, except those inside output section statements
956 with constraint set to -1. */
959 lang_for_each_statement_worker (void (*func
) (lang_statement_union_type
*),
960 lang_statement_union_type
*s
)
962 for (; s
!= NULL
; s
= s
->header
.next
)
966 switch (s
->header
.type
)
968 case lang_constructors_statement_enum
:
969 lang_for_each_statement_worker (func
, constructor_list
.head
);
971 case lang_output_section_statement_enum
:
972 if (s
->output_section_statement
.constraint
!= -1)
973 lang_for_each_statement_worker
974 (func
, s
->output_section_statement
.children
.head
);
976 case lang_wild_statement_enum
:
977 lang_for_each_statement_worker (func
,
978 s
->wild_statement
.children
.head
);
980 case lang_group_statement_enum
:
981 lang_for_each_statement_worker (func
,
982 s
->group_statement
.children
.head
);
984 case lang_data_statement_enum
:
985 case lang_reloc_statement_enum
:
986 case lang_object_symbols_statement_enum
:
987 case lang_output_statement_enum
:
988 case lang_target_statement_enum
:
989 case lang_input_section_enum
:
990 case lang_input_statement_enum
:
991 case lang_assignment_statement_enum
:
992 case lang_padding_statement_enum
:
993 case lang_address_statement_enum
:
994 case lang_fill_statement_enum
:
995 case lang_insert_statement_enum
:
1005 lang_for_each_statement (void (*func
) (lang_statement_union_type
*))
1007 lang_for_each_statement_worker (func
, statement_list
.head
);
1010 /*----------------------------------------------------------------------*/
1013 lang_list_init (lang_statement_list_type
*list
)
1016 list
->tail
= &list
->head
;
1020 lang_statement_append (lang_statement_list_type
*list
,
1024 *(list
->tail
) = element
;
1029 push_stat_ptr (lang_statement_list_type
*new_ptr
)
1031 if (stat_save_ptr
>= stat_save
+ sizeof (stat_save
) / sizeof (stat_save
[0]))
1033 *stat_save_ptr
++ = stat_ptr
;
1040 if (stat_save_ptr
<= stat_save
)
1042 stat_ptr
= *--stat_save_ptr
;
1045 /* Build a new statement node for the parse tree. */
1047 static lang_statement_union_type
*
1048 new_statement (enum statement_enum type
,
1050 lang_statement_list_type
*list
)
1052 lang_statement_union_type
*new_stmt
;
1054 new_stmt
= stat_alloc (size
);
1055 new_stmt
->header
.type
= type
;
1056 new_stmt
->header
.next
= NULL
;
1057 lang_statement_append (list
, new_stmt
, &new_stmt
->header
.next
);
1061 /* Build a new input file node for the language. There are several
1062 ways in which we treat an input file, eg, we only look at symbols,
1063 or prefix it with a -l etc.
1065 We can be supplied with requests for input files more than once;
1066 they may, for example be split over several lines like foo.o(.text)
1067 foo.o(.data) etc, so when asked for a file we check that we haven't
1068 got it already so we don't duplicate the bfd. */
1070 static lang_input_statement_type
*
1071 new_afile (const char *name
,
1072 lang_input_file_enum_type file_type
,
1075 lang_input_statement_type
*p
;
1077 lang_has_input_file
= TRUE
;
1079 p
= new_stat (lang_input_statement
, stat_ptr
);
1080 memset (&p
->the_bfd
, 0,
1081 sizeof (*p
) - offsetof (lang_input_statement_type
, the_bfd
));
1083 p
->flags
.dynamic
= input_flags
.dynamic
;
1084 p
->flags
.add_DT_NEEDED_for_dynamic
= input_flags
.add_DT_NEEDED_for_dynamic
;
1085 p
->flags
.add_DT_NEEDED_for_regular
= input_flags
.add_DT_NEEDED_for_regular
;
1086 p
->flags
.whole_archive
= input_flags
.whole_archive
;
1087 p
->flags
.sysrooted
= input_flags
.sysrooted
;
1091 case lang_input_file_is_symbols_only_enum
:
1093 p
->local_sym_name
= name
;
1094 p
->flags
.real
= TRUE
;
1095 p
->flags
.just_syms
= TRUE
;
1097 case lang_input_file_is_fake_enum
:
1099 p
->local_sym_name
= name
;
1101 case lang_input_file_is_l_enum
:
1102 if (name
[0] == ':' && name
[1] != '\0')
1104 p
->filename
= name
+ 1;
1105 p
->flags
.full_name_provided
= TRUE
;
1109 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
1110 p
->flags
.maybe_archive
= TRUE
;
1111 p
->flags
.real
= TRUE
;
1112 p
->flags
.search_dirs
= TRUE
;
1114 case lang_input_file_is_marker_enum
:
1116 p
->local_sym_name
= name
;
1117 p
->flags
.search_dirs
= TRUE
;
1119 case lang_input_file_is_search_file_enum
:
1121 p
->local_sym_name
= name
;
1122 p
->flags
.real
= TRUE
;
1123 p
->flags
.search_dirs
= TRUE
;
1125 case lang_input_file_is_file_enum
:
1127 p
->local_sym_name
= name
;
1128 p
->flags
.real
= TRUE
;
1134 lang_statement_append (&input_file_chain
, p
, &p
->next_real_file
);
1138 lang_input_statement_type
*
1139 lang_add_input_file (const char *name
,
1140 lang_input_file_enum_type file_type
,
1144 && (*name
== '=' || CONST_STRNEQ (name
, "$SYSROOT")))
1146 lang_input_statement_type
*ret
;
1147 char *sysrooted_name
1148 = concat (ld_sysroot
,
1149 name
+ (*name
== '=' ? 1 : strlen ("$SYSROOT")),
1150 (const char *) NULL
);
1152 /* We've now forcibly prepended the sysroot, making the input
1153 file independent of the context. Therefore, temporarily
1154 force a non-sysrooted context for this statement, so it won't
1155 get the sysroot prepended again when opened. (N.B. if it's a
1156 script, any child nodes with input files starting with "/"
1157 will be handled as "sysrooted" as they'll be found to be
1158 within the sysroot subdirectory.) */
1159 unsigned int outer_sysrooted
= input_flags
.sysrooted
;
1160 input_flags
.sysrooted
= 0;
1161 ret
= new_afile (sysrooted_name
, file_type
, target
);
1162 input_flags
.sysrooted
= outer_sysrooted
;
1166 return new_afile (name
, file_type
, target
);
1169 struct out_section_hash_entry
1171 struct bfd_hash_entry root
;
1172 lang_statement_union_type s
;
1175 /* The hash table. */
1177 static struct bfd_hash_table output_section_statement_table
;
1179 /* Support routines for the hash table used by lang_output_section_find,
1180 initialize the table, fill in an entry and remove the table. */
1182 static struct bfd_hash_entry
*
1183 output_section_statement_newfunc (struct bfd_hash_entry
*entry
,
1184 struct bfd_hash_table
*table
,
1187 lang_output_section_statement_type
**nextp
;
1188 struct out_section_hash_entry
*ret
;
1192 entry
= (struct bfd_hash_entry
*) bfd_hash_allocate (table
,
1198 entry
= bfd_hash_newfunc (entry
, table
, string
);
1202 ret
= (struct out_section_hash_entry
*) entry
;
1203 memset (&ret
->s
, 0, sizeof (ret
->s
));
1204 ret
->s
.header
.type
= lang_output_section_statement_enum
;
1205 ret
->s
.output_section_statement
.subsection_alignment
= NULL
;
1206 ret
->s
.output_section_statement
.section_alignment
= NULL
;
1207 ret
->s
.output_section_statement
.block_value
= 1;
1208 lang_list_init (&ret
->s
.output_section_statement
.children
);
1209 lang_statement_append (stat_ptr
, &ret
->s
, &ret
->s
.header
.next
);
1211 /* For every output section statement added to the list, except the
1212 first one, lang_os_list.tail points to the "next"
1213 field of the last element of the list. */
1214 if (lang_os_list
.head
!= NULL
)
1215 ret
->s
.output_section_statement
.prev
1216 = ((lang_output_section_statement_type
*)
1217 ((char *) lang_os_list
.tail
1218 - offsetof (lang_output_section_statement_type
, next
)));
1220 /* GCC's strict aliasing rules prevent us from just casting the
1221 address, so we store the pointer in a variable and cast that
1223 nextp
= &ret
->s
.output_section_statement
.next
;
1224 lang_statement_append (&lang_os_list
, &ret
->s
, nextp
);
1229 output_section_statement_table_init (void)
1231 if (!bfd_hash_table_init_n (&output_section_statement_table
,
1232 output_section_statement_newfunc
,
1233 sizeof (struct out_section_hash_entry
),
1235 einfo (_("%F%P: can not create hash table: %E\n"));
1239 output_section_statement_table_free (void)
1241 bfd_hash_table_free (&output_section_statement_table
);
1244 /* Build enough state so that the parser can build its tree. */
1249 obstack_begin (&stat_obstack
, 1000);
1251 stat_ptr
= &statement_list
;
1253 output_section_statement_table_init ();
1255 lang_list_init (stat_ptr
);
1257 lang_list_init (&input_file_chain
);
1258 lang_list_init (&lang_os_list
);
1259 lang_list_init (&file_chain
);
1260 first_file
= lang_add_input_file (NULL
, lang_input_file_is_marker_enum
,
1262 abs_output_section
=
1263 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
, 0, TRUE
);
1265 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
1267 asneeded_list_head
= NULL
;
1268 asneeded_list_tail
= &asneeded_list_head
;
1274 output_section_statement_table_free ();
1277 /*----------------------------------------------------------------------
1278 A region is an area of memory declared with the
1279 MEMORY { name:org=exp, len=exp ... }
1282 We maintain a list of all the regions here.
1284 If no regions are specified in the script, then the default is used
1285 which is created when looked up to be the entire data space.
1287 If create is true we are creating a region inside a MEMORY block.
1288 In this case it is probably an error to create a region that has
1289 already been created. If we are not inside a MEMORY block it is
1290 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1291 and so we issue a warning.
1293 Each region has at least one name. The first name is either
1294 DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add
1295 alias names to an existing region within a script with
1296 REGION_ALIAS (alias, region_name). Each name corresponds to at most one
1299 static lang_memory_region_type
*lang_memory_region_list
;
1300 static lang_memory_region_type
**lang_memory_region_list_tail
1301 = &lang_memory_region_list
;
1303 lang_memory_region_type
*
1304 lang_memory_region_lookup (const char *const name
, bfd_boolean create
)
1306 lang_memory_region_name
*n
;
1307 lang_memory_region_type
*r
;
1308 lang_memory_region_type
*new_region
;
1310 /* NAME is NULL for LMA memspecs if no region was specified. */
1314 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1315 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1316 if (strcmp (n
->name
, name
) == 0)
1319 einfo (_("%P:%pS: warning: redeclaration of memory region `%s'\n"),
1324 if (!create
&& strcmp (name
, DEFAULT_MEMORY_REGION
))
1325 einfo (_("%P:%pS: warning: memory region `%s' not declared\n"),
1328 new_region
= stat_alloc (sizeof (lang_memory_region_type
));
1330 new_region
->name_list
.name
= xstrdup (name
);
1331 new_region
->name_list
.next
= NULL
;
1332 new_region
->next
= NULL
;
1333 new_region
->origin_exp
= NULL
;
1334 new_region
->origin
= 0;
1335 new_region
->length_exp
= NULL
;
1336 new_region
->length
= ~(bfd_size_type
) 0;
1337 new_region
->current
= 0;
1338 new_region
->last_os
= NULL
;
1339 new_region
->flags
= 0;
1340 new_region
->not_flags
= 0;
1341 new_region
->had_full_message
= FALSE
;
1343 *lang_memory_region_list_tail
= new_region
;
1344 lang_memory_region_list_tail
= &new_region
->next
;
1350 lang_memory_region_alias (const char *alias
, const char *region_name
)
1352 lang_memory_region_name
*n
;
1353 lang_memory_region_type
*r
;
1354 lang_memory_region_type
*region
;
1356 /* The default region must be unique. This ensures that it is not necessary
1357 to iterate through the name list if someone wants the check if a region is
1358 the default memory region. */
1359 if (strcmp (region_name
, DEFAULT_MEMORY_REGION
) == 0
1360 || strcmp (alias
, DEFAULT_MEMORY_REGION
) == 0)
1361 einfo (_("%F%P:%pS: error: alias for default memory region\n"), NULL
);
1363 /* Look for the target region and check if the alias is not already
1366 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1367 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1369 if (region
== NULL
&& strcmp (n
->name
, region_name
) == 0)
1371 if (strcmp (n
->name
, alias
) == 0)
1372 einfo (_("%F%P:%pS: error: redefinition of memory region "
1377 /* Check if the target region exists. */
1379 einfo (_("%F%P:%pS: error: memory region `%s' "
1380 "for alias `%s' does not exist\n"),
1381 NULL
, region_name
, alias
);
1383 /* Add alias to region name list. */
1384 n
= stat_alloc (sizeof (lang_memory_region_name
));
1385 n
->name
= xstrdup (alias
);
1386 n
->next
= region
->name_list
.next
;
1387 region
->name_list
.next
= n
;
1390 static lang_memory_region_type
*
1391 lang_memory_default (asection
*section
)
1393 lang_memory_region_type
*p
;
1395 flagword sec_flags
= section
->flags
;
1397 /* Override SEC_DATA to mean a writable section. */
1398 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
1399 sec_flags
|= SEC_DATA
;
1401 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
1403 if ((p
->flags
& sec_flags
) != 0
1404 && (p
->not_flags
& sec_flags
) == 0)
1409 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
1412 /* Get the output section statement directly from the userdata. */
1414 lang_output_section_statement_type
*
1415 lang_output_section_get (const asection
*output_section
)
1417 return bfd_section_userdata (output_section
);
1420 /* Find or create an output_section_statement with the given NAME.
1421 If CONSTRAINT is non-zero match one with that constraint, otherwise
1422 match any non-negative constraint. If CREATE, always make a
1423 new output_section_statement for SPECIAL CONSTRAINT. */
1425 lang_output_section_statement_type
*
1426 lang_output_section_statement_lookup (const char *name
,
1430 struct out_section_hash_entry
*entry
;
1432 entry
= ((struct out_section_hash_entry
*)
1433 bfd_hash_lookup (&output_section_statement_table
, name
,
1438 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1442 if (entry
->s
.output_section_statement
.name
!= NULL
)
1444 /* We have a section of this name, but it might not have the correct
1446 struct out_section_hash_entry
*last_ent
;
1448 name
= entry
->s
.output_section_statement
.name
;
1449 if (create
&& constraint
== SPECIAL
)
1450 /* Not traversing to the end reverses the order of the second
1451 and subsequent SPECIAL sections in the hash table chain,
1452 but that shouldn't matter. */
1457 if (constraint
== entry
->s
.output_section_statement
.constraint
1459 && entry
->s
.output_section_statement
.constraint
>= 0))
1460 return &entry
->s
.output_section_statement
;
1462 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1464 while (entry
!= NULL
1465 && name
== entry
->s
.output_section_statement
.name
);
1471 = ((struct out_section_hash_entry
*)
1472 output_section_statement_newfunc (NULL
,
1473 &output_section_statement_table
,
1477 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1480 entry
->root
= last_ent
->root
;
1481 last_ent
->root
.next
= &entry
->root
;
1484 entry
->s
.output_section_statement
.name
= name
;
1485 entry
->s
.output_section_statement
.constraint
= constraint
;
1486 return &entry
->s
.output_section_statement
;
1489 /* Find the next output_section_statement with the same name as OS.
1490 If CONSTRAINT is non-zero, find one with that constraint otherwise
1491 match any non-negative constraint. */
1493 lang_output_section_statement_type
*
1494 next_matching_output_section_statement (lang_output_section_statement_type
*os
,
1497 /* All output_section_statements are actually part of a
1498 struct out_section_hash_entry. */
1499 struct out_section_hash_entry
*entry
= (struct out_section_hash_entry
*)
1501 - offsetof (struct out_section_hash_entry
, s
.output_section_statement
));
1502 const char *name
= os
->name
;
1504 ASSERT (name
== entry
->root
.string
);
1507 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1509 || name
!= entry
->s
.output_section_statement
.name
)
1512 while (constraint
!= entry
->s
.output_section_statement
.constraint
1514 || entry
->s
.output_section_statement
.constraint
< 0));
1516 return &entry
->s
.output_section_statement
;
1519 /* A variant of lang_output_section_find used by place_orphan.
1520 Returns the output statement that should precede a new output
1521 statement for SEC. If an exact match is found on certain flags,
1524 lang_output_section_statement_type
*
1525 lang_output_section_find_by_flags (const asection
*sec
,
1527 lang_output_section_statement_type
**exact
,
1528 lang_match_sec_type_func match_type
)
1530 lang_output_section_statement_type
*first
, *look
, *found
;
1531 flagword look_flags
, differ
;
1533 /* We know the first statement on this list is *ABS*. May as well
1535 first
= &lang_os_list
.head
->output_section_statement
;
1536 first
= first
->next
;
1538 /* First try for an exact match. */
1540 for (look
= first
; look
; look
= look
->next
)
1542 look_flags
= look
->flags
;
1543 if (look
->bfd_section
!= NULL
)
1545 look_flags
= look
->bfd_section
->flags
;
1546 if (match_type
&& !match_type (link_info
.output_bfd
,
1551 differ
= look_flags
^ sec_flags
;
1552 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1553 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1563 if ((sec_flags
& SEC_CODE
) != 0
1564 && (sec_flags
& SEC_ALLOC
) != 0)
1566 /* Try for a rw code section. */
1567 for (look
= first
; look
; look
= look
->next
)
1569 look_flags
= look
->flags
;
1570 if (look
->bfd_section
!= NULL
)
1572 look_flags
= look
->bfd_section
->flags
;
1573 if (match_type
&& !match_type (link_info
.output_bfd
,
1578 differ
= look_flags
^ sec_flags
;
1579 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1580 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1584 else if ((sec_flags
& SEC_READONLY
) != 0
1585 && (sec_flags
& SEC_ALLOC
) != 0)
1587 /* .rodata can go after .text, .sdata2 after .rodata. */
1588 for (look
= first
; look
; look
= look
->next
)
1590 look_flags
= look
->flags
;
1591 if (look
->bfd_section
!= NULL
)
1593 look_flags
= look
->bfd_section
->flags
;
1594 if (match_type
&& !match_type (link_info
.output_bfd
,
1599 differ
= look_flags
^ sec_flags
;
1600 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1601 | SEC_READONLY
| SEC_SMALL_DATA
))
1602 || (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1604 && !(look_flags
& SEC_SMALL_DATA
)))
1608 else if ((sec_flags
& SEC_THREAD_LOCAL
) != 0
1609 && (sec_flags
& SEC_ALLOC
) != 0)
1611 /* .tdata can go after .data, .tbss after .tdata. Treat .tbss
1612 as if it were a loaded section, and don't use match_type. */
1613 bfd_boolean seen_thread_local
= FALSE
;
1616 for (look
= first
; look
; look
= look
->next
)
1618 look_flags
= look
->flags
;
1619 if (look
->bfd_section
!= NULL
)
1620 look_flags
= look
->bfd_section
->flags
;
1622 differ
= look_flags
^ (sec_flags
| SEC_LOAD
| SEC_HAS_CONTENTS
);
1623 if (!(differ
& (SEC_THREAD_LOCAL
| SEC_ALLOC
)))
1625 /* .tdata and .tbss must be adjacent and in that order. */
1626 if (!(look_flags
& SEC_LOAD
)
1627 && (sec_flags
& SEC_LOAD
))
1628 /* ..so if we're at a .tbss section and we're placing
1629 a .tdata section stop looking and return the
1630 previous section. */
1633 seen_thread_local
= TRUE
;
1635 else if (seen_thread_local
)
1637 else if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
)))
1641 else if ((sec_flags
& SEC_SMALL_DATA
) != 0
1642 && (sec_flags
& SEC_ALLOC
) != 0)
1644 /* .sdata goes after .data, .sbss after .sdata. */
1645 for (look
= first
; look
; look
= look
->next
)
1647 look_flags
= look
->flags
;
1648 if (look
->bfd_section
!= NULL
)
1650 look_flags
= look
->bfd_section
->flags
;
1651 if (match_type
&& !match_type (link_info
.output_bfd
,
1656 differ
= look_flags
^ sec_flags
;
1657 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1658 | SEC_THREAD_LOCAL
))
1659 || ((look_flags
& SEC_SMALL_DATA
)
1660 && !(sec_flags
& SEC_HAS_CONTENTS
)))
1664 else if ((sec_flags
& SEC_HAS_CONTENTS
) != 0
1665 && (sec_flags
& SEC_ALLOC
) != 0)
1667 /* .data goes after .rodata. */
1668 for (look
= first
; look
; look
= look
->next
)
1670 look_flags
= look
->flags
;
1671 if (look
->bfd_section
!= NULL
)
1673 look_flags
= look
->bfd_section
->flags
;
1674 if (match_type
&& !match_type (link_info
.output_bfd
,
1679 differ
= look_flags
^ sec_flags
;
1680 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1681 | SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1685 else if ((sec_flags
& SEC_ALLOC
) != 0)
1687 /* .bss goes after any other alloc section. */
1688 for (look
= first
; look
; look
= look
->next
)
1690 look_flags
= look
->flags
;
1691 if (look
->bfd_section
!= NULL
)
1693 look_flags
= look
->bfd_section
->flags
;
1694 if (match_type
&& !match_type (link_info
.output_bfd
,
1699 differ
= look_flags
^ sec_flags
;
1700 if (!(differ
& SEC_ALLOC
))
1706 /* non-alloc go last. */
1707 for (look
= first
; look
; look
= look
->next
)
1709 look_flags
= look
->flags
;
1710 if (look
->bfd_section
!= NULL
)
1711 look_flags
= look
->bfd_section
->flags
;
1712 differ
= look_flags
^ sec_flags
;
1713 if (!(differ
& SEC_DEBUGGING
))
1719 if (found
|| !match_type
)
1722 return lang_output_section_find_by_flags (sec
, sec_flags
, NULL
, NULL
);
1725 /* Find the last output section before given output statement.
1726 Used by place_orphan. */
1729 output_prev_sec_find (lang_output_section_statement_type
*os
)
1731 lang_output_section_statement_type
*lookup
;
1733 for (lookup
= os
->prev
; lookup
!= NULL
; lookup
= lookup
->prev
)
1735 if (lookup
->constraint
< 0)
1738 if (lookup
->bfd_section
!= NULL
&& lookup
->bfd_section
->owner
!= NULL
)
1739 return lookup
->bfd_section
;
1745 /* Look for a suitable place for a new output section statement. The
1746 idea is to skip over anything that might be inside a SECTIONS {}
1747 statement in a script, before we find another output section
1748 statement. Assignments to "dot" before an output section statement
1749 are assumed to belong to it, except in two cases; The first
1750 assignment to dot, and assignments before non-alloc sections.
1751 Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
1752 similar assignments that set the initial address, or we might
1753 insert non-alloc note sections among assignments setting end of
1756 static lang_statement_union_type
**
1757 insert_os_after (lang_output_section_statement_type
*after
)
1759 lang_statement_union_type
**where
;
1760 lang_statement_union_type
**assign
= NULL
;
1761 bfd_boolean ignore_first
;
1763 ignore_first
= after
== &lang_os_list
.head
->output_section_statement
;
1765 for (where
= &after
->header
.next
;
1767 where
= &(*where
)->header
.next
)
1769 switch ((*where
)->header
.type
)
1771 case lang_assignment_statement_enum
:
1774 lang_assignment_statement_type
*ass
;
1776 ass
= &(*where
)->assignment_statement
;
1777 if (ass
->exp
->type
.node_class
!= etree_assert
1778 && ass
->exp
->assign
.dst
[0] == '.'
1779 && ass
->exp
->assign
.dst
[1] == 0)
1783 ignore_first
= FALSE
;
1787 case lang_wild_statement_enum
:
1788 case lang_input_section_enum
:
1789 case lang_object_symbols_statement_enum
:
1790 case lang_fill_statement_enum
:
1791 case lang_data_statement_enum
:
1792 case lang_reloc_statement_enum
:
1793 case lang_padding_statement_enum
:
1794 case lang_constructors_statement_enum
:
1796 ignore_first
= FALSE
;
1798 case lang_output_section_statement_enum
:
1801 asection
*s
= (*where
)->output_section_statement
.bfd_section
;
1804 || s
->map_head
.s
== NULL
1805 || (s
->flags
& SEC_ALLOC
) != 0)
1809 case lang_input_statement_enum
:
1810 case lang_address_statement_enum
:
1811 case lang_target_statement_enum
:
1812 case lang_output_statement_enum
:
1813 case lang_group_statement_enum
:
1814 case lang_insert_statement_enum
:
1823 lang_output_section_statement_type
*
1824 lang_insert_orphan (asection
*s
,
1825 const char *secname
,
1827 lang_output_section_statement_type
*after
,
1828 struct orphan_save
*place
,
1829 etree_type
*address
,
1830 lang_statement_list_type
*add_child
)
1832 lang_statement_list_type add
;
1833 lang_output_section_statement_type
*os
;
1834 lang_output_section_statement_type
**os_tail
;
1836 /* If we have found an appropriate place for the output section
1837 statements for this orphan, add them to our own private list,
1838 inserting them later into the global statement list. */
1841 lang_list_init (&add
);
1842 push_stat_ptr (&add
);
1845 if (bfd_link_relocatable (&link_info
)
1846 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
1847 address
= exp_intop (0);
1849 os_tail
= (lang_output_section_statement_type
**) lang_os_list
.tail
;
1850 os
= lang_enter_output_section_statement (secname
, address
, normal_section
,
1851 NULL
, NULL
, NULL
, constraint
, 0);
1853 if (add_child
== NULL
)
1854 add_child
= &os
->children
;
1855 lang_add_section (add_child
, s
, NULL
, os
);
1857 if (after
&& (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) != 0)
1859 const char *region
= (after
->region
1860 ? after
->region
->name_list
.name
1861 : DEFAULT_MEMORY_REGION
);
1862 const char *lma_region
= (after
->lma_region
1863 ? after
->lma_region
->name_list
.name
1865 lang_leave_output_section_statement (NULL
, region
, after
->phdrs
,
1869 lang_leave_output_section_statement (NULL
, DEFAULT_MEMORY_REGION
, NULL
,
1872 /* Restore the global list pointer. */
1876 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
1878 asection
*snew
, *as
;
1879 bfd_boolean place_after
= place
->stmt
== NULL
;
1880 bfd_boolean insert_after
= TRUE
;
1882 snew
= os
->bfd_section
;
1884 /* Shuffle the bfd section list to make the output file look
1885 neater. This is really only cosmetic. */
1886 if (place
->section
== NULL
1887 && after
!= &lang_os_list
.head
->output_section_statement
)
1889 asection
*bfd_section
= after
->bfd_section
;
1891 /* If the output statement hasn't been used to place any input
1892 sections (and thus doesn't have an output bfd_section),
1893 look for the closest prior output statement having an
1895 if (bfd_section
== NULL
)
1896 bfd_section
= output_prev_sec_find (after
);
1898 if (bfd_section
!= NULL
&& bfd_section
!= snew
)
1899 place
->section
= &bfd_section
->next
;
1902 if (place
->section
== NULL
)
1903 place
->section
= &link_info
.output_bfd
->sections
;
1905 as
= *place
->section
;
1909 /* Put the section at the end of the list. */
1911 /* Unlink the section. */
1912 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1914 /* Now tack it back on in the right place. */
1915 bfd_section_list_append (link_info
.output_bfd
, snew
);
1917 else if ((bfd_get_flavour (link_info
.output_bfd
)
1918 == bfd_target_elf_flavour
)
1919 && (bfd_get_flavour (s
->owner
)
1920 == bfd_target_elf_flavour
)
1921 && ((elf_section_type (s
) == SHT_NOTE
1922 && (s
->flags
& SEC_LOAD
) != 0)
1923 || (elf_section_type (as
) == SHT_NOTE
1924 && (as
->flags
& SEC_LOAD
) != 0)))
1926 /* Make sure that output note sections are grouped and sorted
1927 by alignments when inserting a note section or insert a
1928 section after a note section, */
1930 /* A specific section after which the output note section
1931 should be placed. */
1932 asection
*after_sec
;
1933 /* True if we need to insert the orphan section after a
1934 specific section to maintain output note section order. */
1935 bfd_boolean after_sec_note
= FALSE
;
1937 static asection
*first_orphan_note
= NULL
;
1939 /* Group and sort output note section by alignments in
1942 if (elf_section_type (s
) == SHT_NOTE
1943 && (s
->flags
& SEC_LOAD
) != 0)
1945 /* Search from the beginning for the last output note
1946 section with equal or larger alignments. NB: Don't
1947 place orphan note section after non-note sections. */
1949 first_orphan_note
= NULL
;
1950 for (sec
= link_info
.output_bfd
->sections
;
1952 && !bfd_is_abs_section (sec
));
1955 && elf_section_type (sec
) == SHT_NOTE
1956 && (sec
->flags
& SEC_LOAD
) != 0)
1958 if (!first_orphan_note
)
1959 first_orphan_note
= sec
;
1960 if (sec
->alignment_power
>= s
->alignment_power
)
1963 else if (first_orphan_note
)
1965 /* Stop if there is non-note section after the first
1966 orphan note section. */
1970 /* If this will be the first orphan note section, it can
1971 be placed at the default location. */
1972 after_sec_note
= first_orphan_note
!= NULL
;
1973 if (after_sec
== NULL
&& after_sec_note
)
1975 /* If all output note sections have smaller
1976 alignments, place the section before all
1977 output orphan note sections. */
1978 after_sec
= first_orphan_note
;
1979 insert_after
= FALSE
;
1982 else if (first_orphan_note
)
1984 /* Don't place non-note sections in the middle of orphan
1986 after_sec_note
= TRUE
;
1988 for (sec
= as
->next
;
1990 && !bfd_is_abs_section (sec
));
1992 if (elf_section_type (sec
) == SHT_NOTE
1993 && (sec
->flags
& SEC_LOAD
) != 0)
2001 /* Search forward to insert OS after AFTER_SEC output
2003 lang_output_section_statement_type
*stmt
, *next
;
2004 bfd_boolean found
= FALSE
;
2005 for (stmt
= after
; stmt
!= NULL
; stmt
= next
)
2010 if (stmt
->bfd_section
== after_sec
)
2020 /* If INSERT_AFTER is FALSE, place OS before
2021 AFTER_SEC output statement. */
2022 if (next
&& next
->bfd_section
== after_sec
)
2032 /* Search backward to insert OS after AFTER_SEC output
2035 for (stmt
= after
; stmt
!= NULL
; stmt
= stmt
->prev
)
2039 if (stmt
->bfd_section
== after_sec
)
2048 /* If INSERT_AFTER is FALSE, place OS before
2049 AFTER_SEC output statement. */
2050 if (stmt
->next
->bfd_section
== after_sec
)
2060 if (after_sec
== NULL
2061 || (insert_after
&& after_sec
->next
!= snew
)
2062 || (!insert_after
&& after_sec
->prev
!= snew
))
2064 /* Unlink the section. */
2065 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2067 /* Place SNEW after AFTER_SEC. If AFTER_SEC is NULL,
2072 bfd_section_list_insert_after (link_info
.output_bfd
,
2075 bfd_section_list_insert_before (link_info
.output_bfd
,
2079 bfd_section_list_prepend (link_info
.output_bfd
, snew
);
2082 else if (as
!= snew
&& as
->prev
!= snew
)
2084 /* Unlink the section. */
2085 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2087 /* Now tack it back on in the right place. */
2088 bfd_section_list_insert_before (link_info
.output_bfd
,
2092 else if (as
!= snew
&& as
->prev
!= snew
)
2094 /* Unlink the section. */
2095 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2097 /* Now tack it back on in the right place. */
2098 bfd_section_list_insert_before (link_info
.output_bfd
, as
, snew
);
2101 /* Save the end of this list. Further ophans of this type will
2102 follow the one we've just added. */
2103 place
->section
= &snew
->next
;
2105 /* The following is non-cosmetic. We try to put the output
2106 statements in some sort of reasonable order here, because they
2107 determine the final load addresses of the orphan sections.
2108 In addition, placing output statements in the wrong order may
2109 require extra segments. For instance, given a typical
2110 situation of all read-only sections placed in one segment and
2111 following that a segment containing all the read-write
2112 sections, we wouldn't want to place an orphan read/write
2113 section before or amongst the read-only ones. */
2114 if (add
.head
!= NULL
)
2116 lang_output_section_statement_type
*newly_added_os
;
2118 /* Place OS after AFTER if AFTER_NOTE is TRUE. */
2121 lang_statement_union_type
**where
= insert_os_after (after
);
2126 place
->os_tail
= &after
->next
;
2130 /* Put it after the last orphan statement we added. */
2131 *add
.tail
= *place
->stmt
;
2132 *place
->stmt
= add
.head
;
2135 /* Fix the global list pointer if we happened to tack our
2136 new list at the tail. */
2137 if (*stat_ptr
->tail
== add
.head
)
2138 stat_ptr
->tail
= add
.tail
;
2140 /* Save the end of this list. */
2141 place
->stmt
= add
.tail
;
2143 /* Do the same for the list of output section statements. */
2144 newly_added_os
= *os_tail
;
2146 newly_added_os
->prev
= (lang_output_section_statement_type
*)
2147 ((char *) place
->os_tail
2148 - offsetof (lang_output_section_statement_type
, next
));
2149 newly_added_os
->next
= *place
->os_tail
;
2150 if (newly_added_os
->next
!= NULL
)
2151 newly_added_os
->next
->prev
= newly_added_os
;
2152 *place
->os_tail
= newly_added_os
;
2153 place
->os_tail
= &newly_added_os
->next
;
2155 /* Fixing the global list pointer here is a little different.
2156 We added to the list in lang_enter_output_section_statement,
2157 trimmed off the new output_section_statment above when
2158 assigning *os_tail = NULL, but possibly added it back in
2159 the same place when assigning *place->os_tail. */
2160 if (*os_tail
== NULL
)
2161 lang_os_list
.tail
= (lang_statement_union_type
**) os_tail
;
2168 lang_print_asneeded (void)
2170 struct asneeded_minfo
*m
;
2172 if (asneeded_list_head
== NULL
)
2175 minfo (_("\nAs-needed library included to satisfy reference by file (symbol)\n\n"));
2177 for (m
= asneeded_list_head
; m
!= NULL
; m
= m
->next
)
2181 minfo ("%s", m
->soname
);
2182 len
= strlen (m
->soname
);
2196 minfo ("%pB ", m
->ref
);
2197 minfo ("(%pT)\n", m
->name
);
2202 lang_map_flags (flagword flag
)
2204 if (flag
& SEC_ALLOC
)
2207 if (flag
& SEC_CODE
)
2210 if (flag
& SEC_READONLY
)
2213 if (flag
& SEC_DATA
)
2216 if (flag
& SEC_LOAD
)
2223 lang_memory_region_type
*m
;
2224 bfd_boolean dis_header_printed
= FALSE
;
2226 LANG_FOR_EACH_INPUT_STATEMENT (file
)
2230 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
2231 || file
->flags
.just_syms
)
2234 if (config
.print_map_discarded
)
2235 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2236 if ((s
->output_section
== NULL
2237 || s
->output_section
->owner
!= link_info
.output_bfd
)
2238 && (s
->flags
& (SEC_LINKER_CREATED
| SEC_KEEP
)) == 0)
2240 if (! dis_header_printed
)
2242 fprintf (config
.map_file
, _("\nDiscarded input sections\n\n"));
2243 dis_header_printed
= TRUE
;
2246 print_input_section (s
, TRUE
);
2250 minfo (_("\nMemory Configuration\n\n"));
2251 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
2252 _("Name"), _("Origin"), _("Length"), _("Attributes"));
2254 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
2259 fprintf (config
.map_file
, "%-16s ", m
->name_list
.name
);
2261 sprintf_vma (buf
, m
->origin
);
2262 minfo ("0x%s ", buf
);
2270 minfo ("0x%V", m
->length
);
2271 if (m
->flags
|| m
->not_flags
)
2279 lang_map_flags (m
->flags
);
2285 lang_map_flags (m
->not_flags
);
2292 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
2294 if (!link_info
.reduce_memory_overheads
)
2296 obstack_begin (&map_obstack
, 1000);
2297 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
2299 expld
.phase
= lang_fixed_phase_enum
;
2300 lang_statement_iteration
++;
2301 print_statements ();
2303 ldemul_extra_map_file_text (link_info
.output_bfd
, &link_info
,
2308 sort_def_symbol (struct bfd_link_hash_entry
*hash_entry
,
2309 void *info ATTRIBUTE_UNUSED
)
2311 if ((hash_entry
->type
== bfd_link_hash_defined
2312 || hash_entry
->type
== bfd_link_hash_defweak
)
2313 && hash_entry
->u
.def
.section
->owner
!= link_info
.output_bfd
2314 && hash_entry
->u
.def
.section
->owner
!= NULL
)
2316 input_section_userdata_type
*ud
;
2317 struct map_symbol_def
*def
;
2319 ud
= bfd_section_userdata (hash_entry
->u
.def
.section
);
2322 ud
= stat_alloc (sizeof (*ud
));
2323 bfd_set_section_userdata (hash_entry
->u
.def
.section
, ud
);
2324 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2325 ud
->map_symbol_def_count
= 0;
2327 else if (!ud
->map_symbol_def_tail
)
2328 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2330 def
= (struct map_symbol_def
*) obstack_alloc (&map_obstack
, sizeof *def
);
2331 def
->entry
= hash_entry
;
2332 *(ud
->map_symbol_def_tail
) = def
;
2333 ud
->map_symbol_def_tail
= &def
->next
;
2334 ud
->map_symbol_def_count
++;
2339 /* Initialize an output section. */
2342 init_os (lang_output_section_statement_type
*s
, flagword flags
)
2344 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
2345 einfo (_("%F%P: illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
2347 if (s
->constraint
!= SPECIAL
)
2348 s
->bfd_section
= bfd_get_section_by_name (link_info
.output_bfd
, s
->name
);
2349 if (s
->bfd_section
== NULL
)
2350 s
->bfd_section
= bfd_make_section_anyway_with_flags (link_info
.output_bfd
,
2352 if (s
->bfd_section
== NULL
)
2354 einfo (_("%F%P: output format %s cannot represent section"
2355 " called %s: %E\n"),
2356 link_info
.output_bfd
->xvec
->name
, s
->name
);
2358 s
->bfd_section
->output_section
= s
->bfd_section
;
2359 s
->bfd_section
->output_offset
= 0;
2361 /* Set the userdata of the output section to the output section
2362 statement to avoid lookup. */
2363 bfd_set_section_userdata (s
->bfd_section
, s
);
2365 /* If there is a base address, make sure that any sections it might
2366 mention are initialized. */
2367 if (s
->addr_tree
!= NULL
)
2368 exp_init_os (s
->addr_tree
);
2370 if (s
->load_base
!= NULL
)
2371 exp_init_os (s
->load_base
);
2373 /* If supplied an alignment, set it. */
2374 if (s
->section_alignment
!= NULL
)
2375 s
->bfd_section
->alignment_power
= exp_get_power (s
->section_alignment
,
2376 "section alignment");
2379 /* Make sure that all output sections mentioned in an expression are
2383 exp_init_os (etree_type
*exp
)
2385 switch (exp
->type
.node_class
)
2389 case etree_provided
:
2390 exp_init_os (exp
->assign
.src
);
2394 exp_init_os (exp
->binary
.lhs
);
2395 exp_init_os (exp
->binary
.rhs
);
2399 exp_init_os (exp
->trinary
.cond
);
2400 exp_init_os (exp
->trinary
.lhs
);
2401 exp_init_os (exp
->trinary
.rhs
);
2405 exp_init_os (exp
->assert_s
.child
);
2409 exp_init_os (exp
->unary
.child
);
2413 switch (exp
->type
.node_code
)
2419 lang_output_section_statement_type
*os
;
2421 os
= lang_output_section_find (exp
->name
.name
);
2422 if (os
!= NULL
&& os
->bfd_section
== NULL
)
2434 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
2436 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
2438 /* If we are only reading symbols from this object, then we want to
2439 discard all sections. */
2440 if (entry
->flags
.just_syms
)
2442 bfd_link_just_syms (abfd
, sec
, &link_info
);
2446 /* Deal with SHF_EXCLUDE ELF sections. */
2447 if (!bfd_link_relocatable (&link_info
)
2448 && (abfd
->flags
& BFD_PLUGIN
) == 0
2449 && (sec
->flags
& (SEC_GROUP
| SEC_KEEP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
2450 sec
->output_section
= bfd_abs_section_ptr
;
2452 if (!(abfd
->flags
& DYNAMIC
))
2453 bfd_section_already_linked (abfd
, sec
, &link_info
);
2457 /* Returns true if SECTION is one we know will be discarded based on its
2458 section flags, otherwise returns false. */
2461 lang_discard_section_p (asection
*section
)
2463 bfd_boolean discard
;
2464 flagword flags
= section
->flags
;
2466 /* Discard sections marked with SEC_EXCLUDE. */
2467 discard
= (flags
& SEC_EXCLUDE
) != 0;
2469 /* Discard the group descriptor sections when we're finally placing the
2470 sections from within the group. */
2471 if ((flags
& SEC_GROUP
) != 0
2472 && link_info
.resolve_section_groups
)
2475 /* Discard debugging sections if we are stripping debugging
2477 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
2478 && (flags
& SEC_DEBUGGING
) != 0)
2484 /* The wild routines.
2486 These expand statements like *(.text) and foo.o to a list of
2487 explicit actions, like foo.o(.text), bar.o(.text) and
2488 foo.o(.text, .data). */
2490 /* Add SECTION to the output section OUTPUT. Do this by creating a
2491 lang_input_section statement which is placed at PTR. */
2494 lang_add_section (lang_statement_list_type
*ptr
,
2496 struct flag_info
*sflag_info
,
2497 lang_output_section_statement_type
*output
)
2499 flagword flags
= section
->flags
;
2501 bfd_boolean discard
;
2502 lang_input_section_type
*new_section
;
2503 bfd
*abfd
= link_info
.output_bfd
;
2505 /* Is this section one we know should be discarded? */
2506 discard
= lang_discard_section_p (section
);
2508 /* Discard input sections which are assigned to a section named
2509 DISCARD_SECTION_NAME. */
2510 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
2515 if (section
->output_section
== NULL
)
2517 /* This prevents future calls from assigning this section. */
2518 section
->output_section
= bfd_abs_section_ptr
;
2527 keep
= bfd_lookup_section_flags (&link_info
, sflag_info
, section
);
2532 if (section
->output_section
!= NULL
)
2535 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2536 to an output section, because we want to be able to include a
2537 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2538 section (I don't know why we want to do this, but we do).
2539 build_link_order in ldwrite.c handles this case by turning
2540 the embedded SEC_NEVER_LOAD section into a fill. */
2541 flags
&= ~ SEC_NEVER_LOAD
;
2543 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2544 already been processed. One reason to do this is that on pe
2545 format targets, .text$foo sections go into .text and it's odd
2546 to see .text with SEC_LINK_ONCE set. */
2547 if ((flags
& (SEC_LINK_ONCE
| SEC_GROUP
)) == (SEC_LINK_ONCE
| SEC_GROUP
))
2549 if (link_info
.resolve_section_groups
)
2550 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2552 flags
&= ~(SEC_LINK_DUPLICATES
| SEC_RELOC
);
2554 else if (!bfd_link_relocatable (&link_info
))
2555 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2557 switch (output
->sectype
)
2559 case normal_section
:
2560 case overlay_section
:
2561 case first_overlay_section
:
2563 case noalloc_section
:
2564 flags
&= ~SEC_ALLOC
;
2566 case noload_section
:
2568 flags
|= SEC_NEVER_LOAD
;
2569 /* Unfortunately GNU ld has managed to evolve two different
2570 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2571 alloc, no contents section. All others get a noload, noalloc
2573 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
2574 flags
&= ~SEC_HAS_CONTENTS
;
2576 flags
&= ~SEC_ALLOC
;
2580 if (output
->bfd_section
== NULL
)
2581 init_os (output
, flags
);
2583 /* If SEC_READONLY is not set in the input section, then clear
2584 it from the output section. */
2585 output
->bfd_section
->flags
&= flags
| ~SEC_READONLY
;
2587 if (output
->bfd_section
->linker_has_input
)
2589 /* Only set SEC_READONLY flag on the first input section. */
2590 flags
&= ~ SEC_READONLY
;
2592 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2593 if ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2594 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2595 || ((flags
& SEC_MERGE
) != 0
2596 && output
->bfd_section
->entsize
!= section
->entsize
))
2598 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2599 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2602 output
->bfd_section
->flags
|= flags
;
2604 if (!output
->bfd_section
->linker_has_input
)
2606 output
->bfd_section
->linker_has_input
= 1;
2607 /* This must happen after flags have been updated. The output
2608 section may have been created before we saw its first input
2609 section, eg. for a data statement. */
2610 bfd_init_private_section_data (section
->owner
, section
,
2611 link_info
.output_bfd
,
2612 output
->bfd_section
,
2614 if ((flags
& SEC_MERGE
) != 0)
2615 output
->bfd_section
->entsize
= section
->entsize
;
2618 if ((flags
& SEC_TIC54X_BLOCK
) != 0
2619 && bfd_get_arch (section
->owner
) == bfd_arch_tic54x
)
2621 /* FIXME: This value should really be obtained from the bfd... */
2622 output
->block_value
= 128;
2625 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2626 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2628 section
->output_section
= output
->bfd_section
;
2630 if (!map_head_is_link_order
)
2632 asection
*s
= output
->bfd_section
->map_tail
.s
;
2633 output
->bfd_section
->map_tail
.s
= section
;
2634 section
->map_head
.s
= NULL
;
2635 section
->map_tail
.s
= s
;
2637 s
->map_head
.s
= section
;
2639 output
->bfd_section
->map_head
.s
= section
;
2642 /* Add a section reference to the list. */
2643 new_section
= new_stat (lang_input_section
, ptr
);
2644 new_section
->section
= section
;
2647 /* Handle wildcard sorting. This returns the lang_input_section which
2648 should follow the one we are going to create for SECTION and FILE,
2649 based on the sorting requirements of WILD. It returns NULL if the
2650 new section should just go at the end of the current list. */
2652 static lang_statement_union_type
*
2653 wild_sort (lang_wild_statement_type
*wild
,
2654 struct wildcard_list
*sec
,
2655 lang_input_statement_type
*file
,
2658 lang_statement_union_type
*l
;
2660 if (!wild
->filenames_sorted
2661 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
2664 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
2666 lang_input_section_type
*ls
;
2668 if (l
->header
.type
!= lang_input_section_enum
)
2670 ls
= &l
->input_section
;
2672 /* Sorting by filename takes precedence over sorting by section
2675 if (wild
->filenames_sorted
)
2677 const char *fn
, *ln
;
2681 /* The PE support for the .idata section as generated by
2682 dlltool assumes that files will be sorted by the name of
2683 the archive and then the name of the file within the
2686 if (file
->the_bfd
!= NULL
2687 && file
->the_bfd
->my_archive
!= NULL
)
2689 fn
= bfd_get_filename (file
->the_bfd
->my_archive
);
2694 fn
= file
->filename
;
2698 if (ls
->section
->owner
->my_archive
!= NULL
)
2700 ln
= bfd_get_filename (ls
->section
->owner
->my_archive
);
2705 ln
= ls
->section
->owner
->filename
;
2709 i
= filename_cmp (fn
, ln
);
2718 fn
= file
->filename
;
2720 ln
= ls
->section
->owner
->filename
;
2722 i
= filename_cmp (fn
, ln
);
2730 /* Here either the files are not sorted by name, or we are
2731 looking at the sections for this file. */
2734 && sec
->spec
.sorted
!= none
2735 && sec
->spec
.sorted
!= by_none
)
2736 if (compare_section (sec
->spec
.sorted
, section
, ls
->section
) < 0)
2743 /* Expand a wild statement for a particular FILE. SECTION may be
2744 NULL, in which case it is a wild card. */
2747 output_section_callback (lang_wild_statement_type
*ptr
,
2748 struct wildcard_list
*sec
,
2750 struct flag_info
*sflag_info
,
2751 lang_input_statement_type
*file
,
2754 lang_statement_union_type
*before
;
2755 lang_output_section_statement_type
*os
;
2757 os
= (lang_output_section_statement_type
*) output
;
2759 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2760 if (unique_section_p (section
, os
))
2763 before
= wild_sort (ptr
, sec
, file
, section
);
2765 /* Here BEFORE points to the lang_input_section which
2766 should follow the one we are about to add. If BEFORE
2767 is NULL, then the section should just go at the end
2768 of the current list. */
2771 lang_add_section (&ptr
->children
, section
, sflag_info
, os
);
2774 lang_statement_list_type list
;
2775 lang_statement_union_type
**pp
;
2777 lang_list_init (&list
);
2778 lang_add_section (&list
, section
, sflag_info
, os
);
2780 /* If we are discarding the section, LIST.HEAD will
2782 if (list
.head
!= NULL
)
2784 ASSERT (list
.head
->header
.next
== NULL
);
2786 for (pp
= &ptr
->children
.head
;
2788 pp
= &(*pp
)->header
.next
)
2789 ASSERT (*pp
!= NULL
);
2791 list
.head
->header
.next
= *pp
;
2797 /* Check if all sections in a wild statement for a particular FILE
2801 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2802 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2804 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
2805 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2808 lang_output_section_statement_type
*os
;
2810 os
= (lang_output_section_statement_type
*) output
;
2812 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2813 if (unique_section_p (section
, os
))
2816 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2817 os
->all_input_readonly
= FALSE
;
2820 /* This is passed a file name which must have been seen already and
2821 added to the statement tree. We will see if it has been opened
2822 already and had its symbols read. If not then we'll read it. */
2824 static lang_input_statement_type
*
2825 lookup_name (const char *name
)
2827 lang_input_statement_type
*search
;
2829 for (search
= &input_file_chain
.head
->input_statement
;
2831 search
= search
->next_real_file
)
2833 /* Use the local_sym_name as the name of the file that has
2834 already been loaded as filename might have been transformed
2835 via the search directory lookup mechanism. */
2836 const char *filename
= search
->local_sym_name
;
2838 if (filename
!= NULL
2839 && filename_cmp (filename
, name
) == 0)
2845 /* Arrange to splice the input statement added by new_afile into
2846 statement_list after the current input_file_chain tail.
2847 We know input_file_chain is not an empty list, and that
2848 lookup_name was called via open_input_bfds. Later calls to
2849 lookup_name should always match an existing input_statement. */
2850 lang_statement_union_type
**tail
= stat_ptr
->tail
;
2851 lang_statement_union_type
**after
2852 = (void *) ((char *) input_file_chain
.tail
2853 - offsetof (lang_input_statement_type
, next_real_file
)
2854 + offsetof (lang_input_statement_type
, header
.next
));
2855 lang_statement_union_type
*rest
= *after
;
2856 stat_ptr
->tail
= after
;
2857 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2859 *stat_ptr
->tail
= rest
;
2861 stat_ptr
->tail
= tail
;
2864 /* If we have already added this file, or this file is not real
2865 don't add this file. */
2866 if (search
->flags
.loaded
|| !search
->flags
.real
)
2869 if (!load_symbols (search
, NULL
))
2875 /* Save LIST as a list of libraries whose symbols should not be exported. */
2880 struct excluded_lib
*next
;
2882 static struct excluded_lib
*excluded_libs
;
2885 add_excluded_libs (const char *list
)
2887 const char *p
= list
, *end
;
2891 struct excluded_lib
*entry
;
2892 end
= strpbrk (p
, ",:");
2894 end
= p
+ strlen (p
);
2895 entry
= (struct excluded_lib
*) xmalloc (sizeof (*entry
));
2896 entry
->next
= excluded_libs
;
2897 entry
->name
= (char *) xmalloc (end
- p
+ 1);
2898 memcpy (entry
->name
, p
, end
- p
);
2899 entry
->name
[end
- p
] = '\0';
2900 excluded_libs
= entry
;
2908 check_excluded_libs (bfd
*abfd
)
2910 struct excluded_lib
*lib
= excluded_libs
;
2914 int len
= strlen (lib
->name
);
2915 const char *filename
= lbasename (abfd
->filename
);
2917 if (strcmp (lib
->name
, "ALL") == 0)
2919 abfd
->no_export
= TRUE
;
2923 if (filename_ncmp (lib
->name
, filename
, len
) == 0
2924 && (filename
[len
] == '\0'
2925 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
2926 && filename
[len
+ 2] == '\0')))
2928 abfd
->no_export
= TRUE
;
2936 /* Get the symbols for an input file. */
2939 load_symbols (lang_input_statement_type
*entry
,
2940 lang_statement_list_type
*place
)
2944 if (entry
->flags
.loaded
)
2947 ldfile_open_file (entry
);
2949 /* Do not process further if the file was missing. */
2950 if (entry
->flags
.missing_file
)
2953 if (trace_files
|| verbose
)
2954 info_msg ("%pI\n", entry
);
2956 if (!bfd_check_format (entry
->the_bfd
, bfd_archive
)
2957 && !bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
2960 struct lang_input_statement_flags save_flags
;
2963 err
= bfd_get_error ();
2965 /* See if the emulation has some special knowledge. */
2966 if (ldemul_unrecognized_file (entry
))
2969 if (err
== bfd_error_file_ambiguously_recognized
)
2973 einfo (_("%P: %pB: file not recognized: %E;"
2974 " matching formats:"), entry
->the_bfd
);
2975 for (p
= matching
; *p
!= NULL
; p
++)
2979 else if (err
!= bfd_error_file_not_recognized
2981 einfo (_("%F%P: %pB: file not recognized: %E\n"), entry
->the_bfd
);
2983 bfd_close (entry
->the_bfd
);
2984 entry
->the_bfd
= NULL
;
2986 /* Try to interpret the file as a linker script. */
2987 save_flags
= input_flags
;
2988 ldfile_open_command_file (entry
->filename
);
2990 push_stat_ptr (place
);
2991 input_flags
.add_DT_NEEDED_for_regular
2992 = entry
->flags
.add_DT_NEEDED_for_regular
;
2993 input_flags
.add_DT_NEEDED_for_dynamic
2994 = entry
->flags
.add_DT_NEEDED_for_dynamic
;
2995 input_flags
.whole_archive
= entry
->flags
.whole_archive
;
2996 input_flags
.dynamic
= entry
->flags
.dynamic
;
2998 ldfile_assumed_script
= TRUE
;
2999 parser_input
= input_script
;
3001 ldfile_assumed_script
= FALSE
;
3003 /* missing_file is sticky. sysrooted will already have been
3004 restored when seeing EOF in yyparse, but no harm to restore
3006 save_flags
.missing_file
|= input_flags
.missing_file
;
3007 input_flags
= save_flags
;
3011 entry
->flags
.loaded
= TRUE
;
3016 if (ldemul_recognized_file (entry
))
3019 /* We don't call ldlang_add_file for an archive. Instead, the
3020 add_symbols entry point will call ldlang_add_file, via the
3021 add_archive_element callback, for each element of the archive
3023 switch (bfd_get_format (entry
->the_bfd
))
3029 if (!entry
->flags
.reload
)
3030 ldlang_add_file (entry
);
3034 check_excluded_libs (entry
->the_bfd
);
3036 bfd_set_usrdata (entry
->the_bfd
, entry
);
3037 if (entry
->flags
.whole_archive
)
3040 bfd_boolean loaded
= TRUE
;
3045 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
3050 if (!bfd_check_format (member
, bfd_object
))
3052 einfo (_("%F%P: %pB: member %pB in archive is not an object\n"),
3053 entry
->the_bfd
, member
);
3058 if (!(*link_info
.callbacks
3059 ->add_archive_element
) (&link_info
, member
,
3060 "--whole-archive", &subsbfd
))
3063 /* Potentially, the add_archive_element hook may have set a
3064 substitute BFD for us. */
3065 if (!bfd_link_add_symbols (subsbfd
, &link_info
))
3067 einfo (_("%F%P: %pB: error adding symbols: %E\n"), member
);
3072 entry
->flags
.loaded
= loaded
;
3078 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
3079 entry
->flags
.loaded
= TRUE
;
3081 einfo (_("%F%P: %pB: error adding symbols: %E\n"), entry
->the_bfd
);
3083 return entry
->flags
.loaded
;
3086 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
3087 may be NULL, indicating that it is a wildcard. Separate
3088 lang_input_section statements are created for each part of the
3089 expansion; they are added after the wild statement S. OUTPUT is
3090 the output section. */
3093 wild (lang_wild_statement_type
*s
,
3094 const char *target ATTRIBUTE_UNUSED
,
3095 lang_output_section_statement_type
*output
)
3097 struct wildcard_list
*sec
;
3099 if (s
->handler_data
[0]
3100 && s
->handler_data
[0]->spec
.sorted
== by_name
3101 && !s
->filenames_sorted
)
3103 lang_section_bst_type
*tree
;
3105 walk_wild (s
, output_section_callback_fast
, output
);
3110 output_section_callback_tree_to_list (s
, tree
, output
);
3115 walk_wild (s
, output_section_callback
, output
);
3117 if (default_common_section
== NULL
)
3118 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
3119 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
3121 /* Remember the section that common is going to in case we
3122 later get something which doesn't know where to put it. */
3123 default_common_section
= output
;
3128 /* Return TRUE iff target is the sought target. */
3131 get_target (const bfd_target
*target
, void *data
)
3133 const char *sought
= (const char *) data
;
3135 return strcmp (target
->name
, sought
) == 0;
3138 /* Like strcpy() but convert to lower case as well. */
3141 stricpy (char *dest
, const char *src
)
3145 while ((c
= *src
++) != 0)
3146 *dest
++ = TOLOWER (c
);
3151 /* Remove the first occurrence of needle (if any) in haystack
3155 strcut (char *haystack
, const char *needle
)
3157 haystack
= strstr (haystack
, needle
);
3163 for (src
= haystack
+ strlen (needle
); *src
;)
3164 *haystack
++ = *src
++;
3170 /* Compare two target format name strings.
3171 Return a value indicating how "similar" they are. */
3174 name_compare (const char *first
, const char *second
)
3180 copy1
= (char *) xmalloc (strlen (first
) + 1);
3181 copy2
= (char *) xmalloc (strlen (second
) + 1);
3183 /* Convert the names to lower case. */
3184 stricpy (copy1
, first
);
3185 stricpy (copy2
, second
);
3187 /* Remove size and endian strings from the name. */
3188 strcut (copy1
, "big");
3189 strcut (copy1
, "little");
3190 strcut (copy2
, "big");
3191 strcut (copy2
, "little");
3193 /* Return a value based on how many characters match,
3194 starting from the beginning. If both strings are
3195 the same then return 10 * their length. */
3196 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
3197 if (copy1
[result
] == 0)
3209 /* Set by closest_target_match() below. */
3210 static const bfd_target
*winner
;
3212 /* Scan all the valid bfd targets looking for one that has the endianness
3213 requirement that was specified on the command line, and is the nearest
3214 match to the original output target. */
3217 closest_target_match (const bfd_target
*target
, void *data
)
3219 const bfd_target
*original
= (const bfd_target
*) data
;
3221 if (command_line
.endian
== ENDIAN_BIG
3222 && target
->byteorder
!= BFD_ENDIAN_BIG
)
3225 if (command_line
.endian
== ENDIAN_LITTLE
3226 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
3229 /* Must be the same flavour. */
3230 if (target
->flavour
!= original
->flavour
)
3233 /* Ignore generic big and little endian elf vectors. */
3234 if (strcmp (target
->name
, "elf32-big") == 0
3235 || strcmp (target
->name
, "elf64-big") == 0
3236 || strcmp (target
->name
, "elf32-little") == 0
3237 || strcmp (target
->name
, "elf64-little") == 0)
3240 /* If we have not found a potential winner yet, then record this one. */
3247 /* Oh dear, we now have two potential candidates for a successful match.
3248 Compare their names and choose the better one. */
3249 if (name_compare (target
->name
, original
->name
)
3250 > name_compare (winner
->name
, original
->name
))
3253 /* Keep on searching until wqe have checked them all. */
3257 /* Return the BFD target format of the first input file. */
3260 get_first_input_target (void)
3262 const char *target
= NULL
;
3264 LANG_FOR_EACH_INPUT_STATEMENT (s
)
3266 if (s
->header
.type
== lang_input_statement_enum
3269 ldfile_open_file (s
);
3271 if (s
->the_bfd
!= NULL
3272 && bfd_check_format (s
->the_bfd
, bfd_object
))
3274 target
= bfd_get_target (s
->the_bfd
);
3286 lang_get_output_target (void)
3290 /* Has the user told us which output format to use? */
3291 if (output_target
!= NULL
)
3292 return output_target
;
3294 /* No - has the current target been set to something other than
3296 if (current_target
!= default_target
&& current_target
!= NULL
)
3297 return current_target
;
3299 /* No - can we determine the format of the first input file? */
3300 target
= get_first_input_target ();
3304 /* Failed - use the default output target. */
3305 return default_target
;
3308 /* Open the output file. */
3311 open_output (const char *name
)
3313 output_target
= lang_get_output_target ();
3315 /* Has the user requested a particular endianness on the command
3317 if (command_line
.endian
!= ENDIAN_UNSET
)
3319 /* Get the chosen target. */
3320 const bfd_target
*target
3321 = bfd_iterate_over_targets (get_target
, (void *) output_target
);
3323 /* If the target is not supported, we cannot do anything. */
3326 enum bfd_endian desired_endian
;
3328 if (command_line
.endian
== ENDIAN_BIG
)
3329 desired_endian
= BFD_ENDIAN_BIG
;
3331 desired_endian
= BFD_ENDIAN_LITTLE
;
3333 /* See if the target has the wrong endianness. This should
3334 not happen if the linker script has provided big and
3335 little endian alternatives, but some scrips don't do
3337 if (target
->byteorder
!= desired_endian
)
3339 /* If it does, then see if the target provides
3340 an alternative with the correct endianness. */
3341 if (target
->alternative_target
!= NULL
3342 && (target
->alternative_target
->byteorder
== desired_endian
))
3343 output_target
= target
->alternative_target
->name
;
3346 /* Try to find a target as similar as possible to
3347 the default target, but which has the desired
3348 endian characteristic. */
3349 bfd_iterate_over_targets (closest_target_match
,
3352 /* Oh dear - we could not find any targets that
3353 satisfy our requirements. */
3355 einfo (_("%P: warning: could not find any targets"
3356 " that match endianness requirement\n"));
3358 output_target
= winner
->name
;
3364 link_info
.output_bfd
= bfd_openw (name
, output_target
);
3366 if (link_info
.output_bfd
== NULL
)
3368 if (bfd_get_error () == bfd_error_invalid_target
)
3369 einfo (_("%F%P: target %s not found\n"), output_target
);
3371 einfo (_("%F%P: cannot open output file %s: %E\n"), name
);
3374 delete_output_file_on_failure
= TRUE
;
3376 if (!bfd_set_format (link_info
.output_bfd
, bfd_object
))
3377 einfo (_("%F%P: %s: can not make object file: %E\n"), name
);
3378 if (!bfd_set_arch_mach (link_info
.output_bfd
,
3379 ldfile_output_architecture
,
3380 ldfile_output_machine
))
3381 einfo (_("%F%P: %s: can not set architecture: %E\n"), name
);
3383 link_info
.hash
= bfd_link_hash_table_create (link_info
.output_bfd
);
3384 if (link_info
.hash
== NULL
)
3385 einfo (_("%F%P: can not create hash table: %E\n"));
3387 bfd_set_gp_size (link_info
.output_bfd
, g_switch_value
);
3391 ldlang_open_output (lang_statement_union_type
*statement
)
3393 switch (statement
->header
.type
)
3395 case lang_output_statement_enum
:
3396 ASSERT (link_info
.output_bfd
== NULL
);
3397 open_output (statement
->output_statement
.name
);
3398 ldemul_set_output_arch ();
3399 if (config
.magic_demand_paged
3400 && !bfd_link_relocatable (&link_info
))
3401 link_info
.output_bfd
->flags
|= D_PAGED
;
3403 link_info
.output_bfd
->flags
&= ~D_PAGED
;
3404 if (config
.text_read_only
)
3405 link_info
.output_bfd
->flags
|= WP_TEXT
;
3407 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
3408 if (link_info
.traditional_format
)
3409 link_info
.output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
3411 link_info
.output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
3414 case lang_target_statement_enum
:
3415 current_target
= statement
->target_statement
.target
;
3425 unsigned x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3426 ldfile_output_machine
);
3429 while ((x
& 1) == 0)
3437 /* Open all the input files. */
3441 OPEN_BFD_NORMAL
= 0,
3445 #ifdef ENABLE_PLUGINS
3446 static lang_input_statement_type
*plugin_insert
= NULL
;
3447 static struct bfd_link_hash_entry
*plugin_undefs
= NULL
;
3451 open_input_bfds (lang_statement_union_type
*s
, enum open_bfd_mode mode
)
3453 for (; s
!= NULL
; s
= s
->header
.next
)
3455 switch (s
->header
.type
)
3457 case lang_constructors_statement_enum
:
3458 open_input_bfds (constructor_list
.head
, mode
);
3460 case lang_output_section_statement_enum
:
3461 open_input_bfds (s
->output_section_statement
.children
.head
, mode
);
3463 case lang_wild_statement_enum
:
3464 /* Maybe we should load the file's symbols. */
3465 if ((mode
& OPEN_BFD_RESCAN
) == 0
3466 && s
->wild_statement
.filename
3467 && !wildcardp (s
->wild_statement
.filename
)
3468 && !archive_path (s
->wild_statement
.filename
))
3469 lookup_name (s
->wild_statement
.filename
);
3470 open_input_bfds (s
->wild_statement
.children
.head
, mode
);
3472 case lang_group_statement_enum
:
3474 struct bfd_link_hash_entry
*undefs
;
3475 #ifdef ENABLE_PLUGINS
3476 lang_input_statement_type
*plugin_insert_save
;
3479 /* We must continually search the entries in the group
3480 until no new symbols are added to the list of undefined
3485 #ifdef ENABLE_PLUGINS
3486 plugin_insert_save
= plugin_insert
;
3488 undefs
= link_info
.hash
->undefs_tail
;
3489 open_input_bfds (s
->group_statement
.children
.head
,
3490 mode
| OPEN_BFD_FORCE
);
3492 while (undefs
!= link_info
.hash
->undefs_tail
3493 #ifdef ENABLE_PLUGINS
3494 /* Objects inserted by a plugin, which are loaded
3495 before we hit this loop, may have added new
3497 || (plugin_insert
!= plugin_insert_save
&& plugin_undefs
)
3502 case lang_target_statement_enum
:
3503 current_target
= s
->target_statement
.target
;
3505 case lang_input_statement_enum
:
3506 if (s
->input_statement
.flags
.real
)
3508 lang_statement_union_type
**os_tail
;
3509 lang_statement_list_type add
;
3512 s
->input_statement
.target
= current_target
;
3514 /* If we are being called from within a group, and this
3515 is an archive which has already been searched, then
3516 force it to be researched unless the whole archive
3517 has been loaded already. Do the same for a rescan.
3518 Likewise reload --as-needed shared libs. */
3519 if (mode
!= OPEN_BFD_NORMAL
3520 #ifdef ENABLE_PLUGINS
3521 && ((mode
& OPEN_BFD_RESCAN
) == 0
3522 || plugin_insert
== NULL
)
3524 && s
->input_statement
.flags
.loaded
3525 && (abfd
= s
->input_statement
.the_bfd
) != NULL
3526 && ((bfd_get_format (abfd
) == bfd_archive
3527 && !s
->input_statement
.flags
.whole_archive
)
3528 || (bfd_get_format (abfd
) == bfd_object
3529 && ((abfd
->flags
) & DYNAMIC
) != 0
3530 && s
->input_statement
.flags
.add_DT_NEEDED_for_regular
3531 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3532 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)))
3534 s
->input_statement
.flags
.loaded
= FALSE
;
3535 s
->input_statement
.flags
.reload
= TRUE
;
3538 os_tail
= lang_os_list
.tail
;
3539 lang_list_init (&add
);
3541 if (!load_symbols (&s
->input_statement
, &add
))
3542 config
.make_executable
= FALSE
;
3544 if (add
.head
!= NULL
)
3546 /* If this was a script with output sections then
3547 tack any added statements on to the end of the
3548 list. This avoids having to reorder the output
3549 section statement list. Very likely the user
3550 forgot -T, and whatever we do here will not meet
3551 naive user expectations. */
3552 if (os_tail
!= lang_os_list
.tail
)
3554 einfo (_("%P: warning: %s contains output sections;"
3555 " did you forget -T?\n"),
3556 s
->input_statement
.filename
);
3557 *stat_ptr
->tail
= add
.head
;
3558 stat_ptr
->tail
= add
.tail
;
3562 *add
.tail
= s
->header
.next
;
3563 s
->header
.next
= add
.head
;
3567 #ifdef ENABLE_PLUGINS
3568 /* If we have found the point at which a plugin added new
3569 files, clear plugin_insert to enable archive rescan. */
3570 if (&s
->input_statement
== plugin_insert
)
3571 plugin_insert
= NULL
;
3574 case lang_assignment_statement_enum
:
3575 if (s
->assignment_statement
.exp
->type
.node_class
!= etree_assert
)
3576 exp_fold_tree_no_dot (s
->assignment_statement
.exp
);
3583 /* Exit if any of the files were missing. */
3584 if (input_flags
.missing_file
)
3588 /* Add the supplied name to the symbol table as an undefined reference.
3589 This is a two step process as the symbol table doesn't even exist at
3590 the time the ld command line is processed. First we put the name
3591 on a list, then, once the output file has been opened, transfer the
3592 name to the symbol table. */
3594 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3596 #define ldlang_undef_chain_list_head entry_symbol.next
3599 ldlang_add_undef (const char *const name
, bfd_boolean cmdline
)
3601 ldlang_undef_chain_list_type
*new_undef
;
3603 undef_from_cmdline
= undef_from_cmdline
|| cmdline
;
3604 new_undef
= stat_alloc (sizeof (*new_undef
));
3605 new_undef
->next
= ldlang_undef_chain_list_head
;
3606 ldlang_undef_chain_list_head
= new_undef
;
3608 new_undef
->name
= xstrdup (name
);
3610 if (link_info
.output_bfd
!= NULL
)
3611 insert_undefined (new_undef
->name
);
3614 /* Insert NAME as undefined in the symbol table. */
3617 insert_undefined (const char *name
)
3619 struct bfd_link_hash_entry
*h
;
3621 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
3623 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
3624 if (h
->type
== bfd_link_hash_new
)
3626 h
->type
= bfd_link_hash_undefined
;
3627 h
->u
.undef
.abfd
= NULL
;
3628 h
->non_ir_ref_regular
= TRUE
;
3629 if (is_elf_hash_table (link_info
.hash
))
3630 ((struct elf_link_hash_entry
*) h
)->mark
= 1;
3631 bfd_link_add_undef (link_info
.hash
, h
);
3635 /* Run through the list of undefineds created above and place them
3636 into the linker hash table as undefined symbols belonging to the
3640 lang_place_undefineds (void)
3642 ldlang_undef_chain_list_type
*ptr
;
3644 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3645 insert_undefined (ptr
->name
);
3648 /* Structure used to build the list of symbols that the user has required
3651 struct require_defined_symbol
3654 struct require_defined_symbol
*next
;
3657 /* The list of symbols that the user has required be defined. */
3659 static struct require_defined_symbol
*require_defined_symbol_list
;
3661 /* Add a new symbol NAME to the list of symbols that are required to be
3665 ldlang_add_require_defined (const char *const name
)
3667 struct require_defined_symbol
*ptr
;
3669 ldlang_add_undef (name
, TRUE
);
3670 ptr
= stat_alloc (sizeof (*ptr
));
3671 ptr
->next
= require_defined_symbol_list
;
3672 ptr
->name
= strdup (name
);
3673 require_defined_symbol_list
= ptr
;
3676 /* Check that all symbols the user required to be defined, are defined,
3677 raise an error if we find a symbol that is not defined. */
3680 ldlang_check_require_defined_symbols (void)
3682 struct require_defined_symbol
*ptr
;
3684 for (ptr
= require_defined_symbol_list
; ptr
!= NULL
; ptr
= ptr
->next
)
3686 struct bfd_link_hash_entry
*h
;
3688 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
,
3689 FALSE
, FALSE
, TRUE
);
3691 || (h
->type
!= bfd_link_hash_defined
3692 && h
->type
!= bfd_link_hash_defweak
))
3693 einfo(_("%X%P: required symbol `%s' not defined\n"), ptr
->name
);
3697 /* Check for all readonly or some readwrite sections. */
3700 check_input_sections
3701 (lang_statement_union_type
*s
,
3702 lang_output_section_statement_type
*output_section_statement
)
3704 for (; s
!= NULL
; s
= s
->header
.next
)
3706 switch (s
->header
.type
)
3708 case lang_wild_statement_enum
:
3709 walk_wild (&s
->wild_statement
, check_section_callback
,
3710 output_section_statement
);
3711 if (!output_section_statement
->all_input_readonly
)
3714 case lang_constructors_statement_enum
:
3715 check_input_sections (constructor_list
.head
,
3716 output_section_statement
);
3717 if (!output_section_statement
->all_input_readonly
)
3720 case lang_group_statement_enum
:
3721 check_input_sections (s
->group_statement
.children
.head
,
3722 output_section_statement
);
3723 if (!output_section_statement
->all_input_readonly
)
3732 /* Update wildcard statements if needed. */
3735 update_wild_statements (lang_statement_union_type
*s
)
3737 struct wildcard_list
*sec
;
3739 switch (sort_section
)
3749 for (; s
!= NULL
; s
= s
->header
.next
)
3751 switch (s
->header
.type
)
3756 case lang_wild_statement_enum
:
3757 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
3759 /* Don't sort .init/.fini sections. */
3760 if (strcmp (sec
->spec
.name
, ".init") != 0
3761 && strcmp (sec
->spec
.name
, ".fini") != 0)
3762 switch (sec
->spec
.sorted
)
3765 sec
->spec
.sorted
= sort_section
;
3768 if (sort_section
== by_alignment
)
3769 sec
->spec
.sorted
= by_name_alignment
;
3772 if (sort_section
== by_name
)
3773 sec
->spec
.sorted
= by_alignment_name
;
3780 case lang_constructors_statement_enum
:
3781 update_wild_statements (constructor_list
.head
);
3784 case lang_output_section_statement_enum
:
3785 update_wild_statements
3786 (s
->output_section_statement
.children
.head
);
3789 case lang_group_statement_enum
:
3790 update_wild_statements (s
->group_statement
.children
.head
);
3798 /* Open input files and attach to output sections. */
3801 map_input_to_output_sections
3802 (lang_statement_union_type
*s
, const char *target
,
3803 lang_output_section_statement_type
*os
)
3805 for (; s
!= NULL
; s
= s
->header
.next
)
3807 lang_output_section_statement_type
*tos
;
3810 switch (s
->header
.type
)
3812 case lang_wild_statement_enum
:
3813 wild (&s
->wild_statement
, target
, os
);
3815 case lang_constructors_statement_enum
:
3816 map_input_to_output_sections (constructor_list
.head
,
3820 case lang_output_section_statement_enum
:
3821 tos
= &s
->output_section_statement
;
3822 if (tos
->constraint
!= 0)
3824 if (tos
->constraint
!= ONLY_IF_RW
3825 && tos
->constraint
!= ONLY_IF_RO
)
3827 tos
->all_input_readonly
= TRUE
;
3828 check_input_sections (tos
->children
.head
, tos
);
3829 if (tos
->all_input_readonly
!= (tos
->constraint
== ONLY_IF_RO
))
3831 tos
->constraint
= -1;
3835 map_input_to_output_sections (tos
->children
.head
,
3839 case lang_output_statement_enum
:
3841 case lang_target_statement_enum
:
3842 target
= s
->target_statement
.target
;
3844 case lang_group_statement_enum
:
3845 map_input_to_output_sections (s
->group_statement
.children
.head
,
3849 case lang_data_statement_enum
:
3850 /* Make sure that any sections mentioned in the expression
3852 exp_init_os (s
->data_statement
.exp
);
3853 /* The output section gets CONTENTS, ALLOC and LOAD, but
3854 these may be overridden by the script. */
3855 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
;
3856 switch (os
->sectype
)
3858 case normal_section
:
3859 case overlay_section
:
3860 case first_overlay_section
:
3862 case noalloc_section
:
3863 flags
= SEC_HAS_CONTENTS
;
3865 case noload_section
:
3866 if (bfd_get_flavour (link_info
.output_bfd
)
3867 == bfd_target_elf_flavour
)
3868 flags
= SEC_NEVER_LOAD
| SEC_ALLOC
;
3870 flags
= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
;
3873 if (os
->bfd_section
== NULL
)
3874 init_os (os
, flags
);
3876 os
->bfd_section
->flags
|= flags
;
3878 case lang_input_section_enum
:
3880 case lang_fill_statement_enum
:
3881 case lang_object_symbols_statement_enum
:
3882 case lang_reloc_statement_enum
:
3883 case lang_padding_statement_enum
:
3884 case lang_input_statement_enum
:
3885 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3888 case lang_assignment_statement_enum
:
3889 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3892 /* Make sure that any sections mentioned in the assignment
3894 exp_init_os (s
->assignment_statement
.exp
);
3896 case lang_address_statement_enum
:
3897 /* Mark the specified section with the supplied address.
3898 If this section was actually a segment marker, then the
3899 directive is ignored if the linker script explicitly
3900 processed the segment marker. Originally, the linker
3901 treated segment directives (like -Ttext on the
3902 command-line) as section directives. We honor the
3903 section directive semantics for backwards compatibility;
3904 linker scripts that do not specifically check for
3905 SEGMENT_START automatically get the old semantics. */
3906 if (!s
->address_statement
.segment
3907 || !s
->address_statement
.segment
->used
)
3909 const char *name
= s
->address_statement
.section_name
;
3911 /* Create the output section statement here so that
3912 orphans with a set address will be placed after other
3913 script sections. If we let the orphan placement code
3914 place them in amongst other sections then the address
3915 will affect following script sections, which is
3916 likely to surprise naive users. */
3917 tos
= lang_output_section_statement_lookup (name
, 0, TRUE
);
3918 tos
->addr_tree
= s
->address_statement
.address
;
3919 if (tos
->bfd_section
== NULL
)
3923 case lang_insert_statement_enum
:
3929 /* An insert statement snips out all the linker statements from the
3930 start of the list and places them after the output section
3931 statement specified by the insert. This operation is complicated
3932 by the fact that we keep a doubly linked list of output section
3933 statements as well as the singly linked list of all statements.
3934 FIXME someday: Twiddling with the list not only moves statements
3935 from the user's script but also input and group statements that are
3936 built from command line object files and --start-group. We only
3937 get away with this because the list pointers used by file_chain
3938 and input_file_chain are not reordered, and processing via
3939 statement_list after this point mostly ignores input statements.
3940 One exception is the map file, where LOAD and START GROUP/END GROUP
3941 can end up looking odd. */
3944 process_insert_statements (lang_statement_union_type
**start
)
3946 lang_statement_union_type
**s
;
3947 lang_output_section_statement_type
*first_os
= NULL
;
3948 lang_output_section_statement_type
*last_os
= NULL
;
3949 lang_output_section_statement_type
*os
;
3954 if ((*s
)->header
.type
== lang_output_section_statement_enum
)
3956 /* Keep pointers to the first and last output section
3957 statement in the sequence we may be about to move. */
3958 os
= &(*s
)->output_section_statement
;
3960 ASSERT (last_os
== NULL
|| last_os
->next
== os
);
3963 /* Set constraint negative so that lang_output_section_find
3964 won't match this output section statement. At this
3965 stage in linking constraint has values in the range
3966 [-1, ONLY_IN_RW]. */
3967 last_os
->constraint
= -2 - last_os
->constraint
;
3968 if (first_os
== NULL
)
3971 else if ((*s
)->header
.type
== lang_group_statement_enum
)
3973 /* A user might put -T between --start-group and
3974 --end-group. One way this odd construct might arise is
3975 from a wrapper around ld to change library search
3976 behaviour. For example:
3978 exec real_ld --start-group "$@" --end-group
3979 This isn't completely unreasonable so go looking inside a
3980 group statement for insert statements. */
3981 process_insert_statements (&(*s
)->group_statement
.children
.head
);
3983 else if ((*s
)->header
.type
== lang_insert_statement_enum
)
3985 lang_insert_statement_type
*i
= &(*s
)->insert_statement
;
3986 lang_output_section_statement_type
*where
;
3987 lang_statement_union_type
**ptr
;
3988 lang_statement_union_type
*first
;
3990 where
= lang_output_section_find (i
->where
);
3991 if (where
!= NULL
&& i
->is_before
)
3994 where
= where
->prev
;
3995 while (where
!= NULL
&& where
->constraint
< 0);
3999 einfo (_("%F%P: %s not found for insert\n"), i
->where
);
4003 /* Deal with reordering the output section statement list. */
4004 if (last_os
!= NULL
)
4006 asection
*first_sec
, *last_sec
;
4007 struct lang_output_section_statement_struct
**next
;
4009 /* Snip out the output sections we are moving. */
4010 first_os
->prev
->next
= last_os
->next
;
4011 if (last_os
->next
== NULL
)
4013 next
= &first_os
->prev
->next
;
4014 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4017 last_os
->next
->prev
= first_os
->prev
;
4018 /* Add them in at the new position. */
4019 last_os
->next
= where
->next
;
4020 if (where
->next
== NULL
)
4022 next
= &last_os
->next
;
4023 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4026 where
->next
->prev
= last_os
;
4027 first_os
->prev
= where
;
4028 where
->next
= first_os
;
4030 /* Move the bfd sections in the same way. */
4033 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4035 os
->constraint
= -2 - os
->constraint
;
4036 if (os
->bfd_section
!= NULL
4037 && os
->bfd_section
->owner
!= NULL
)
4039 last_sec
= os
->bfd_section
;
4040 if (first_sec
== NULL
)
4041 first_sec
= last_sec
;
4046 if (last_sec
!= NULL
)
4048 asection
*sec
= where
->bfd_section
;
4050 sec
= output_prev_sec_find (where
);
4052 /* The place we want to insert must come after the
4053 sections we are moving. So if we find no
4054 section or if the section is the same as our
4055 last section, then no move is needed. */
4056 if (sec
!= NULL
&& sec
!= last_sec
)
4058 /* Trim them off. */
4059 if (first_sec
->prev
!= NULL
)
4060 first_sec
->prev
->next
= last_sec
->next
;
4062 link_info
.output_bfd
->sections
= last_sec
->next
;
4063 if (last_sec
->next
!= NULL
)
4064 last_sec
->next
->prev
= first_sec
->prev
;
4066 link_info
.output_bfd
->section_last
= first_sec
->prev
;
4068 last_sec
->next
= sec
->next
;
4069 if (sec
->next
!= NULL
)
4070 sec
->next
->prev
= last_sec
;
4072 link_info
.output_bfd
->section_last
= last_sec
;
4073 first_sec
->prev
= sec
;
4074 sec
->next
= first_sec
;
4082 ptr
= insert_os_after (where
);
4083 /* Snip everything from the start of the list, up to and
4084 including the insert statement we are currently processing. */
4086 *start
= (*s
)->header
.next
;
4087 /* Add them back where they belong, minus the insert. */
4090 statement_list
.tail
= s
;
4095 s
= &(*s
)->header
.next
;
4098 /* Undo constraint twiddling. */
4099 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4101 os
->constraint
= -2 - os
->constraint
;
4107 /* An output section might have been removed after its statement was
4108 added. For example, ldemul_before_allocation can remove dynamic
4109 sections if they turn out to be not needed. Clean them up here. */
4112 strip_excluded_output_sections (void)
4114 lang_output_section_statement_type
*os
;
4116 /* Run lang_size_sections (if not already done). */
4117 if (expld
.phase
!= lang_mark_phase_enum
)
4119 expld
.phase
= lang_mark_phase_enum
;
4120 expld
.dataseg
.phase
= exp_seg_none
;
4121 one_lang_size_sections_pass (NULL
, FALSE
);
4122 lang_reset_memory_regions ();
4125 for (os
= &lang_os_list
.head
->output_section_statement
;
4129 asection
*output_section
;
4130 bfd_boolean exclude
;
4132 if (os
->constraint
< 0)
4135 output_section
= os
->bfd_section
;
4136 if (output_section
== NULL
)
4139 exclude
= (output_section
->rawsize
== 0
4140 && (output_section
->flags
& SEC_KEEP
) == 0
4141 && !bfd_section_removed_from_list (link_info
.output_bfd
,
4144 /* Some sections have not yet been sized, notably .gnu.version,
4145 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
4146 input sections, so don't drop output sections that have such
4147 input sections unless they are also marked SEC_EXCLUDE. */
4148 if (exclude
&& output_section
->map_head
.s
!= NULL
)
4152 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
4153 if ((s
->flags
& SEC_EXCLUDE
) == 0
4154 && ((s
->flags
& SEC_LINKER_CREATED
) != 0
4155 || link_info
.emitrelocations
))
4164 /* We don't set bfd_section to NULL since bfd_section of the
4165 removed output section statement may still be used. */
4166 if (!os
->update_dot
)
4168 output_section
->flags
|= SEC_EXCLUDE
;
4169 bfd_section_list_remove (link_info
.output_bfd
, output_section
);
4170 link_info
.output_bfd
->section_count
--;
4175 /* Called from ldwrite to clear out asection.map_head and
4176 asection.map_tail for use as link_orders in ldwrite. */
4179 lang_clear_os_map (void)
4181 lang_output_section_statement_type
*os
;
4183 if (map_head_is_link_order
)
4186 for (os
= &lang_os_list
.head
->output_section_statement
;
4190 asection
*output_section
;
4192 if (os
->constraint
< 0)
4195 output_section
= os
->bfd_section
;
4196 if (output_section
== NULL
)
4199 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
4200 output_section
->map_head
.link_order
= NULL
;
4201 output_section
->map_tail
.link_order
= NULL
;
4204 /* Stop future calls to lang_add_section from messing with map_head
4205 and map_tail link_order fields. */
4206 map_head_is_link_order
= TRUE
;
4210 print_output_section_statement
4211 (lang_output_section_statement_type
*output_section_statement
)
4213 asection
*section
= output_section_statement
->bfd_section
;
4216 if (output_section_statement
!= abs_output_section
)
4218 minfo ("\n%s", output_section_statement
->name
);
4220 if (section
!= NULL
)
4222 print_dot
= section
->vma
;
4224 len
= strlen (output_section_statement
->name
);
4225 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4230 while (len
< SECTION_NAME_MAP_LENGTH
)
4236 minfo ("0x%V %W", section
->vma
, TO_ADDR (section
->size
));
4238 if (section
->vma
!= section
->lma
)
4239 minfo (_(" load address 0x%V"), section
->lma
);
4241 if (output_section_statement
->update_dot_tree
!= NULL
)
4242 exp_fold_tree (output_section_statement
->update_dot_tree
,
4243 bfd_abs_section_ptr
, &print_dot
);
4249 print_statement_list (output_section_statement
->children
.head
,
4250 output_section_statement
);
4254 print_assignment (lang_assignment_statement_type
*assignment
,
4255 lang_output_section_statement_type
*output_section
)
4262 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4265 if (assignment
->exp
->type
.node_class
== etree_assert
)
4268 tree
= assignment
->exp
->assert_s
.child
;
4272 const char *dst
= assignment
->exp
->assign
.dst
;
4274 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
4275 tree
= assignment
->exp
;
4278 osec
= output_section
->bfd_section
;
4280 osec
= bfd_abs_section_ptr
;
4282 if (assignment
->exp
->type
.node_class
!= etree_provide
)
4283 exp_fold_tree (tree
, osec
, &print_dot
);
4285 expld
.result
.valid_p
= FALSE
;
4287 if (expld
.result
.valid_p
)
4291 if (assignment
->exp
->type
.node_class
== etree_assert
4293 || expld
.assign_name
!= NULL
)
4295 value
= expld
.result
.value
;
4297 if (expld
.result
.section
!= NULL
)
4298 value
+= expld
.result
.section
->vma
;
4300 minfo ("0x%V", value
);
4306 struct bfd_link_hash_entry
*h
;
4308 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
4309 FALSE
, FALSE
, TRUE
);
4311 && (h
->type
== bfd_link_hash_defined
4312 || h
->type
== bfd_link_hash_defweak
))
4314 value
= h
->u
.def
.value
;
4315 value
+= h
->u
.def
.section
->output_section
->vma
;
4316 value
+= h
->u
.def
.section
->output_offset
;
4318 minfo ("[0x%V]", value
);
4321 minfo ("[unresolved]");
4326 if (assignment
->exp
->type
.node_class
== etree_provide
)
4327 minfo ("[!provide]");
4334 expld
.assign_name
= NULL
;
4337 exp_print_tree (assignment
->exp
);
4342 print_input_statement (lang_input_statement_type
*statm
)
4344 if (statm
->filename
!= NULL
)
4345 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
4348 /* Print all symbols defined in a particular section. This is called
4349 via bfd_link_hash_traverse, or by print_all_symbols. */
4352 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
4354 asection
*sec
= (asection
*) ptr
;
4356 if ((hash_entry
->type
== bfd_link_hash_defined
4357 || hash_entry
->type
== bfd_link_hash_defweak
)
4358 && sec
== hash_entry
->u
.def
.section
)
4362 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4365 (hash_entry
->u
.def
.value
4366 + hash_entry
->u
.def
.section
->output_offset
4367 + hash_entry
->u
.def
.section
->output_section
->vma
));
4369 minfo (" %pT\n", hash_entry
->root
.string
);
4376 hash_entry_addr_cmp (const void *a
, const void *b
)
4378 const struct bfd_link_hash_entry
*l
= *(const struct bfd_link_hash_entry
**)a
;
4379 const struct bfd_link_hash_entry
*r
= *(const struct bfd_link_hash_entry
**)b
;
4381 if (l
->u
.def
.value
< r
->u
.def
.value
)
4383 else if (l
->u
.def
.value
> r
->u
.def
.value
)
4390 print_all_symbols (asection
*sec
)
4392 input_section_userdata_type
*ud
= bfd_section_userdata (sec
);
4393 struct map_symbol_def
*def
;
4394 struct bfd_link_hash_entry
**entries
;
4400 *ud
->map_symbol_def_tail
= 0;
4402 /* Sort the symbols by address. */
4403 entries
= (struct bfd_link_hash_entry
**)
4404 obstack_alloc (&map_obstack
,
4405 ud
->map_symbol_def_count
* sizeof (*entries
));
4407 for (i
= 0, def
= ud
->map_symbol_def_head
; def
; def
= def
->next
, i
++)
4408 entries
[i
] = def
->entry
;
4410 qsort (entries
, ud
->map_symbol_def_count
, sizeof (*entries
),
4411 hash_entry_addr_cmp
);
4413 /* Print the symbols. */
4414 for (i
= 0; i
< ud
->map_symbol_def_count
; i
++)
4415 print_one_symbol (entries
[i
], sec
);
4417 obstack_free (&map_obstack
, entries
);
4420 /* Print information about an input section to the map file. */
4423 print_input_section (asection
*i
, bfd_boolean is_discarded
)
4425 bfd_size_type size
= i
->size
;
4432 minfo ("%s", i
->name
);
4434 len
= 1 + strlen (i
->name
);
4435 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4440 while (len
< SECTION_NAME_MAP_LENGTH
)
4446 if (i
->output_section
!= NULL
4447 && i
->output_section
->owner
== link_info
.output_bfd
)
4448 addr
= i
->output_section
->vma
+ i
->output_offset
;
4456 minfo ("0x%V %W %pB\n", addr
, size
, i
->owner
);
4458 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
4460 len
= SECTION_NAME_MAP_LENGTH
+ 3;
4472 minfo (_("%W (size before relaxing)\n"), i
->rawsize
);
4475 if (i
->output_section
!= NULL
4476 && i
->output_section
->owner
== link_info
.output_bfd
)
4478 if (link_info
.reduce_memory_overheads
)
4479 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, i
);
4481 print_all_symbols (i
);
4483 /* Update print_dot, but make sure that we do not move it
4484 backwards - this could happen if we have overlays and a
4485 later overlay is shorter than an earier one. */
4486 if (addr
+ TO_ADDR (size
) > print_dot
)
4487 print_dot
= addr
+ TO_ADDR (size
);
4492 print_fill_statement (lang_fill_statement_type
*fill
)
4496 fputs (" FILL mask 0x", config
.map_file
);
4497 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
4498 fprintf (config
.map_file
, "%02x", *p
);
4499 fputs ("\n", config
.map_file
);
4503 print_data_statement (lang_data_statement_type
*data
)
4511 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4514 addr
= data
->output_offset
;
4515 if (data
->output_section
!= NULL
)
4516 addr
+= data
->output_section
->vma
;
4544 if (size
< TO_SIZE ((unsigned) 1))
4545 size
= TO_SIZE ((unsigned) 1);
4546 minfo ("0x%V %W %s 0x%v", addr
, TO_ADDR (size
), name
, data
->value
);
4548 if (data
->exp
->type
.node_class
!= etree_value
)
4551 exp_print_tree (data
->exp
);
4556 print_dot
= addr
+ TO_ADDR (size
);
4559 /* Print an address statement. These are generated by options like
4563 print_address_statement (lang_address_statement_type
*address
)
4565 minfo (_("Address of section %s set to "), address
->section_name
);
4566 exp_print_tree (address
->address
);
4570 /* Print a reloc statement. */
4573 print_reloc_statement (lang_reloc_statement_type
*reloc
)
4580 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4583 addr
= reloc
->output_offset
;
4584 if (reloc
->output_section
!= NULL
)
4585 addr
+= reloc
->output_section
->vma
;
4587 size
= bfd_get_reloc_size (reloc
->howto
);
4589 minfo ("0x%V %W RELOC %s ", addr
, TO_ADDR (size
), reloc
->howto
->name
);
4591 if (reloc
->name
!= NULL
)
4592 minfo ("%s+", reloc
->name
);
4594 minfo ("%s+", reloc
->section
->name
);
4596 exp_print_tree (reloc
->addend_exp
);
4600 print_dot
= addr
+ TO_ADDR (size
);
4604 print_padding_statement (lang_padding_statement_type
*s
)
4612 len
= sizeof " *fill*" - 1;
4613 while (len
< SECTION_NAME_MAP_LENGTH
)
4619 addr
= s
->output_offset
;
4620 if (s
->output_section
!= NULL
)
4621 addr
+= s
->output_section
->vma
;
4622 minfo ("0x%V %W ", addr
, TO_ADDR (s
->size
));
4624 if (s
->fill
->size
!= 0)
4628 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
4629 fprintf (config
.map_file
, "%02x", *p
);
4634 print_dot
= addr
+ TO_ADDR (s
->size
);
4638 print_wild_statement (lang_wild_statement_type
*w
,
4639 lang_output_section_statement_type
*os
)
4641 struct wildcard_list
*sec
;
4645 if (w
->exclude_name_list
)
4648 minfo ("EXCLUDE_FILE(%s", w
->exclude_name_list
->name
);
4649 for (tmp
= w
->exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4650 minfo (" %s", tmp
->name
);
4654 if (w
->filenames_sorted
)
4655 minfo ("SORT_BY_NAME(");
4656 if (w
->filename
!= NULL
)
4657 minfo ("%s", w
->filename
);
4660 if (w
->filenames_sorted
)
4664 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
4666 int closing_paren
= 0;
4668 switch (sec
->spec
.sorted
)
4674 minfo ("SORT_BY_NAME(");
4679 minfo ("SORT_BY_ALIGNMENT(");
4683 case by_name_alignment
:
4684 minfo ("SORT_BY_NAME(SORT_BY_ALIGNMENT(");
4688 case by_alignment_name
:
4689 minfo ("SORT_BY_ALIGNMENT(SORT_BY_NAME(");
4694 minfo ("SORT_NONE(");
4698 case by_init_priority
:
4699 minfo ("SORT_BY_INIT_PRIORITY(");
4704 if (sec
->spec
.exclude_name_list
!= NULL
)
4707 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
4708 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4709 minfo (" %s", tmp
->name
);
4712 if (sec
->spec
.name
!= NULL
)
4713 minfo ("%s", sec
->spec
.name
);
4716 for (;closing_paren
> 0; closing_paren
--)
4725 print_statement_list (w
->children
.head
, os
);
4728 /* Print a group statement. */
4731 print_group (lang_group_statement_type
*s
,
4732 lang_output_section_statement_type
*os
)
4734 fprintf (config
.map_file
, "START GROUP\n");
4735 print_statement_list (s
->children
.head
, os
);
4736 fprintf (config
.map_file
, "END GROUP\n");
4739 /* Print the list of statements in S.
4740 This can be called for any statement type. */
4743 print_statement_list (lang_statement_union_type
*s
,
4744 lang_output_section_statement_type
*os
)
4748 print_statement (s
, os
);
4753 /* Print the first statement in statement list S.
4754 This can be called for any statement type. */
4757 print_statement (lang_statement_union_type
*s
,
4758 lang_output_section_statement_type
*os
)
4760 switch (s
->header
.type
)
4763 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
4766 case lang_constructors_statement_enum
:
4767 if (constructor_list
.head
!= NULL
)
4769 if (constructors_sorted
)
4770 minfo (" SORT (CONSTRUCTORS)\n");
4772 minfo (" CONSTRUCTORS\n");
4773 print_statement_list (constructor_list
.head
, os
);
4776 case lang_wild_statement_enum
:
4777 print_wild_statement (&s
->wild_statement
, os
);
4779 case lang_address_statement_enum
:
4780 print_address_statement (&s
->address_statement
);
4782 case lang_object_symbols_statement_enum
:
4783 minfo (" CREATE_OBJECT_SYMBOLS\n");
4785 case lang_fill_statement_enum
:
4786 print_fill_statement (&s
->fill_statement
);
4788 case lang_data_statement_enum
:
4789 print_data_statement (&s
->data_statement
);
4791 case lang_reloc_statement_enum
:
4792 print_reloc_statement (&s
->reloc_statement
);
4794 case lang_input_section_enum
:
4795 print_input_section (s
->input_section
.section
, FALSE
);
4797 case lang_padding_statement_enum
:
4798 print_padding_statement (&s
->padding_statement
);
4800 case lang_output_section_statement_enum
:
4801 print_output_section_statement (&s
->output_section_statement
);
4803 case lang_assignment_statement_enum
:
4804 print_assignment (&s
->assignment_statement
, os
);
4806 case lang_target_statement_enum
:
4807 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
4809 case lang_output_statement_enum
:
4810 minfo ("OUTPUT(%s", s
->output_statement
.name
);
4811 if (output_target
!= NULL
)
4812 minfo (" %s", output_target
);
4815 case lang_input_statement_enum
:
4816 print_input_statement (&s
->input_statement
);
4818 case lang_group_statement_enum
:
4819 print_group (&s
->group_statement
, os
);
4821 case lang_insert_statement_enum
:
4822 minfo ("INSERT %s %s\n",
4823 s
->insert_statement
.is_before
? "BEFORE" : "AFTER",
4824 s
->insert_statement
.where
);
4830 print_statements (void)
4832 print_statement_list (statement_list
.head
, abs_output_section
);
4835 /* Print the first N statements in statement list S to STDERR.
4836 If N == 0, nothing is printed.
4837 If N < 0, the entire list is printed.
4838 Intended to be called from GDB. */
4841 dprint_statement (lang_statement_union_type
*s
, int n
)
4843 FILE *map_save
= config
.map_file
;
4845 config
.map_file
= stderr
;
4848 print_statement_list (s
, abs_output_section
);
4851 while (s
&& --n
>= 0)
4853 print_statement (s
, abs_output_section
);
4858 config
.map_file
= map_save
;
4862 insert_pad (lang_statement_union_type
**ptr
,
4864 bfd_size_type alignment_needed
,
4865 asection
*output_section
,
4868 static fill_type zero_fill
;
4869 lang_statement_union_type
*pad
= NULL
;
4871 if (ptr
!= &statement_list
.head
)
4872 pad
= ((lang_statement_union_type
*)
4873 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
4875 && pad
->header
.type
== lang_padding_statement_enum
4876 && pad
->padding_statement
.output_section
== output_section
)
4878 /* Use the existing pad statement. */
4880 else if ((pad
= *ptr
) != NULL
4881 && pad
->header
.type
== lang_padding_statement_enum
4882 && pad
->padding_statement
.output_section
== output_section
)
4884 /* Use the existing pad statement. */
4888 /* Make a new padding statement, linked into existing chain. */
4889 pad
= stat_alloc (sizeof (lang_padding_statement_type
));
4890 pad
->header
.next
= *ptr
;
4892 pad
->header
.type
= lang_padding_statement_enum
;
4893 pad
->padding_statement
.output_section
= output_section
;
4896 pad
->padding_statement
.fill
= fill
;
4898 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
4899 pad
->padding_statement
.size
= alignment_needed
;
4900 if (!(output_section
->flags
& SEC_FIXED_SIZE
))
4901 output_section
->size
= TO_SIZE (dot
+ TO_ADDR (alignment_needed
)
4902 - output_section
->vma
);
4905 /* Work out how much this section will move the dot point. */
4909 (lang_statement_union_type
**this_ptr
,
4910 lang_output_section_statement_type
*output_section_statement
,
4914 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
4915 asection
*i
= is
->section
;
4916 asection
*o
= output_section_statement
->bfd_section
;
4918 if (i
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
4919 i
->output_offset
= i
->vma
- o
->vma
;
4920 else if (((i
->flags
& SEC_EXCLUDE
) != 0)
4921 || output_section_statement
->ignored
)
4922 i
->output_offset
= dot
- o
->vma
;
4925 bfd_size_type alignment_needed
;
4927 /* Align this section first to the input sections requirement,
4928 then to the output section's requirement. If this alignment
4929 is greater than any seen before, then record it too. Perform
4930 the alignment by inserting a magic 'padding' statement. */
4932 if (output_section_statement
->subsection_alignment
!= NULL
)
4934 = exp_get_power (output_section_statement
->subsection_alignment
,
4935 "subsection alignment");
4937 if (o
->alignment_power
< i
->alignment_power
)
4938 o
->alignment_power
= i
->alignment_power
;
4940 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
4942 if (alignment_needed
!= 0)
4944 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
4945 dot
+= alignment_needed
;
4948 /* Remember where in the output section this input section goes. */
4949 i
->output_offset
= dot
- o
->vma
;
4951 /* Mark how big the output section must be to contain this now. */
4952 dot
+= TO_ADDR (i
->size
);
4953 if (!(o
->flags
& SEC_FIXED_SIZE
))
4954 o
->size
= TO_SIZE (dot
- o
->vma
);
4967 sort_sections_by_lma (const void *arg1
, const void *arg2
)
4969 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
4970 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
4972 if (sec1
->lma
< sec2
->lma
)
4974 else if (sec1
->lma
> sec2
->lma
)
4976 else if (sec1
->id
< sec2
->id
)
4978 else if (sec1
->id
> sec2
->id
)
4985 sort_sections_by_vma (const void *arg1
, const void *arg2
)
4987 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
4988 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
4990 if (sec1
->vma
< sec2
->vma
)
4992 else if (sec1
->vma
> sec2
->vma
)
4994 else if (sec1
->id
< sec2
->id
)
4996 else if (sec1
->id
> sec2
->id
)
5002 #define IS_TBSS(s) \
5003 ((s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == SEC_THREAD_LOCAL)
5005 #define IGNORE_SECTION(s) \
5006 ((s->flags & SEC_ALLOC) == 0 || IS_TBSS (s))
5008 /* Check to see if any allocated sections overlap with other allocated
5009 sections. This can happen if a linker script specifies the output
5010 section addresses of the two sections. Also check whether any memory
5011 region has overflowed. */
5014 lang_check_section_addresses (void)
5017 struct check_sec
*sections
;
5022 bfd_vma p_start
= 0;
5024 lang_memory_region_type
*m
;
5025 bfd_boolean overlays
;
5027 /* Detect address space overflow on allocated sections. */
5028 addr_mask
= ((bfd_vma
) 1 <<
5029 (bfd_arch_bits_per_address (link_info
.output_bfd
) - 1)) - 1;
5030 addr_mask
= (addr_mask
<< 1) + 1;
5031 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5032 if ((s
->flags
& SEC_ALLOC
) != 0)
5034 s_end
= (s
->vma
+ s
->size
) & addr_mask
;
5035 if (s_end
!= 0 && s_end
< (s
->vma
& addr_mask
))
5036 einfo (_("%X%P: section %s VMA wraps around address space\n"),
5040 s_end
= (s
->lma
+ s
->size
) & addr_mask
;
5041 if (s_end
!= 0 && s_end
< (s
->lma
& addr_mask
))
5042 einfo (_("%X%P: section %s LMA wraps around address space\n"),
5047 if (bfd_count_sections (link_info
.output_bfd
) <= 1)
5050 count
= bfd_count_sections (link_info
.output_bfd
);
5051 sections
= XNEWVEC (struct check_sec
, count
);
5053 /* Scan all sections in the output list. */
5055 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5057 if (IGNORE_SECTION (s
)
5061 sections
[count
].sec
= s
;
5062 sections
[count
].warned
= FALSE
;
5072 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_lma
);
5074 /* First check section LMAs. There should be no overlap of LMAs on
5075 loadable sections, even with overlays. */
5076 for (p
= NULL
, i
= 0; i
< count
; i
++)
5078 s
= sections
[i
].sec
;
5079 if ((s
->flags
& SEC_LOAD
) != 0)
5082 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5084 /* Look for an overlap. We have sorted sections by lma, so
5085 we know that s_start >= p_start. Besides the obvious
5086 case of overlap when the current section starts before
5087 the previous one ends, we also must have overlap if the
5088 previous section wraps around the address space. */
5090 && (s_start
<= p_end
5091 || p_end
< p_start
))
5093 einfo (_("%X%P: section %s LMA [%V,%V]"
5094 " overlaps section %s LMA [%V,%V]\n"),
5095 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5096 sections
[i
].warned
= TRUE
;
5104 /* If any non-zero size allocated section (excluding tbss) starts at
5105 exactly the same VMA as another such section, then we have
5106 overlays. Overlays generated by the OVERLAY keyword will have
5107 this property. It is possible to intentionally generate overlays
5108 that fail this test, but it would be unusual. */
5109 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_vma
);
5111 p_start
= sections
[0].sec
->vma
;
5112 for (i
= 1; i
< count
; i
++)
5114 s_start
= sections
[i
].sec
->vma
;
5115 if (p_start
== s_start
)
5123 /* Now check section VMAs if no overlays were detected. */
5126 for (p
= NULL
, i
= 0; i
< count
; i
++)
5128 s
= sections
[i
].sec
;
5130 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5133 && !sections
[i
].warned
5134 && (s_start
<= p_end
5135 || p_end
< p_start
))
5136 einfo (_("%X%P: section %s VMA [%V,%V]"
5137 " overlaps section %s VMA [%V,%V]\n"),
5138 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5147 /* If any memory region has overflowed, report by how much.
5148 We do not issue this diagnostic for regions that had sections
5149 explicitly placed outside their bounds; os_region_check's
5150 diagnostics are adequate for that case.
5152 FIXME: It is conceivable that m->current - (m->origin + m->length)
5153 might overflow a 32-bit integer. There is, alas, no way to print
5154 a bfd_vma quantity in decimal. */
5155 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
5156 if (m
->had_full_message
)
5158 unsigned long over
= m
->current
- (m
->origin
+ m
->length
);
5159 einfo (ngettext ("%X%P: region `%s' overflowed by %lu byte\n",
5160 "%X%P: region `%s' overflowed by %lu bytes\n",
5162 m
->name_list
.name
, over
);
5166 /* Make sure the new address is within the region. We explicitly permit the
5167 current address to be at the exact end of the region when the address is
5168 non-zero, in case the region is at the end of addressable memory and the
5169 calculation wraps around. */
5172 os_region_check (lang_output_section_statement_type
*os
,
5173 lang_memory_region_type
*region
,
5177 if ((region
->current
< region
->origin
5178 || (region
->current
- region
->origin
> region
->length
))
5179 && ((region
->current
!= region
->origin
+ region
->length
)
5184 einfo (_("%X%P: address 0x%v of %pB section `%s'"
5185 " is not within region `%s'\n"),
5187 os
->bfd_section
->owner
,
5188 os
->bfd_section
->name
,
5189 region
->name_list
.name
);
5191 else if (!region
->had_full_message
)
5193 region
->had_full_message
= TRUE
;
5195 einfo (_("%X%P: %pB section `%s' will not fit in region `%s'\n"),
5196 os
->bfd_section
->owner
,
5197 os
->bfd_section
->name
,
5198 region
->name_list
.name
);
5204 ldlang_check_relro_region (lang_statement_union_type
*s
,
5205 seg_align_type
*seg
)
5207 if (seg
->relro
== exp_seg_relro_start
)
5209 if (!seg
->relro_start_stat
)
5210 seg
->relro_start_stat
= s
;
5213 ASSERT (seg
->relro_start_stat
== s
);
5216 else if (seg
->relro
== exp_seg_relro_end
)
5218 if (!seg
->relro_end_stat
)
5219 seg
->relro_end_stat
= s
;
5222 ASSERT (seg
->relro_end_stat
== s
);
5227 /* Set the sizes for all the output sections. */
5230 lang_size_sections_1
5231 (lang_statement_union_type
**prev
,
5232 lang_output_section_statement_type
*output_section_statement
,
5236 bfd_boolean check_regions
)
5238 lang_statement_union_type
*s
;
5240 /* Size up the sections from their constituent parts. */
5241 for (s
= *prev
; s
!= NULL
; s
= s
->header
.next
)
5243 switch (s
->header
.type
)
5245 case lang_output_section_statement_enum
:
5247 bfd_vma newdot
, after
, dotdelta
;
5248 lang_output_section_statement_type
*os
;
5249 lang_memory_region_type
*r
;
5250 int section_alignment
= 0;
5252 os
= &s
->output_section_statement
;
5253 if (os
->constraint
== -1)
5256 /* FIXME: We shouldn't need to zero section vmas for ld -r
5257 here, in lang_insert_orphan, or in the default linker scripts.
5258 This is covering for coff backend linker bugs. See PR6945. */
5259 if (os
->addr_tree
== NULL
5260 && bfd_link_relocatable (&link_info
)
5261 && (bfd_get_flavour (link_info
.output_bfd
)
5262 == bfd_target_coff_flavour
))
5263 os
->addr_tree
= exp_intop (0);
5264 if (os
->addr_tree
!= NULL
)
5266 os
->processed_vma
= FALSE
;
5267 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
5269 if (expld
.result
.valid_p
)
5271 dot
= expld
.result
.value
;
5272 if (expld
.result
.section
!= NULL
)
5273 dot
+= expld
.result
.section
->vma
;
5275 else if (expld
.phase
!= lang_mark_phase_enum
)
5276 einfo (_("%F%P:%pS: non constant or forward reference"
5277 " address expression for section %s\n"),
5278 os
->addr_tree
, os
->name
);
5281 if (os
->bfd_section
== NULL
)
5282 /* This section was removed or never actually created. */
5285 /* If this is a COFF shared library section, use the size and
5286 address from the input section. FIXME: This is COFF
5287 specific; it would be cleaner if there were some other way
5288 to do this, but nothing simple comes to mind. */
5289 if (((bfd_get_flavour (link_info
.output_bfd
)
5290 == bfd_target_ecoff_flavour
)
5291 || (bfd_get_flavour (link_info
.output_bfd
)
5292 == bfd_target_coff_flavour
))
5293 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
5297 if (os
->children
.head
== NULL
5298 || os
->children
.head
->header
.next
!= NULL
5299 || (os
->children
.head
->header
.type
5300 != lang_input_section_enum
))
5301 einfo (_("%X%P: internal error on COFF shared library"
5302 " section %s\n"), os
->name
);
5304 input
= os
->children
.head
->input_section
.section
;
5305 bfd_set_section_vma (os
->bfd_section
,
5306 bfd_section_vma (input
));
5307 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5308 os
->bfd_section
->size
= input
->size
;
5314 if (bfd_is_abs_section (os
->bfd_section
))
5316 /* No matter what happens, an abs section starts at zero. */
5317 ASSERT (os
->bfd_section
->vma
== 0);
5321 if (os
->addr_tree
== NULL
)
5323 /* No address specified for this section, get one
5324 from the region specification. */
5325 if (os
->region
== NULL
5326 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
5327 && os
->region
->name_list
.name
[0] == '*'
5328 && strcmp (os
->region
->name_list
.name
,
5329 DEFAULT_MEMORY_REGION
) == 0))
5331 os
->region
= lang_memory_default (os
->bfd_section
);
5334 /* If a loadable section is using the default memory
5335 region, and some non default memory regions were
5336 defined, issue an error message. */
5338 && !IGNORE_SECTION (os
->bfd_section
)
5339 && !bfd_link_relocatable (&link_info
)
5341 && strcmp (os
->region
->name_list
.name
,
5342 DEFAULT_MEMORY_REGION
) == 0
5343 && lang_memory_region_list
!= NULL
5344 && (strcmp (lang_memory_region_list
->name_list
.name
,
5345 DEFAULT_MEMORY_REGION
) != 0
5346 || lang_memory_region_list
->next
!= NULL
)
5347 && expld
.phase
!= lang_mark_phase_enum
)
5349 /* By default this is an error rather than just a
5350 warning because if we allocate the section to the
5351 default memory region we can end up creating an
5352 excessively large binary, or even seg faulting when
5353 attempting to perform a negative seek. See
5354 sources.redhat.com/ml/binutils/2003-04/msg00423.html
5355 for an example of this. This behaviour can be
5356 overridden by the using the --no-check-sections
5358 if (command_line
.check_section_addresses
)
5359 einfo (_("%F%P: error: no memory region specified"
5360 " for loadable section `%s'\n"),
5361 bfd_section_name (os
->bfd_section
));
5363 einfo (_("%P: warning: no memory region specified"
5364 " for loadable section `%s'\n"),
5365 bfd_section_name (os
->bfd_section
));
5368 newdot
= os
->region
->current
;
5369 section_alignment
= os
->bfd_section
->alignment_power
;
5372 section_alignment
= exp_get_power (os
->section_alignment
,
5373 "section alignment");
5375 /* Align to what the section needs. */
5376 if (section_alignment
> 0)
5378 bfd_vma savedot
= newdot
;
5379 newdot
= align_power (newdot
, section_alignment
);
5381 dotdelta
= newdot
- savedot
;
5383 && (config
.warn_section_align
5384 || os
->addr_tree
!= NULL
)
5385 && expld
.phase
!= lang_mark_phase_enum
)
5386 einfo (ngettext ("%P: warning: changing start of "
5387 "section %s by %lu byte\n",
5388 "%P: warning: changing start of "
5389 "section %s by %lu bytes\n",
5390 (unsigned long) dotdelta
),
5391 os
->name
, (unsigned long) dotdelta
);
5394 bfd_set_section_vma (os
->bfd_section
, newdot
);
5396 os
->bfd_section
->output_offset
= 0;
5399 lang_size_sections_1 (&os
->children
.head
, os
,
5400 os
->fill
, newdot
, relax
, check_regions
);
5402 os
->processed_vma
= TRUE
;
5404 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5405 /* Except for some special linker created sections,
5406 no output section should change from zero size
5407 after strip_excluded_output_sections. A non-zero
5408 size on an ignored section indicates that some
5409 input section was not sized early enough. */
5410 ASSERT (os
->bfd_section
->size
== 0);
5413 dot
= os
->bfd_section
->vma
;
5415 /* Put the section within the requested block size, or
5416 align at the block boundary. */
5418 + TO_ADDR (os
->bfd_section
->size
)
5419 + os
->block_value
- 1)
5420 & - (bfd_vma
) os
->block_value
);
5422 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5423 os
->bfd_section
->size
= TO_SIZE (after
5424 - os
->bfd_section
->vma
);
5427 /* Set section lma. */
5430 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
5434 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
5435 os
->bfd_section
->lma
= lma
;
5437 else if (os
->lma_region
!= NULL
)
5439 bfd_vma lma
= os
->lma_region
->current
;
5441 if (os
->align_lma_with_input
)
5445 /* When LMA_REGION is the same as REGION, align the LMA
5446 as we did for the VMA, possibly including alignment
5447 from the bfd section. If a different region, then
5448 only align according to the value in the output
5450 if (os
->lma_region
!= os
->region
)
5451 section_alignment
= exp_get_power (os
->section_alignment
,
5452 "section alignment");
5453 if (section_alignment
> 0)
5454 lma
= align_power (lma
, section_alignment
);
5456 os
->bfd_section
->lma
= lma
;
5458 else if (r
->last_os
!= NULL
5459 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5464 last
= r
->last_os
->output_section_statement
.bfd_section
;
5466 /* A backwards move of dot should be accompanied by
5467 an explicit assignment to the section LMA (ie.
5468 os->load_base set) because backwards moves can
5469 create overlapping LMAs. */
5471 && os
->bfd_section
->size
!= 0
5472 && dot
+ TO_ADDR (os
->bfd_section
->size
) <= last
->vma
)
5474 /* If dot moved backwards then leave lma equal to
5475 vma. This is the old default lma, which might
5476 just happen to work when the backwards move is
5477 sufficiently large. Nag if this changes anything,
5478 so people can fix their linker scripts. */
5480 if (last
->vma
!= last
->lma
)
5481 einfo (_("%P: warning: dot moved backwards "
5482 "before `%s'\n"), os
->name
);
5486 /* If this is an overlay, set the current lma to that
5487 at the end of the previous section. */
5488 if (os
->sectype
== overlay_section
)
5489 lma
= last
->lma
+ TO_ADDR (last
->size
);
5491 /* Otherwise, keep the same lma to vma relationship
5492 as the previous section. */
5494 lma
= dot
+ last
->lma
- last
->vma
;
5496 if (section_alignment
> 0)
5497 lma
= align_power (lma
, section_alignment
);
5498 os
->bfd_section
->lma
= lma
;
5501 os
->processed_lma
= TRUE
;
5503 /* Keep track of normal sections using the default
5504 lma region. We use this to set the lma for
5505 following sections. Overlays or other linker
5506 script assignment to lma might mean that the
5507 default lma == vma is incorrect.
5508 To avoid warnings about dot moving backwards when using
5509 -Ttext, don't start tracking sections until we find one
5510 of non-zero size or with lma set differently to vma.
5511 Do this tracking before we short-cut the loop so that we
5512 track changes for the case where the section size is zero,
5513 but the lma is set differently to the vma. This is
5514 important, if an orphan section is placed after an
5515 otherwise empty output section that has an explicit lma
5516 set, we want that lma reflected in the orphans lma. */
5517 if (((!IGNORE_SECTION (os
->bfd_section
)
5518 && (os
->bfd_section
->size
!= 0
5519 || (r
->last_os
== NULL
5520 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
5521 || (r
->last_os
!= NULL
5522 && dot
>= (r
->last_os
->output_section_statement
5523 .bfd_section
->vma
))))
5524 || os
->sectype
== first_overlay_section
)
5525 && os
->lma_region
== NULL
5526 && !bfd_link_relocatable (&link_info
))
5529 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5532 /* .tbss sections effectively have zero size. */
5533 if (!IS_TBSS (os
->bfd_section
)
5534 || bfd_link_relocatable (&link_info
))
5535 dotdelta
= TO_ADDR (os
->bfd_section
->size
);
5540 if (os
->update_dot_tree
!= 0)
5541 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5543 /* Update dot in the region ?
5544 We only do this if the section is going to be allocated,
5545 since unallocated sections do not contribute to the region's
5546 overall size in memory. */
5547 if (os
->region
!= NULL
5548 && (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)))
5550 os
->region
->current
= dot
;
5553 /* Make sure the new address is within the region. */
5554 os_region_check (os
, os
->region
, os
->addr_tree
,
5555 os
->bfd_section
->vma
);
5557 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
5558 && ((os
->bfd_section
->flags
& SEC_LOAD
)
5559 || os
->align_lma_with_input
))
5561 os
->lma_region
->current
= os
->bfd_section
->lma
+ dotdelta
;
5564 os_region_check (os
, os
->lma_region
, NULL
,
5565 os
->bfd_section
->lma
);
5571 case lang_constructors_statement_enum
:
5572 dot
= lang_size_sections_1 (&constructor_list
.head
,
5573 output_section_statement
,
5574 fill
, dot
, relax
, check_regions
);
5577 case lang_data_statement_enum
:
5579 unsigned int size
= 0;
5581 s
->data_statement
.output_offset
=
5582 dot
- output_section_statement
->bfd_section
->vma
;
5583 s
->data_statement
.output_section
=
5584 output_section_statement
->bfd_section
;
5586 /* We might refer to provided symbols in the expression, and
5587 need to mark them as needed. */
5588 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5590 switch (s
->data_statement
.type
)
5608 if (size
< TO_SIZE ((unsigned) 1))
5609 size
= TO_SIZE ((unsigned) 1);
5610 dot
+= TO_ADDR (size
);
5611 if (!(output_section_statement
->bfd_section
->flags
5613 output_section_statement
->bfd_section
->size
5614 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5619 case lang_reloc_statement_enum
:
5623 s
->reloc_statement
.output_offset
=
5624 dot
- output_section_statement
->bfd_section
->vma
;
5625 s
->reloc_statement
.output_section
=
5626 output_section_statement
->bfd_section
;
5627 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
5628 dot
+= TO_ADDR (size
);
5629 if (!(output_section_statement
->bfd_section
->flags
5631 output_section_statement
->bfd_section
->size
5632 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5636 case lang_wild_statement_enum
:
5637 dot
= lang_size_sections_1 (&s
->wild_statement
.children
.head
,
5638 output_section_statement
,
5639 fill
, dot
, relax
, check_regions
);
5642 case lang_object_symbols_statement_enum
:
5643 link_info
.create_object_symbols_section
5644 = output_section_statement
->bfd_section
;
5645 output_section_statement
->bfd_section
->flags
|= SEC_KEEP
;
5648 case lang_output_statement_enum
:
5649 case lang_target_statement_enum
:
5652 case lang_input_section_enum
:
5656 i
= s
->input_section
.section
;
5661 if (!bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
5662 einfo (_("%F%P: can't relax section: %E\n"));
5666 dot
= size_input_section (prev
, output_section_statement
,
5671 case lang_input_statement_enum
:
5674 case lang_fill_statement_enum
:
5675 s
->fill_statement
.output_section
=
5676 output_section_statement
->bfd_section
;
5678 fill
= s
->fill_statement
.fill
;
5681 case lang_assignment_statement_enum
:
5683 bfd_vma newdot
= dot
;
5684 etree_type
*tree
= s
->assignment_statement
.exp
;
5686 expld
.dataseg
.relro
= exp_seg_relro_none
;
5688 exp_fold_tree (tree
,
5689 output_section_statement
->bfd_section
,
5692 ldlang_check_relro_region (s
, &expld
.dataseg
);
5694 expld
.dataseg
.relro
= exp_seg_relro_none
;
5696 /* This symbol may be relative to this section. */
5697 if ((tree
->type
.node_class
== etree_provided
5698 || tree
->type
.node_class
== etree_assign
)
5699 && (tree
->assign
.dst
[0] != '.'
5700 || tree
->assign
.dst
[1] != '\0'))
5701 output_section_statement
->update_dot
= 1;
5703 if (!output_section_statement
->ignored
)
5705 if (output_section_statement
== abs_output_section
)
5707 /* If we don't have an output section, then just adjust
5708 the default memory address. */
5709 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
5710 FALSE
)->current
= newdot
;
5712 else if (newdot
!= dot
)
5714 /* Insert a pad after this statement. We can't
5715 put the pad before when relaxing, in case the
5716 assignment references dot. */
5717 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
5718 output_section_statement
->bfd_section
, dot
);
5720 /* Don't neuter the pad below when relaxing. */
5723 /* If dot is advanced, this implies that the section
5724 should have space allocated to it, unless the
5725 user has explicitly stated that the section
5726 should not be allocated. */
5727 if (output_section_statement
->sectype
!= noalloc_section
5728 && (output_section_statement
->sectype
!= noload_section
5729 || (bfd_get_flavour (link_info
.output_bfd
)
5730 == bfd_target_elf_flavour
)))
5731 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
5738 case lang_padding_statement_enum
:
5739 /* If this is the first time lang_size_sections is called,
5740 we won't have any padding statements. If this is the
5741 second or later passes when relaxing, we should allow
5742 padding to shrink. If padding is needed on this pass, it
5743 will be added back in. */
5744 s
->padding_statement
.size
= 0;
5746 /* Make sure output_offset is valid. If relaxation shrinks
5747 the section and this pad isn't needed, it's possible to
5748 have output_offset larger than the final size of the
5749 section. bfd_set_section_contents will complain even for
5750 a pad size of zero. */
5751 s
->padding_statement
.output_offset
5752 = dot
- output_section_statement
->bfd_section
->vma
;
5755 case lang_group_statement_enum
:
5756 dot
= lang_size_sections_1 (&s
->group_statement
.children
.head
,
5757 output_section_statement
,
5758 fill
, dot
, relax
, check_regions
);
5761 case lang_insert_statement_enum
:
5764 /* We can only get here when relaxing is turned on. */
5765 case lang_address_statement_enum
:
5772 prev
= &s
->header
.next
;
5777 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
5778 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
5779 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
5780 segments. We are allowed an opportunity to override this decision. */
5783 ldlang_override_segment_assignment (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5784 bfd
*abfd ATTRIBUTE_UNUSED
,
5785 asection
*current_section
,
5786 asection
*previous_section
,
5787 bfd_boolean new_segment
)
5789 lang_output_section_statement_type
*cur
;
5790 lang_output_section_statement_type
*prev
;
5792 /* The checks below are only necessary when the BFD library has decided
5793 that the two sections ought to be placed into the same segment. */
5797 /* Paranoia checks. */
5798 if (current_section
== NULL
|| previous_section
== NULL
)
5801 /* If this flag is set, the target never wants code and non-code
5802 sections comingled in the same segment. */
5803 if (config
.separate_code
5804 && ((current_section
->flags
^ previous_section
->flags
) & SEC_CODE
))
5807 /* Find the memory regions associated with the two sections.
5808 We call lang_output_section_find() here rather than scanning the list
5809 of output sections looking for a matching section pointer because if
5810 we have a large number of sections then a hash lookup is faster. */
5811 cur
= lang_output_section_find (current_section
->name
);
5812 prev
= lang_output_section_find (previous_section
->name
);
5814 /* More paranoia. */
5815 if (cur
== NULL
|| prev
== NULL
)
5818 /* If the regions are different then force the sections to live in
5819 different segments. See the email thread starting at the following
5820 URL for the reasons why this is necessary:
5821 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
5822 return cur
->region
!= prev
->region
;
5826 one_lang_size_sections_pass (bfd_boolean
*relax
, bfd_boolean check_regions
)
5828 lang_statement_iteration
++;
5829 lang_size_sections_1 (&statement_list
.head
, abs_output_section
,
5830 0, 0, relax
, check_regions
);
5834 lang_size_segment (seg_align_type
*seg
)
5836 /* If XXX_SEGMENT_ALIGN XXX_SEGMENT_END pair was seen, check whether
5837 a page could be saved in the data segment. */
5838 bfd_vma first
, last
;
5840 first
= -seg
->base
& (seg
->pagesize
- 1);
5841 last
= seg
->end
& (seg
->pagesize
- 1);
5843 && ((seg
->base
& ~(seg
->pagesize
- 1))
5844 != (seg
->end
& ~(seg
->pagesize
- 1)))
5845 && first
+ last
<= seg
->pagesize
)
5847 seg
->phase
= exp_seg_adjust
;
5851 seg
->phase
= exp_seg_done
;
5856 lang_size_relro_segment_1 (seg_align_type
*seg
)
5858 bfd_vma relro_end
, desired_end
;
5861 /* Compute the expected PT_GNU_RELRO/PT_LOAD segment end. */
5862 relro_end
= ((seg
->relro_end
+ seg
->pagesize
- 1)
5863 & ~(seg
->pagesize
- 1));
5865 /* Adjust by the offset arg of XXX_SEGMENT_RELRO_END. */
5866 desired_end
= relro_end
- seg
->relro_offset
;
5868 /* For sections in the relro segment.. */
5869 for (sec
= link_info
.output_bfd
->section_last
; sec
; sec
= sec
->prev
)
5870 if ((sec
->flags
& SEC_ALLOC
) != 0
5871 && sec
->vma
>= seg
->base
5872 && sec
->vma
< seg
->relro_end
- seg
->relro_offset
)
5874 /* Where do we want to put this section so that it ends as
5876 bfd_vma start
, end
, bump
;
5878 end
= start
= sec
->vma
;
5880 end
+= TO_ADDR (sec
->size
);
5881 bump
= desired_end
- end
;
5882 /* We'd like to increase START by BUMP, but we must heed
5883 alignment so the increase might be less than optimum. */
5885 start
&= ~(((bfd_vma
) 1 << sec
->alignment_power
) - 1);
5886 /* This is now the desired end for the previous section. */
5887 desired_end
= start
;
5890 seg
->phase
= exp_seg_relro_adjust
;
5891 ASSERT (desired_end
>= seg
->base
);
5892 seg
->base
= desired_end
;
5897 lang_size_relro_segment (bfd_boolean
*relax
, bfd_boolean check_regions
)
5899 bfd_boolean do_reset
= FALSE
;
5900 bfd_boolean do_data_relro
;
5901 bfd_vma data_initial_base
, data_relro_end
;
5903 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
5905 do_data_relro
= TRUE
;
5906 data_initial_base
= expld
.dataseg
.base
;
5907 data_relro_end
= lang_size_relro_segment_1 (&expld
.dataseg
);
5911 do_data_relro
= FALSE
;
5912 data_initial_base
= data_relro_end
= 0;
5917 lang_reset_memory_regions ();
5918 one_lang_size_sections_pass (relax
, check_regions
);
5920 /* Assignments to dot, or to output section address in a user
5921 script have increased padding over the original. Revert. */
5922 if (do_data_relro
&& expld
.dataseg
.relro_end
> data_relro_end
)
5924 expld
.dataseg
.base
= data_initial_base
;;
5929 if (!do_data_relro
&& lang_size_segment (&expld
.dataseg
))
5936 lang_size_sections (bfd_boolean
*relax
, bfd_boolean check_regions
)
5938 expld
.phase
= lang_allocating_phase_enum
;
5939 expld
.dataseg
.phase
= exp_seg_none
;
5941 one_lang_size_sections_pass (relax
, check_regions
);
5943 if (expld
.dataseg
.phase
!= exp_seg_end_seen
)
5944 expld
.dataseg
.phase
= exp_seg_done
;
5946 if (expld
.dataseg
.phase
== exp_seg_end_seen
)
5948 bfd_boolean do_reset
5949 = lang_size_relro_segment (relax
, check_regions
);
5953 lang_reset_memory_regions ();
5954 one_lang_size_sections_pass (relax
, check_regions
);
5957 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
5959 link_info
.relro_start
= expld
.dataseg
.base
;
5960 link_info
.relro_end
= expld
.dataseg
.relro_end
;
5965 static lang_output_section_statement_type
*current_section
;
5966 static lang_assignment_statement_type
*current_assign
;
5967 static bfd_boolean prefer_next_section
;
5969 /* Worker function for lang_do_assignments. Recursiveness goes here. */
5972 lang_do_assignments_1 (lang_statement_union_type
*s
,
5973 lang_output_section_statement_type
*current_os
,
5976 bfd_boolean
*found_end
)
5978 for (; s
!= NULL
; s
= s
->header
.next
)
5980 switch (s
->header
.type
)
5982 case lang_constructors_statement_enum
:
5983 dot
= lang_do_assignments_1 (constructor_list
.head
,
5984 current_os
, fill
, dot
, found_end
);
5987 case lang_output_section_statement_enum
:
5989 lang_output_section_statement_type
*os
;
5992 os
= &(s
->output_section_statement
);
5993 os
->after_end
= *found_end
;
5994 if (os
->bfd_section
!= NULL
&& !os
->ignored
)
5996 if ((os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5998 current_section
= os
;
5999 prefer_next_section
= FALSE
;
6001 dot
= os
->bfd_section
->vma
;
6003 newdot
= lang_do_assignments_1 (os
->children
.head
,
6004 os
, os
->fill
, dot
, found_end
);
6007 if (os
->bfd_section
!= NULL
)
6009 /* .tbss sections effectively have zero size. */
6010 if (!IS_TBSS (os
->bfd_section
)
6011 || bfd_link_relocatable (&link_info
))
6012 dot
+= TO_ADDR (os
->bfd_section
->size
);
6014 if (os
->update_dot_tree
!= NULL
)
6015 exp_fold_tree (os
->update_dot_tree
,
6016 bfd_abs_section_ptr
, &dot
);
6024 case lang_wild_statement_enum
:
6026 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
6027 current_os
, fill
, dot
, found_end
);
6030 case lang_object_symbols_statement_enum
:
6031 case lang_output_statement_enum
:
6032 case lang_target_statement_enum
:
6035 case lang_data_statement_enum
:
6036 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
6037 if (expld
.result
.valid_p
)
6039 s
->data_statement
.value
= expld
.result
.value
;
6040 if (expld
.result
.section
!= NULL
)
6041 s
->data_statement
.value
+= expld
.result
.section
->vma
;
6043 else if (expld
.phase
== lang_final_phase_enum
)
6044 einfo (_("%F%P: invalid data statement\n"));
6047 switch (s
->data_statement
.type
)
6065 if (size
< TO_SIZE ((unsigned) 1))
6066 size
= TO_SIZE ((unsigned) 1);
6067 dot
+= TO_ADDR (size
);
6071 case lang_reloc_statement_enum
:
6072 exp_fold_tree (s
->reloc_statement
.addend_exp
,
6073 bfd_abs_section_ptr
, &dot
);
6074 if (expld
.result
.valid_p
)
6075 s
->reloc_statement
.addend_value
= expld
.result
.value
;
6076 else if (expld
.phase
== lang_final_phase_enum
)
6077 einfo (_("%F%P: invalid reloc statement\n"));
6078 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
6081 case lang_input_section_enum
:
6083 asection
*in
= s
->input_section
.section
;
6085 if ((in
->flags
& SEC_EXCLUDE
) == 0)
6086 dot
+= TO_ADDR (in
->size
);
6090 case lang_input_statement_enum
:
6093 case lang_fill_statement_enum
:
6094 fill
= s
->fill_statement
.fill
;
6097 case lang_assignment_statement_enum
:
6098 current_assign
= &s
->assignment_statement
;
6099 if (current_assign
->exp
->type
.node_class
!= etree_assert
)
6101 const char *p
= current_assign
->exp
->assign
.dst
;
6103 if (current_os
== abs_output_section
&& p
[0] == '.' && p
[1] == 0)
6104 prefer_next_section
= TRUE
;
6108 if (strcmp (p
, "end") == 0)
6111 exp_fold_tree (s
->assignment_statement
.exp
,
6112 (current_os
->bfd_section
!= NULL
6113 ? current_os
->bfd_section
: bfd_und_section_ptr
),
6117 case lang_padding_statement_enum
:
6118 dot
+= TO_ADDR (s
->padding_statement
.size
);
6121 case lang_group_statement_enum
:
6122 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
6123 current_os
, fill
, dot
, found_end
);
6126 case lang_insert_statement_enum
:
6129 case lang_address_statement_enum
:
6141 lang_do_assignments (lang_phase_type phase
)
6143 bfd_boolean found_end
= FALSE
;
6145 current_section
= NULL
;
6146 prefer_next_section
= FALSE
;
6147 expld
.phase
= phase
;
6148 lang_statement_iteration
++;
6149 lang_do_assignments_1 (statement_list
.head
,
6150 abs_output_section
, NULL
, 0, &found_end
);
6153 /* For an assignment statement outside of an output section statement,
6154 choose the best of neighbouring output sections to use for values
6158 section_for_dot (void)
6162 /* Assignments belong to the previous output section, unless there
6163 has been an assignment to "dot", in which case following
6164 assignments belong to the next output section. (The assumption
6165 is that an assignment to "dot" is setting up the address for the
6166 next output section.) Except that past the assignment to "_end"
6167 we always associate with the previous section. This exception is
6168 for targets like SH that define an alloc .stack or other
6169 weirdness after non-alloc sections. */
6170 if (current_section
== NULL
|| prefer_next_section
)
6172 lang_statement_union_type
*stmt
;
6173 lang_output_section_statement_type
*os
;
6175 for (stmt
= (lang_statement_union_type
*) current_assign
;
6177 stmt
= stmt
->header
.next
)
6178 if (stmt
->header
.type
== lang_output_section_statement_enum
)
6181 os
= &stmt
->output_section_statement
;
6184 && (os
->bfd_section
== NULL
6185 || (os
->bfd_section
->flags
& SEC_EXCLUDE
) != 0
6186 || bfd_section_removed_from_list (link_info
.output_bfd
,
6190 if (current_section
== NULL
|| os
== NULL
|| !os
->after_end
)
6193 s
= os
->bfd_section
;
6195 s
= link_info
.output_bfd
->section_last
;
6197 && ((s
->flags
& SEC_ALLOC
) == 0
6198 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6203 return bfd_abs_section_ptr
;
6207 s
= current_section
->bfd_section
;
6209 /* The section may have been stripped. */
6211 && ((s
->flags
& SEC_EXCLUDE
) != 0
6212 || (s
->flags
& SEC_ALLOC
) == 0
6213 || (s
->flags
& SEC_THREAD_LOCAL
) != 0
6214 || bfd_section_removed_from_list (link_info
.output_bfd
, s
)))
6217 s
= link_info
.output_bfd
->sections
;
6219 && ((s
->flags
& SEC_ALLOC
) == 0
6220 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6225 return bfd_abs_section_ptr
;
6228 /* Array of __start/__stop/.startof./.sizeof/ symbols. */
6230 static struct bfd_link_hash_entry
**start_stop_syms
;
6231 static size_t start_stop_count
= 0;
6232 static size_t start_stop_alloc
= 0;
6234 /* Give start/stop SYMBOL for SEC a preliminary definition, and add it
6235 to start_stop_syms. */
6238 lang_define_start_stop (const char *symbol
, asection
*sec
)
6240 struct bfd_link_hash_entry
*h
;
6242 h
= bfd_define_start_stop (link_info
.output_bfd
, &link_info
, symbol
, sec
);
6245 if (start_stop_count
== start_stop_alloc
)
6247 start_stop_alloc
= 2 * start_stop_alloc
+ 10;
6249 = xrealloc (start_stop_syms
,
6250 start_stop_alloc
* sizeof (*start_stop_syms
));
6252 start_stop_syms
[start_stop_count
++] = h
;
6256 /* Check for input sections whose names match references to
6257 __start_SECNAME or __stop_SECNAME symbols. Give the symbols
6258 preliminary definitions. */
6261 lang_init_start_stop (void)
6265 char leading_char
= bfd_get_symbol_leading_char (link_info
.output_bfd
);
6267 for (abfd
= link_info
.input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6268 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6271 const char *secname
= s
->name
;
6273 for (ps
= secname
; *ps
!= '\0'; ps
++)
6274 if (!ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
6278 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6280 symbol
[0] = leading_char
;
6281 sprintf (symbol
+ (leading_char
!= 0), "__start_%s", secname
);
6282 lang_define_start_stop (symbol
, s
);
6284 symbol
[1] = leading_char
;
6285 memcpy (symbol
+ 1 + (leading_char
!= 0), "__stop", 6);
6286 lang_define_start_stop (symbol
+ 1, s
);
6293 /* Iterate over start_stop_syms. */
6296 foreach_start_stop (void (*func
) (struct bfd_link_hash_entry
*))
6300 for (i
= 0; i
< start_stop_count
; ++i
)
6301 func (start_stop_syms
[i
]);
6304 /* __start and __stop symbols are only supposed to be defined by the
6305 linker for orphan sections, but we now extend that to sections that
6306 map to an output section of the same name. The symbols were
6307 defined early for --gc-sections, before we mapped input to output
6308 sections, so undo those that don't satisfy this rule. */
6311 undef_start_stop (struct bfd_link_hash_entry
*h
)
6313 if (h
->ldscript_def
)
6316 if (h
->u
.def
.section
->output_section
== NULL
6317 || h
->u
.def
.section
->output_section
->owner
!= link_info
.output_bfd
6318 || strcmp (h
->u
.def
.section
->name
,
6319 h
->u
.def
.section
->output_section
->name
) != 0)
6321 asection
*sec
= bfd_get_section_by_name (link_info
.output_bfd
,
6322 h
->u
.def
.section
->name
);
6325 /* When there are more than one input sections with the same
6326 section name, SECNAME, linker picks the first one to define
6327 __start_SECNAME and __stop_SECNAME symbols. When the first
6328 input section is removed by comdat group, we need to check
6329 if there is still an output section with section name
6332 for (i
= sec
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
6333 if (strcmp (h
->u
.def
.section
->name
, i
->name
) == 0)
6335 h
->u
.def
.section
= i
;
6339 h
->type
= bfd_link_hash_undefined
;
6340 h
->u
.undef
.abfd
= NULL
;
6345 lang_undef_start_stop (void)
6347 foreach_start_stop (undef_start_stop
);
6350 /* Check for output sections whose names match references to
6351 .startof.SECNAME or .sizeof.SECNAME symbols. Give the symbols
6352 preliminary definitions. */
6355 lang_init_startof_sizeof (void)
6359 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6361 const char *secname
= s
->name
;
6362 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6364 sprintf (symbol
, ".startof.%s", secname
);
6365 lang_define_start_stop (symbol
, s
);
6367 memcpy (symbol
+ 1, ".size", 5);
6368 lang_define_start_stop (symbol
+ 1, s
);
6373 /* Set .startof., .sizeof., __start and __stop symbols final values. */
6376 set_start_stop (struct bfd_link_hash_entry
*h
)
6379 || h
->type
!= bfd_link_hash_defined
)
6382 if (h
->root
.string
[0] == '.')
6384 /* .startof. or .sizeof. symbol.
6385 .startof. already has final value. */
6386 if (h
->root
.string
[2] == 'i')
6389 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6390 h
->u
.def
.section
= bfd_abs_section_ptr
;
6395 /* __start or __stop symbol. */
6396 int has_lead
= bfd_get_symbol_leading_char (link_info
.output_bfd
) != 0;
6398 h
->u
.def
.section
= h
->u
.def
.section
->output_section
;
6399 if (h
->root
.string
[4 + has_lead
] == 'o')
6402 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6408 lang_finalize_start_stop (void)
6410 foreach_start_stop (set_start_stop
);
6416 struct bfd_link_hash_entry
*h
;
6419 if ((bfd_link_relocatable (&link_info
) && !link_info
.gc_sections
)
6420 || bfd_link_dll (&link_info
))
6421 warn
= entry_from_cmdline
;
6425 /* Force the user to specify a root when generating a relocatable with
6426 --gc-sections, unless --gc-keep-exported was also given. */
6427 if (bfd_link_relocatable (&link_info
)
6428 && link_info
.gc_sections
6429 && !link_info
.gc_keep_exported
6430 && !(entry_from_cmdline
|| undef_from_cmdline
))
6431 einfo (_("%F%P: gc-sections requires either an entry or "
6432 "an undefined symbol\n"));
6434 if (entry_symbol
.name
== NULL
)
6436 /* No entry has been specified. Look for the default entry, but
6437 don't warn if we don't find it. */
6438 entry_symbol
.name
= entry_symbol_default
;
6442 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
6443 FALSE
, FALSE
, TRUE
);
6445 && (h
->type
== bfd_link_hash_defined
6446 || h
->type
== bfd_link_hash_defweak
)
6447 && h
->u
.def
.section
->output_section
!= NULL
)
6451 val
= (h
->u
.def
.value
6452 + bfd_section_vma (h
->u
.def
.section
->output_section
)
6453 + h
->u
.def
.section
->output_offset
);
6454 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6455 einfo (_("%F%P: %s: can't set start address\n"), entry_symbol
.name
);
6462 /* We couldn't find the entry symbol. Try parsing it as a
6464 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
6467 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6468 einfo (_("%F%P: can't set start address\n"));
6474 /* Can't find the entry symbol, and it's not a number. Use
6475 the first address in the text section. */
6476 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
6480 einfo (_("%P: warning: cannot find entry symbol %s;"
6481 " defaulting to %V\n"),
6483 bfd_section_vma (ts
));
6484 if (!bfd_set_start_address (link_info
.output_bfd
,
6485 bfd_section_vma (ts
)))
6486 einfo (_("%F%P: can't set start address\n"));
6491 einfo (_("%P: warning: cannot find entry symbol %s;"
6492 " not setting start address\n"),
6499 /* This is a small function used when we want to ignore errors from
6503 ignore_bfd_errors (const char *fmt ATTRIBUTE_UNUSED
,
6504 va_list ap ATTRIBUTE_UNUSED
)
6506 /* Don't do anything. */
6509 /* Check that the architecture of all the input files is compatible
6510 with the output file. Also call the backend to let it do any
6511 other checking that is needed. */
6516 lang_input_statement_type
*file
;
6518 const bfd_arch_info_type
*compatible
;
6520 for (file
= &file_chain
.head
->input_statement
;
6524 #ifdef ENABLE_PLUGINS
6525 /* Don't check format of files claimed by plugin. */
6526 if (file
->flags
.claimed
)
6528 #endif /* ENABLE_PLUGINS */
6529 input_bfd
= file
->the_bfd
;
6531 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
6532 command_line
.accept_unknown_input_arch
);
6534 /* In general it is not possible to perform a relocatable
6535 link between differing object formats when the input
6536 file has relocations, because the relocations in the
6537 input format may not have equivalent representations in
6538 the output format (and besides BFD does not translate
6539 relocs for other link purposes than a final link). */
6540 if ((bfd_link_relocatable (&link_info
)
6541 || link_info
.emitrelocations
)
6542 && (compatible
== NULL
6543 || (bfd_get_flavour (input_bfd
)
6544 != bfd_get_flavour (link_info
.output_bfd
)))
6545 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
6547 einfo (_("%F%P: relocatable linking with relocations from"
6548 " format %s (%pB) to format %s (%pB) is not supported\n"),
6549 bfd_get_target (input_bfd
), input_bfd
,
6550 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
6551 /* einfo with %F exits. */
6554 if (compatible
== NULL
)
6556 if (command_line
.warn_mismatch
)
6557 einfo (_("%X%P: %s architecture of input file `%pB'"
6558 " is incompatible with %s output\n"),
6559 bfd_printable_name (input_bfd
), input_bfd
,
6560 bfd_printable_name (link_info
.output_bfd
));
6562 else if (bfd_count_sections (input_bfd
))
6564 /* If the input bfd has no contents, it shouldn't set the
6565 private data of the output bfd. */
6567 bfd_error_handler_type pfn
= NULL
;
6569 /* If we aren't supposed to warn about mismatched input
6570 files, temporarily set the BFD error handler to a
6571 function which will do nothing. We still want to call
6572 bfd_merge_private_bfd_data, since it may set up
6573 information which is needed in the output file. */
6574 if (!command_line
.warn_mismatch
)
6575 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
6576 if (!bfd_merge_private_bfd_data (input_bfd
, &link_info
))
6578 if (command_line
.warn_mismatch
)
6579 einfo (_("%X%P: failed to merge target specific data"
6580 " of file %pB\n"), input_bfd
);
6582 if (!command_line
.warn_mismatch
)
6583 bfd_set_error_handler (pfn
);
6588 /* Look through all the global common symbols and attach them to the
6589 correct section. The -sort-common command line switch may be used
6590 to roughly sort the entries by alignment. */
6595 if (link_info
.inhibit_common_definition
)
6597 if (bfd_link_relocatable (&link_info
)
6598 && !command_line
.force_common_definition
)
6601 if (!config
.sort_common
)
6602 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
6607 if (config
.sort_common
== sort_descending
)
6609 for (power
= 4; power
> 0; power
--)
6610 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6613 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6617 for (power
= 0; power
<= 4; power
++)
6618 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6620 power
= (unsigned int) -1;
6621 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6626 /* Place one common symbol in the correct section. */
6629 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
6631 unsigned int power_of_two
;
6635 if (h
->type
!= bfd_link_hash_common
)
6639 power_of_two
= h
->u
.c
.p
->alignment_power
;
6641 if (config
.sort_common
== sort_descending
6642 && power_of_two
< *(unsigned int *) info
)
6644 else if (config
.sort_common
== sort_ascending
6645 && power_of_two
> *(unsigned int *) info
)
6648 section
= h
->u
.c
.p
->section
;
6649 if (!bfd_define_common_symbol (link_info
.output_bfd
, &link_info
, h
))
6650 einfo (_("%F%P: could not define common symbol `%pT': %E\n"),
6653 if (config
.map_file
!= NULL
)
6655 static bfd_boolean header_printed
;
6660 if (!header_printed
)
6662 minfo (_("\nAllocating common symbols\n"));
6663 minfo (_("Common symbol size file\n\n"));
6664 header_printed
= TRUE
;
6667 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
6668 DMGL_ANSI
| DMGL_PARAMS
);
6671 minfo ("%s", h
->root
.string
);
6672 len
= strlen (h
->root
.string
);
6677 len
= strlen (name
);
6693 if (size
<= 0xffffffff)
6694 sprintf (buf
, "%lx", (unsigned long) size
);
6696 sprintf_vma (buf
, size
);
6706 minfo ("%pB\n", section
->owner
);
6712 /* Handle a single orphan section S, placing the orphan into an appropriate
6713 output section. The effects of the --orphan-handling command line
6714 option are handled here. */
6717 ldlang_place_orphan (asection
*s
)
6719 if (config
.orphan_handling
== orphan_handling_discard
)
6721 lang_output_section_statement_type
*os
;
6722 os
= lang_output_section_statement_lookup (DISCARD_SECTION_NAME
, 0,
6724 if (os
->addr_tree
== NULL
6725 && (bfd_link_relocatable (&link_info
)
6726 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6727 os
->addr_tree
= exp_intop (0);
6728 lang_add_section (&os
->children
, s
, NULL
, os
);
6732 lang_output_section_statement_type
*os
;
6733 const char *name
= s
->name
;
6736 if (config
.orphan_handling
== orphan_handling_error
)
6737 einfo (_("%X%P: error: unplaced orphan section `%pA' from `%pB'\n"),
6740 if (config
.unique_orphan_sections
|| unique_section_p (s
, NULL
))
6741 constraint
= SPECIAL
;
6743 os
= ldemul_place_orphan (s
, name
, constraint
);
6746 os
= lang_output_section_statement_lookup (name
, constraint
, TRUE
);
6747 if (os
->addr_tree
== NULL
6748 && (bfd_link_relocatable (&link_info
)
6749 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6750 os
->addr_tree
= exp_intop (0);
6751 lang_add_section (&os
->children
, s
, NULL
, os
);
6754 if (config
.orphan_handling
== orphan_handling_warn
)
6755 einfo (_("%P: warning: orphan section `%pA' from `%pB' being "
6756 "placed in section `%s'\n"),
6757 s
, s
->owner
, os
->name
);
6761 /* Run through the input files and ensure that every input section has
6762 somewhere to go. If one is found without a destination then create
6763 an input request and place it into the statement tree. */
6766 lang_place_orphans (void)
6768 LANG_FOR_EACH_INPUT_STATEMENT (file
)
6772 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6774 if (s
->output_section
== NULL
)
6776 /* This section of the file is not attached, root
6777 around for a sensible place for it to go. */
6779 if (file
->flags
.just_syms
)
6780 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
6781 else if (lang_discard_section_p (s
))
6782 s
->output_section
= bfd_abs_section_ptr
;
6783 else if (strcmp (s
->name
, "COMMON") == 0)
6785 /* This is a lonely common section which must have
6786 come from an archive. We attach to the section
6787 with the wildcard. */
6788 if (!bfd_link_relocatable (&link_info
)
6789 || command_line
.force_common_definition
)
6791 if (default_common_section
== NULL
)
6792 default_common_section
6793 = lang_output_section_statement_lookup (".bss", 0,
6795 lang_add_section (&default_common_section
->children
, s
,
6796 NULL
, default_common_section
);
6800 ldlang_place_orphan (s
);
6807 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
6809 flagword
*ptr_flags
;
6811 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
6817 /* PR 17900: An exclamation mark in the attributes reverses
6818 the sense of any of the attributes that follow. */
6821 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
6825 *ptr_flags
|= SEC_ALLOC
;
6829 *ptr_flags
|= SEC_READONLY
;
6833 *ptr_flags
|= SEC_DATA
;
6837 *ptr_flags
|= SEC_CODE
;
6842 *ptr_flags
|= SEC_LOAD
;
6846 einfo (_("%F%P: invalid character %c (%d) in flags\n"),
6854 /* Call a function on each real input file. This function will be
6855 called on an archive, but not on the elements. */
6858 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
6860 lang_input_statement_type
*f
;
6862 for (f
= &input_file_chain
.head
->input_statement
;
6864 f
= f
->next_real_file
)
6869 /* Call a function on each real file. The function will be called on
6870 all the elements of an archive which are included in the link, but
6871 will not be called on the archive file itself. */
6874 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
6876 LANG_FOR_EACH_INPUT_STATEMENT (f
)
6884 ldlang_add_file (lang_input_statement_type
*entry
)
6886 lang_statement_append (&file_chain
, entry
, &entry
->next
);
6888 /* The BFD linker needs to have a list of all input BFDs involved in
6890 ASSERT (entry
->the_bfd
->link
.next
== NULL
);
6891 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
6893 *link_info
.input_bfds_tail
= entry
->the_bfd
;
6894 link_info
.input_bfds_tail
= &entry
->the_bfd
->link
.next
;
6895 bfd_set_usrdata (entry
->the_bfd
, entry
);
6896 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
6898 /* Look through the sections and check for any which should not be
6899 included in the link. We need to do this now, so that we can
6900 notice when the backend linker tries to report multiple
6901 definition errors for symbols which are in sections we aren't
6902 going to link. FIXME: It might be better to entirely ignore
6903 symbols which are defined in sections which are going to be
6904 discarded. This would require modifying the backend linker for
6905 each backend which might set the SEC_LINK_ONCE flag. If we do
6906 this, we should probably handle SEC_EXCLUDE in the same way. */
6908 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
6912 lang_add_output (const char *name
, int from_script
)
6914 /* Make -o on command line override OUTPUT in script. */
6915 if (!had_output_filename
|| !from_script
)
6917 output_filename
= name
;
6918 had_output_filename
= TRUE
;
6922 lang_output_section_statement_type
*
6923 lang_enter_output_section_statement (const char *output_section_statement_name
,
6924 etree_type
*address_exp
,
6925 enum section_type sectype
,
6927 etree_type
*subalign
,
6930 int align_with_input
)
6932 lang_output_section_statement_type
*os
;
6934 os
= lang_output_section_statement_lookup (output_section_statement_name
,
6936 current_section
= os
;
6938 if (os
->addr_tree
== NULL
)
6940 os
->addr_tree
= address_exp
;
6942 os
->sectype
= sectype
;
6943 if (sectype
!= noload_section
)
6944 os
->flags
= SEC_NO_FLAGS
;
6946 os
->flags
= SEC_NEVER_LOAD
;
6947 os
->block_value
= 1;
6949 /* Make next things chain into subchain of this. */
6950 push_stat_ptr (&os
->children
);
6952 os
->align_lma_with_input
= align_with_input
== ALIGN_WITH_INPUT
;
6953 if (os
->align_lma_with_input
&& align
!= NULL
)
6954 einfo (_("%F%P:%pS: error: align with input and explicit align specified\n"),
6957 os
->subsection_alignment
= subalign
;
6958 os
->section_alignment
= align
;
6960 os
->load_base
= ebase
;
6967 lang_output_statement_type
*new_stmt
;
6969 new_stmt
= new_stat (lang_output_statement
, stat_ptr
);
6970 new_stmt
->name
= output_filename
;
6973 /* Reset the current counters in the regions. */
6976 lang_reset_memory_regions (void)
6978 lang_memory_region_type
*p
= lang_memory_region_list
;
6980 lang_output_section_statement_type
*os
;
6982 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
6984 p
->current
= p
->origin
;
6988 for (os
= &lang_os_list
.head
->output_section_statement
;
6992 os
->processed_vma
= FALSE
;
6993 os
->processed_lma
= FALSE
;
6996 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6998 /* Save the last size for possible use by bfd_relax_section. */
6999 o
->rawsize
= o
->size
;
7000 if (!(o
->flags
& SEC_FIXED_SIZE
))
7005 /* Worker for lang_gc_sections_1. */
7008 gc_section_callback (lang_wild_statement_type
*ptr
,
7009 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7011 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
7012 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7013 void *data ATTRIBUTE_UNUSED
)
7015 /* If the wild pattern was marked KEEP, the member sections
7016 should be as well. */
7017 if (ptr
->keep_sections
)
7018 section
->flags
|= SEC_KEEP
;
7021 /* Iterate over sections marking them against GC. */
7024 lang_gc_sections_1 (lang_statement_union_type
*s
)
7026 for (; s
!= NULL
; s
= s
->header
.next
)
7028 switch (s
->header
.type
)
7030 case lang_wild_statement_enum
:
7031 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
7033 case lang_constructors_statement_enum
:
7034 lang_gc_sections_1 (constructor_list
.head
);
7036 case lang_output_section_statement_enum
:
7037 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
7039 case lang_group_statement_enum
:
7040 lang_gc_sections_1 (s
->group_statement
.children
.head
);
7049 lang_gc_sections (void)
7051 /* Keep all sections so marked in the link script. */
7052 lang_gc_sections_1 (statement_list
.head
);
7054 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
7055 the special case of debug info. (See bfd/stabs.c)
7056 Twiddle the flag here, to simplify later linker code. */
7057 if (bfd_link_relocatable (&link_info
))
7059 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7062 #ifdef ENABLE_PLUGINS
7063 if (f
->flags
.claimed
)
7066 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7067 if ((sec
->flags
& SEC_DEBUGGING
) == 0)
7068 sec
->flags
&= ~SEC_EXCLUDE
;
7072 if (link_info
.gc_sections
)
7073 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
7076 /* Worker for lang_find_relro_sections_1. */
7079 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
7080 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7082 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
7083 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7086 /* Discarded, excluded and ignored sections effectively have zero
7088 if (section
->output_section
!= NULL
7089 && section
->output_section
->owner
== link_info
.output_bfd
7090 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
7091 && !IGNORE_SECTION (section
)
7092 && section
->size
!= 0)
7094 bfd_boolean
*has_relro_section
= (bfd_boolean
*) data
;
7095 *has_relro_section
= TRUE
;
7099 /* Iterate over sections for relro sections. */
7102 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
7103 seg_align_type
*seg
,
7104 bfd_boolean
*has_relro_section
)
7106 if (*has_relro_section
)
7109 for (; s
!= NULL
; s
= s
->header
.next
)
7111 if (s
== seg
->relro_end_stat
)
7114 switch (s
->header
.type
)
7116 case lang_wild_statement_enum
:
7117 walk_wild (&s
->wild_statement
,
7118 find_relro_section_callback
,
7121 case lang_constructors_statement_enum
:
7122 lang_find_relro_sections_1 (constructor_list
.head
,
7123 seg
, has_relro_section
);
7125 case lang_output_section_statement_enum
:
7126 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
7127 seg
, has_relro_section
);
7129 case lang_group_statement_enum
:
7130 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
7131 seg
, has_relro_section
);
7140 lang_find_relro_sections (void)
7142 bfd_boolean has_relro_section
= FALSE
;
7144 /* Check all sections in the link script. */
7146 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
7147 &expld
.dataseg
, &has_relro_section
);
7149 if (!has_relro_section
)
7150 link_info
.relro
= FALSE
;
7153 /* Relax all sections until bfd_relax_section gives up. */
7156 lang_relax_sections (bfd_boolean need_layout
)
7158 if (RELAXATION_ENABLED
)
7160 /* We may need more than one relaxation pass. */
7161 int i
= link_info
.relax_pass
;
7163 /* The backend can use it to determine the current pass. */
7164 link_info
.relax_pass
= 0;
7168 /* Keep relaxing until bfd_relax_section gives up. */
7169 bfd_boolean relax_again
;
7171 link_info
.relax_trip
= -1;
7174 link_info
.relax_trip
++;
7176 /* Note: pe-dll.c does something like this also. If you find
7177 you need to change this code, you probably need to change
7178 pe-dll.c also. DJ */
7180 /* Do all the assignments with our current guesses as to
7182 lang_do_assignments (lang_assigning_phase_enum
);
7184 /* We must do this after lang_do_assignments, because it uses
7186 lang_reset_memory_regions ();
7188 /* Perform another relax pass - this time we know where the
7189 globals are, so can make a better guess. */
7190 relax_again
= FALSE
;
7191 lang_size_sections (&relax_again
, FALSE
);
7193 while (relax_again
);
7195 link_info
.relax_pass
++;
7202 /* Final extra sizing to report errors. */
7203 lang_do_assignments (lang_assigning_phase_enum
);
7204 lang_reset_memory_regions ();
7205 lang_size_sections (NULL
, TRUE
);
7209 #ifdef ENABLE_PLUGINS
7210 /* Find the insert point for the plugin's replacement files. We
7211 place them after the first claimed real object file, or if the
7212 first claimed object is an archive member, after the last real
7213 object file immediately preceding the archive. In the event
7214 no objects have been claimed at all, we return the first dummy
7215 object file on the list as the insert point; that works, but
7216 the callee must be careful when relinking the file_chain as it
7217 is not actually on that chain, only the statement_list and the
7218 input_file list; in that case, the replacement files must be
7219 inserted at the head of the file_chain. */
7221 static lang_input_statement_type
*
7222 find_replacements_insert_point (bfd_boolean
*before
)
7224 lang_input_statement_type
*claim1
, *lastobject
;
7225 lastobject
= &input_file_chain
.head
->input_statement
;
7226 for (claim1
= &file_chain
.head
->input_statement
;
7228 claim1
= claim1
->next
)
7230 if (claim1
->flags
.claimed
)
7232 *before
= claim1
->flags
.claim_archive
;
7233 return claim1
->flags
.claim_archive
? lastobject
: claim1
;
7235 /* Update lastobject if this is a real object file. */
7236 if (claim1
->the_bfd
!= NULL
&& claim1
->the_bfd
->my_archive
== NULL
)
7237 lastobject
= claim1
;
7239 /* No files were claimed by the plugin. Choose the last object
7240 file found on the list (maybe the first, dummy entry) as the
7246 /* Find where to insert ADD, an archive element or shared library
7247 added during a rescan. */
7249 static lang_input_statement_type
**
7250 find_rescan_insertion (lang_input_statement_type
*add
)
7252 bfd
*add_bfd
= add
->the_bfd
;
7253 lang_input_statement_type
*f
;
7254 lang_input_statement_type
*last_loaded
= NULL
;
7255 lang_input_statement_type
*before
= NULL
;
7256 lang_input_statement_type
**iter
= NULL
;
7258 if (add_bfd
->my_archive
!= NULL
)
7259 add_bfd
= add_bfd
->my_archive
;
7261 /* First look through the input file chain, to find an object file
7262 before the one we've rescanned. Normal object files always
7263 appear on both the input file chain and the file chain, so this
7264 lets us get quickly to somewhere near the correct place on the
7265 file chain if it is full of archive elements. Archives don't
7266 appear on the file chain, but if an element has been extracted
7267 then their input_statement->next points at it. */
7268 for (f
= &input_file_chain
.head
->input_statement
;
7270 f
= f
->next_real_file
)
7272 if (f
->the_bfd
== add_bfd
)
7274 before
= last_loaded
;
7275 if (f
->next
!= NULL
)
7276 return &f
->next
->next
;
7278 if (f
->the_bfd
!= NULL
&& f
->next
!= NULL
)
7282 for (iter
= before
? &before
->next
: &file_chain
.head
->input_statement
.next
;
7284 iter
= &(*iter
)->next
)
7285 if (!(*iter
)->flags
.claim_archive
7286 && (*iter
)->the_bfd
->my_archive
== NULL
)
7292 /* Insert SRCLIST into DESTLIST after given element by chaining
7293 on FIELD as the next-pointer. (Counterintuitively does not need
7294 a pointer to the actual after-node itself, just its chain field.) */
7297 lang_list_insert_after (lang_statement_list_type
*destlist
,
7298 lang_statement_list_type
*srclist
,
7299 lang_statement_union_type
**field
)
7301 *(srclist
->tail
) = *field
;
7302 *field
= srclist
->head
;
7303 if (destlist
->tail
== field
)
7304 destlist
->tail
= srclist
->tail
;
7307 /* Detach new nodes added to DESTLIST since the time ORIGLIST
7308 was taken as a copy of it and leave them in ORIGLIST. */
7311 lang_list_remove_tail (lang_statement_list_type
*destlist
,
7312 lang_statement_list_type
*origlist
)
7314 union lang_statement_union
**savetail
;
7315 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
7316 ASSERT (origlist
->head
== destlist
->head
);
7317 savetail
= origlist
->tail
;
7318 origlist
->head
= *(savetail
);
7319 origlist
->tail
= destlist
->tail
;
7320 destlist
->tail
= savetail
;
7324 static lang_statement_union_type
**
7325 find_next_input_statement (lang_statement_union_type
**s
)
7327 for ( ; *s
; s
= &(*s
)->header
.next
)
7329 lang_statement_union_type
**t
;
7330 switch ((*s
)->header
.type
)
7332 case lang_input_statement_enum
:
7334 case lang_wild_statement_enum
:
7335 t
= &(*s
)->wild_statement
.children
.head
;
7337 case lang_group_statement_enum
:
7338 t
= &(*s
)->group_statement
.children
.head
;
7340 case lang_output_section_statement_enum
:
7341 t
= &(*s
)->output_section_statement
.children
.head
;
7346 t
= find_next_input_statement (t
);
7352 #endif /* ENABLE_PLUGINS */
7354 /* Add NAME to the list of garbage collection entry points. */
7357 lang_add_gc_name (const char *name
)
7359 struct bfd_sym_chain
*sym
;
7364 sym
= stat_alloc (sizeof (*sym
));
7366 sym
->next
= link_info
.gc_sym_list
;
7368 link_info
.gc_sym_list
= sym
;
7371 /* Check relocations. */
7374 lang_check_relocs (void)
7376 if (link_info
.check_relocs_after_open_input
)
7380 for (abfd
= link_info
.input_bfds
;
7381 abfd
!= (bfd
*) NULL
; abfd
= abfd
->link
.next
)
7382 if (!bfd_link_check_relocs (abfd
, &link_info
))
7384 /* No object output, fail return. */
7385 config
.make_executable
= FALSE
;
7386 /* Note: we do not abort the loop, but rather
7387 continue the scan in case there are other
7388 bad relocations to report. */
7393 /* Look through all output sections looking for places where we can
7394 propagate forward the lma region. */
7397 lang_propagate_lma_regions (void)
7399 lang_output_section_statement_type
*os
;
7401 for (os
= &lang_os_list
.head
->output_section_statement
;
7405 if (os
->prev
!= NULL
7406 && os
->lma_region
== NULL
7407 && os
->load_base
== NULL
7408 && os
->addr_tree
== NULL
7409 && os
->region
== os
->prev
->region
)
7410 os
->lma_region
= os
->prev
->lma_region
;
7417 /* Finalize dynamic list. */
7418 if (link_info
.dynamic_list
)
7419 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
7421 current_target
= default_target
;
7423 /* Open the output file. */
7424 lang_for_each_statement (ldlang_open_output
);
7427 ldemul_create_output_section_statements ();
7429 /* Add to the hash table all undefineds on the command line. */
7430 lang_place_undefineds ();
7432 if (!bfd_section_already_linked_table_init ())
7433 einfo (_("%F%P: can not create hash table: %E\n"));
7435 /* Create a bfd for each input file. */
7436 current_target
= default_target
;
7437 lang_statement_iteration
++;
7438 open_input_bfds (statement_list
.head
, OPEN_BFD_NORMAL
);
7439 /* open_input_bfds also handles assignments, so we can give values
7440 to symbolic origin/length now. */
7441 lang_do_memory_regions ();
7443 #ifdef ENABLE_PLUGINS
7444 if (link_info
.lto_plugin_active
)
7446 lang_statement_list_type added
;
7447 lang_statement_list_type files
, inputfiles
;
7449 /* Now all files are read, let the plugin(s) decide if there
7450 are any more to be added to the link before we call the
7451 emulation's after_open hook. We create a private list of
7452 input statements for this purpose, which we will eventually
7453 insert into the global statement list after the first claimed
7456 /* We need to manipulate all three chains in synchrony. */
7458 inputfiles
= input_file_chain
;
7459 if (plugin_call_all_symbols_read ())
7460 einfo (_("%F%P: %s: plugin reported error after all symbols read\n"),
7461 plugin_error_plugin ());
7462 /* Open any newly added files, updating the file chains. */
7463 plugin_undefs
= link_info
.hash
->undefs_tail
;
7464 open_input_bfds (*added
.tail
, OPEN_BFD_NORMAL
);
7465 if (plugin_undefs
== link_info
.hash
->undefs_tail
)
7466 plugin_undefs
= NULL
;
7467 /* Restore the global list pointer now they have all been added. */
7468 lang_list_remove_tail (stat_ptr
, &added
);
7469 /* And detach the fresh ends of the file lists. */
7470 lang_list_remove_tail (&file_chain
, &files
);
7471 lang_list_remove_tail (&input_file_chain
, &inputfiles
);
7472 /* Were any new files added? */
7473 if (added
.head
!= NULL
)
7475 /* If so, we will insert them into the statement list immediately
7476 after the first input file that was claimed by the plugin,
7477 unless that file was an archive in which case it is inserted
7478 immediately before. */
7480 lang_statement_union_type
**prev
;
7481 plugin_insert
= find_replacements_insert_point (&before
);
7482 /* If a plugin adds input files without having claimed any, we
7483 don't really have a good idea where to place them. Just putting
7484 them at the start or end of the list is liable to leave them
7485 outside the crtbegin...crtend range. */
7486 ASSERT (plugin_insert
!= NULL
);
7487 /* Splice the new statement list into the old one. */
7488 prev
= &plugin_insert
->header
.next
;
7491 prev
= find_next_input_statement (prev
);
7492 if (*prev
!= (void *) plugin_insert
->next_real_file
)
7494 /* We didn't find the expected input statement.
7495 Fall back to adding after plugin_insert. */
7496 prev
= &plugin_insert
->header
.next
;
7499 lang_list_insert_after (stat_ptr
, &added
, prev
);
7500 /* Likewise for the file chains. */
7501 lang_list_insert_after (&input_file_chain
, &inputfiles
,
7502 (void *) &plugin_insert
->next_real_file
);
7503 /* We must be careful when relinking file_chain; we may need to
7504 insert the new files at the head of the list if the insert
7505 point chosen is the dummy first input file. */
7506 if (plugin_insert
->filename
)
7507 lang_list_insert_after (&file_chain
, &files
,
7508 (void *) &plugin_insert
->next
);
7510 lang_list_insert_after (&file_chain
, &files
, &file_chain
.head
);
7512 /* Rescan archives in case new undefined symbols have appeared. */
7514 lang_statement_iteration
++;
7515 open_input_bfds (statement_list
.head
, OPEN_BFD_RESCAN
);
7516 lang_list_remove_tail (&file_chain
, &files
);
7517 while (files
.head
!= NULL
)
7519 lang_input_statement_type
**insert
;
7520 lang_input_statement_type
**iter
, *temp
;
7523 insert
= find_rescan_insertion (&files
.head
->input_statement
);
7524 /* All elements from an archive can be added at once. */
7525 iter
= &files
.head
->input_statement
.next
;
7526 my_arch
= files
.head
->input_statement
.the_bfd
->my_archive
;
7527 if (my_arch
!= NULL
)
7528 for (; *iter
!= NULL
; iter
= &(*iter
)->next
)
7529 if ((*iter
)->the_bfd
->my_archive
!= my_arch
)
7532 *insert
= &files
.head
->input_statement
;
7533 files
.head
= (lang_statement_union_type
*) *iter
;
7535 if (my_arch
!= NULL
)
7537 lang_input_statement_type
*parent
= bfd_usrdata (my_arch
);
7539 parent
->next
= (lang_input_statement_type
*)
7541 - offsetof (lang_input_statement_type
, next
));
7546 #endif /* ENABLE_PLUGINS */
7548 /* Make sure that nobody has tried to add a symbol to this list
7550 ASSERT (link_info
.gc_sym_list
== NULL
);
7552 link_info
.gc_sym_list
= &entry_symbol
;
7554 if (entry_symbol
.name
== NULL
)
7556 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
7558 /* entry_symbol is normally initialied by a ENTRY definition in the
7559 linker script or the -e command line option. But if neither of
7560 these have been used, the target specific backend may still have
7561 provided an entry symbol via a call to lang_default_entry().
7562 Unfortunately this value will not be processed until lang_end()
7563 is called, long after this function has finished. So detect this
7564 case here and add the target's entry symbol to the list of starting
7565 points for garbage collection resolution. */
7566 lang_add_gc_name (entry_symbol_default
);
7569 lang_add_gc_name (link_info
.init_function
);
7570 lang_add_gc_name (link_info
.fini_function
);
7572 ldemul_after_open ();
7573 if (config
.map_file
!= NULL
)
7574 lang_print_asneeded ();
7576 bfd_section_already_linked_table_free ();
7578 /* Make sure that we're not mixing architectures. We call this
7579 after all the input files have been opened, but before we do any
7580 other processing, so that any operations merge_private_bfd_data
7581 does on the output file will be known during the rest of the
7585 /* Handle .exports instead of a version script if we're told to do so. */
7586 if (command_line
.version_exports_section
)
7587 lang_do_version_exports_section ();
7589 /* Build all sets based on the information gathered from the input
7591 ldctor_build_sets ();
7593 /* Give initial values for __start and __stop symbols, so that ELF
7594 gc_sections will keep sections referenced by these symbols. Must
7595 be done before lang_do_assignments below. */
7596 if (config
.build_constructors
)
7597 lang_init_start_stop ();
7599 /* PR 13683: We must rerun the assignments prior to running garbage
7600 collection in order to make sure that all symbol aliases are resolved. */
7601 lang_do_assignments (lang_mark_phase_enum
);
7602 expld
.phase
= lang_first_phase_enum
;
7604 /* Size up the common data. */
7607 /* Remove unreferenced sections if asked to. */
7608 lang_gc_sections ();
7610 /* Check relocations. */
7611 lang_check_relocs ();
7613 ldemul_after_check_relocs ();
7615 /* Update wild statements. */
7616 update_wild_statements (statement_list
.head
);
7618 /* Run through the contours of the script and attach input sections
7619 to the correct output sections. */
7620 lang_statement_iteration
++;
7621 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
7623 /* Start at the statement immediately after the special abs_section
7624 output statement, so that it isn't reordered. */
7625 process_insert_statements (&lang_os_list
.head
->header
.next
);
7627 /* Find any sections not attached explicitly and handle them. */
7628 lang_place_orphans ();
7630 if (!bfd_link_relocatable (&link_info
))
7634 /* Merge SEC_MERGE sections. This has to be done after GC of
7635 sections, so that GCed sections are not merged, but before
7636 assigning dynamic symbols, since removing whole input sections
7638 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
7640 /* Look for a text section and set the readonly attribute in it. */
7641 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
7645 if (config
.text_read_only
)
7646 found
->flags
|= SEC_READONLY
;
7648 found
->flags
&= ~SEC_READONLY
;
7652 /* Copy forward lma regions for output sections in same lma region. */
7653 lang_propagate_lma_regions ();
7655 /* Defining __start/__stop symbols early for --gc-sections to work
7656 around a glibc build problem can result in these symbols being
7657 defined when they should not be. Fix them now. */
7658 if (config
.build_constructors
)
7659 lang_undef_start_stop ();
7661 /* Define .startof./.sizeof. symbols with preliminary values before
7662 dynamic symbols are created. */
7663 if (!bfd_link_relocatable (&link_info
))
7664 lang_init_startof_sizeof ();
7666 /* Do anything special before sizing sections. This is where ELF
7667 and other back-ends size dynamic sections. */
7668 ldemul_before_allocation ();
7670 /* We must record the program headers before we try to fix the
7671 section positions, since they will affect SIZEOF_HEADERS. */
7672 lang_record_phdrs ();
7674 /* Check relro sections. */
7675 if (link_info
.relro
&& !bfd_link_relocatable (&link_info
))
7676 lang_find_relro_sections ();
7678 /* Size up the sections. */
7679 lang_size_sections (NULL
, !RELAXATION_ENABLED
);
7681 /* See if anything special should be done now we know how big
7682 everything is. This is where relaxation is done. */
7683 ldemul_after_allocation ();
7685 /* Fix any __start, __stop, .startof. or .sizeof. symbols. */
7686 lang_finalize_start_stop ();
7688 /* Do all the assignments again, to report errors. Assignment
7689 statements are processed multiple times, updating symbols; In
7690 open_input_bfds, lang_do_assignments, and lang_size_sections.
7691 Since lang_relax_sections calls lang_do_assignments, symbols are
7692 also updated in ldemul_after_allocation. */
7693 lang_do_assignments (lang_final_phase_enum
);
7697 /* Convert absolute symbols to section relative. */
7698 ldexp_finalize_syms ();
7700 /* Make sure that the section addresses make sense. */
7701 if (command_line
.check_section_addresses
)
7702 lang_check_section_addresses ();
7704 /* Check any required symbols are known. */
7705 ldlang_check_require_defined_symbols ();
7710 /* EXPORTED TO YACC */
7713 lang_add_wild (struct wildcard_spec
*filespec
,
7714 struct wildcard_list
*section_list
,
7715 bfd_boolean keep_sections
)
7717 struct wildcard_list
*curr
, *next
;
7718 lang_wild_statement_type
*new_stmt
;
7720 /* Reverse the list as the parser puts it back to front. */
7721 for (curr
= section_list
, section_list
= NULL
;
7723 section_list
= curr
, curr
= next
)
7726 curr
->next
= section_list
;
7729 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
7731 if (strcmp (filespec
->name
, "*") == 0)
7732 filespec
->name
= NULL
;
7733 else if (!wildcardp (filespec
->name
))
7734 lang_has_input_file
= TRUE
;
7737 new_stmt
= new_stat (lang_wild_statement
, stat_ptr
);
7738 new_stmt
->filename
= NULL
;
7739 new_stmt
->filenames_sorted
= FALSE
;
7740 new_stmt
->section_flag_list
= NULL
;
7741 new_stmt
->exclude_name_list
= NULL
;
7742 if (filespec
!= NULL
)
7744 new_stmt
->filename
= filespec
->name
;
7745 new_stmt
->filenames_sorted
= filespec
->sorted
== by_name
;
7746 new_stmt
->section_flag_list
= filespec
->section_flag_list
;
7747 new_stmt
->exclude_name_list
= filespec
->exclude_name_list
;
7749 new_stmt
->section_list
= section_list
;
7750 new_stmt
->keep_sections
= keep_sections
;
7751 lang_list_init (&new_stmt
->children
);
7752 analyze_walk_wild_section_handler (new_stmt
);
7756 lang_section_start (const char *name
, etree_type
*address
,
7757 const segment_type
*segment
)
7759 lang_address_statement_type
*ad
;
7761 ad
= new_stat (lang_address_statement
, stat_ptr
);
7762 ad
->section_name
= name
;
7763 ad
->address
= address
;
7764 ad
->segment
= segment
;
7767 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
7768 because of a -e argument on the command line, or zero if this is
7769 called by ENTRY in a linker script. Command line arguments take
7773 lang_add_entry (const char *name
, bfd_boolean cmdline
)
7775 if (entry_symbol
.name
== NULL
7777 || !entry_from_cmdline
)
7779 entry_symbol
.name
= name
;
7780 entry_from_cmdline
= cmdline
;
7784 /* Set the default start symbol to NAME. .em files should use this,
7785 not lang_add_entry, to override the use of "start" if neither the
7786 linker script nor the command line specifies an entry point. NAME
7787 must be permanently allocated. */
7789 lang_default_entry (const char *name
)
7791 entry_symbol_default
= name
;
7795 lang_add_target (const char *name
)
7797 lang_target_statement_type
*new_stmt
;
7799 new_stmt
= new_stat (lang_target_statement
, stat_ptr
);
7800 new_stmt
->target
= name
;
7804 lang_add_map (const char *name
)
7811 map_option_f
= TRUE
;
7819 lang_add_fill (fill_type
*fill
)
7821 lang_fill_statement_type
*new_stmt
;
7823 new_stmt
= new_stat (lang_fill_statement
, stat_ptr
);
7824 new_stmt
->fill
= fill
;
7828 lang_add_data (int type
, union etree_union
*exp
)
7830 lang_data_statement_type
*new_stmt
;
7832 new_stmt
= new_stat (lang_data_statement
, stat_ptr
);
7833 new_stmt
->exp
= exp
;
7834 new_stmt
->type
= type
;
7837 /* Create a new reloc statement. RELOC is the BFD relocation type to
7838 generate. HOWTO is the corresponding howto structure (we could
7839 look this up, but the caller has already done so). SECTION is the
7840 section to generate a reloc against, or NAME is the name of the
7841 symbol to generate a reloc against. Exactly one of SECTION and
7842 NAME must be NULL. ADDEND is an expression for the addend. */
7845 lang_add_reloc (bfd_reloc_code_real_type reloc
,
7846 reloc_howto_type
*howto
,
7849 union etree_union
*addend
)
7851 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
7855 p
->section
= section
;
7857 p
->addend_exp
= addend
;
7859 p
->addend_value
= 0;
7860 p
->output_section
= NULL
;
7861 p
->output_offset
= 0;
7864 lang_assignment_statement_type
*
7865 lang_add_assignment (etree_type
*exp
)
7867 lang_assignment_statement_type
*new_stmt
;
7869 new_stmt
= new_stat (lang_assignment_statement
, stat_ptr
);
7870 new_stmt
->exp
= exp
;
7875 lang_add_attribute (enum statement_enum attribute
)
7877 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
7881 lang_startup (const char *name
)
7883 if (first_file
->filename
!= NULL
)
7885 einfo (_("%F%P: multiple STARTUP files\n"));
7887 first_file
->filename
= name
;
7888 first_file
->local_sym_name
= name
;
7889 first_file
->flags
.real
= TRUE
;
7893 lang_float (bfd_boolean maybe
)
7895 lang_float_flag
= maybe
;
7899 /* Work out the load- and run-time regions from a script statement, and
7900 store them in *LMA_REGION and *REGION respectively.
7902 MEMSPEC is the name of the run-time region, or the value of
7903 DEFAULT_MEMORY_REGION if the statement didn't specify one.
7904 LMA_MEMSPEC is the name of the load-time region, or null if the
7905 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
7906 had an explicit load address.
7908 It is an error to specify both a load region and a load address. */
7911 lang_get_regions (lang_memory_region_type
**region
,
7912 lang_memory_region_type
**lma_region
,
7913 const char *memspec
,
7914 const char *lma_memspec
,
7915 bfd_boolean have_lma
,
7916 bfd_boolean have_vma
)
7918 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
7920 /* If no runtime region or VMA has been specified, but the load region
7921 has been specified, then use the load region for the runtime region
7923 if (lma_memspec
!= NULL
7925 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
7926 *region
= *lma_region
;
7928 *region
= lang_memory_region_lookup (memspec
, FALSE
);
7930 if (have_lma
&& lma_memspec
!= 0)
7931 einfo (_("%X%P:%pS: section has both a load address and a load region\n"),
7936 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
7937 lang_output_section_phdr_list
*phdrs
,
7938 const char *lma_memspec
)
7940 lang_get_regions (¤t_section
->region
,
7941 ¤t_section
->lma_region
,
7942 memspec
, lma_memspec
,
7943 current_section
->load_base
!= NULL
,
7944 current_section
->addr_tree
!= NULL
);
7946 current_section
->fill
= fill
;
7947 current_section
->phdrs
= phdrs
;
7951 /* Set the output format type. -oformat overrides scripts. */
7954 lang_add_output_format (const char *format
,
7959 if (output_target
== NULL
|| !from_script
)
7961 if (command_line
.endian
== ENDIAN_BIG
7964 else if (command_line
.endian
== ENDIAN_LITTLE
7968 output_target
= format
;
7973 lang_add_insert (const char *where
, int is_before
)
7975 lang_insert_statement_type
*new_stmt
;
7977 new_stmt
= new_stat (lang_insert_statement
, stat_ptr
);
7978 new_stmt
->where
= where
;
7979 new_stmt
->is_before
= is_before
;
7980 saved_script_handle
= previous_script_handle
;
7983 /* Enter a group. This creates a new lang_group_statement, and sets
7984 stat_ptr to build new statements within the group. */
7987 lang_enter_group (void)
7989 lang_group_statement_type
*g
;
7991 g
= new_stat (lang_group_statement
, stat_ptr
);
7992 lang_list_init (&g
->children
);
7993 push_stat_ptr (&g
->children
);
7996 /* Leave a group. This just resets stat_ptr to start writing to the
7997 regular list of statements again. Note that this will not work if
7998 groups can occur inside anything else which can adjust stat_ptr,
7999 but currently they can't. */
8002 lang_leave_group (void)
8007 /* Add a new program header. This is called for each entry in a PHDRS
8008 command in a linker script. */
8011 lang_new_phdr (const char *name
,
8013 bfd_boolean filehdr
,
8018 struct lang_phdr
*n
, **pp
;
8021 n
= stat_alloc (sizeof (struct lang_phdr
));
8024 n
->type
= exp_get_vma (type
, 0, "program header type");
8025 n
->filehdr
= filehdr
;
8030 hdrs
= n
->type
== 1 && (phdrs
|| filehdr
);
8032 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
8035 && !((*pp
)->filehdr
|| (*pp
)->phdrs
))
8037 einfo (_("%X%P:%pS: PHDRS and FILEHDR are not supported"
8038 " when prior PT_LOAD headers lack them\n"), NULL
);
8045 /* Record the program header information in the output BFD. FIXME: We
8046 should not be calling an ELF specific function here. */
8049 lang_record_phdrs (void)
8053 lang_output_section_phdr_list
*last
;
8054 struct lang_phdr
*l
;
8055 lang_output_section_statement_type
*os
;
8058 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
8061 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
8068 for (os
= &lang_os_list
.head
->output_section_statement
;
8072 lang_output_section_phdr_list
*pl
;
8074 if (os
->constraint
< 0)
8082 if (os
->sectype
== noload_section
8083 || os
->bfd_section
== NULL
8084 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
8087 /* Don't add orphans to PT_INTERP header. */
8093 lang_output_section_statement_type
*tmp_os
;
8095 /* If we have not run across a section with a program
8096 header assigned to it yet, then scan forwards to find
8097 one. This prevents inconsistencies in the linker's
8098 behaviour when a script has specified just a single
8099 header and there are sections in that script which are
8100 not assigned to it, and which occur before the first
8101 use of that header. See here for more details:
8102 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
8103 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
8106 last
= tmp_os
->phdrs
;
8110 einfo (_("%F%P: no sections assigned to phdrs\n"));
8115 if (os
->bfd_section
== NULL
)
8118 for (; pl
!= NULL
; pl
= pl
->next
)
8120 if (strcmp (pl
->name
, l
->name
) == 0)
8125 secs
= (asection
**) xrealloc (secs
,
8126 alc
* sizeof (asection
*));
8128 secs
[c
] = os
->bfd_section
;
8135 if (l
->flags
== NULL
)
8138 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
8143 at
= exp_get_vma (l
->at
, 0, "phdr load address");
8145 if (!bfd_record_phdr (link_info
.output_bfd
, l
->type
,
8146 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
8147 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
8148 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
8153 /* Make sure all the phdr assignments succeeded. */
8154 for (os
= &lang_os_list
.head
->output_section_statement
;
8158 lang_output_section_phdr_list
*pl
;
8160 if (os
->constraint
< 0
8161 || os
->bfd_section
== NULL
)
8164 for (pl
= os
->phdrs
;
8167 if (!pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
8168 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
8169 os
->name
, pl
->name
);
8173 /* Record a list of sections which may not be cross referenced. */
8176 lang_add_nocrossref (lang_nocrossref_type
*l
)
8178 struct lang_nocrossrefs
*n
;
8180 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
8181 n
->next
= nocrossref_list
;
8183 n
->onlyfirst
= FALSE
;
8184 nocrossref_list
= n
;
8186 /* Set notice_all so that we get informed about all symbols. */
8187 link_info
.notice_all
= TRUE
;
8190 /* Record a section that cannot be referenced from a list of sections. */
8193 lang_add_nocrossref_to (lang_nocrossref_type
*l
)
8195 lang_add_nocrossref (l
);
8196 nocrossref_list
->onlyfirst
= TRUE
;
8199 /* Overlay handling. We handle overlays with some static variables. */
8201 /* The overlay virtual address. */
8202 static etree_type
*overlay_vma
;
8203 /* And subsection alignment. */
8204 static etree_type
*overlay_subalign
;
8206 /* An expression for the maximum section size seen so far. */
8207 static etree_type
*overlay_max
;
8209 /* A list of all the sections in this overlay. */
8211 struct overlay_list
{
8212 struct overlay_list
*next
;
8213 lang_output_section_statement_type
*os
;
8216 static struct overlay_list
*overlay_list
;
8218 /* Start handling an overlay. */
8221 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
8223 /* The grammar should prevent nested overlays from occurring. */
8224 ASSERT (overlay_vma
== NULL
8225 && overlay_subalign
== NULL
8226 && overlay_max
== NULL
);
8228 overlay_vma
= vma_expr
;
8229 overlay_subalign
= subalign
;
8232 /* Start a section in an overlay. We handle this by calling
8233 lang_enter_output_section_statement with the correct VMA.
8234 lang_leave_overlay sets up the LMA and memory regions. */
8237 lang_enter_overlay_section (const char *name
)
8239 struct overlay_list
*n
;
8242 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
8243 0, overlay_subalign
, 0, 0, 0);
8245 /* If this is the first section, then base the VMA of future
8246 sections on this one. This will work correctly even if `.' is
8247 used in the addresses. */
8248 if (overlay_list
== NULL
)
8249 overlay_vma
= exp_nameop (ADDR
, name
);
8251 /* Remember the section. */
8252 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
8253 n
->os
= current_section
;
8254 n
->next
= overlay_list
;
8257 size
= exp_nameop (SIZEOF
, name
);
8259 /* Arrange to work out the maximum section end address. */
8260 if (overlay_max
== NULL
)
8263 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
8266 /* Finish a section in an overlay. There isn't any special to do
8270 lang_leave_overlay_section (fill_type
*fill
,
8271 lang_output_section_phdr_list
*phdrs
)
8278 name
= current_section
->name
;
8280 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
8281 region and that no load-time region has been specified. It doesn't
8282 really matter what we say here, since lang_leave_overlay will
8284 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
8286 /* Define the magic symbols. */
8288 clean
= (char *) xmalloc (strlen (name
) + 1);
8290 for (s1
= name
; *s1
!= '\0'; s1
++)
8291 if (ISALNUM (*s1
) || *s1
== '_')
8295 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_start_");
8296 sprintf (buf
, "__load_start_%s", clean
);
8297 lang_add_assignment (exp_provide (buf
,
8298 exp_nameop (LOADADDR
, name
),
8301 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_stop_");
8302 sprintf (buf
, "__load_stop_%s", clean
);
8303 lang_add_assignment (exp_provide (buf
,
8305 exp_nameop (LOADADDR
, name
),
8306 exp_nameop (SIZEOF
, name
)),
8312 /* Finish an overlay. If there are any overlay wide settings, this
8313 looks through all the sections in the overlay and sets them. */
8316 lang_leave_overlay (etree_type
*lma_expr
,
8319 const char *memspec
,
8320 lang_output_section_phdr_list
*phdrs
,
8321 const char *lma_memspec
)
8323 lang_memory_region_type
*region
;
8324 lang_memory_region_type
*lma_region
;
8325 struct overlay_list
*l
;
8326 lang_nocrossref_type
*nocrossref
;
8328 lang_get_regions (®ion
, &lma_region
,
8329 memspec
, lma_memspec
,
8330 lma_expr
!= NULL
, FALSE
);
8334 /* After setting the size of the last section, set '.' to end of the
8336 if (overlay_list
!= NULL
)
8338 overlay_list
->os
->update_dot
= 1;
8339 overlay_list
->os
->update_dot_tree
8340 = exp_assign (".", exp_binop ('+', overlay_vma
, overlay_max
), FALSE
);
8346 struct overlay_list
*next
;
8348 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
8351 l
->os
->region
= region
;
8352 l
->os
->lma_region
= lma_region
;
8354 /* The first section has the load address specified in the
8355 OVERLAY statement. The rest are worked out from that.
8356 The base address is not needed (and should be null) if
8357 an LMA region was specified. */
8360 l
->os
->load_base
= lma_expr
;
8361 l
->os
->sectype
= first_overlay_section
;
8363 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
8364 l
->os
->phdrs
= phdrs
;
8368 lang_nocrossref_type
*nc
;
8370 nc
= (lang_nocrossref_type
*) xmalloc (sizeof *nc
);
8371 nc
->name
= l
->os
->name
;
8372 nc
->next
= nocrossref
;
8381 if (nocrossref
!= NULL
)
8382 lang_add_nocrossref (nocrossref
);
8385 overlay_list
= NULL
;
8387 overlay_subalign
= NULL
;
8390 /* Version handling. This is only useful for ELF. */
8392 /* If PREV is NULL, return first version pattern matching particular symbol.
8393 If PREV is non-NULL, return first version pattern matching particular
8394 symbol after PREV (previously returned by lang_vers_match). */
8396 static struct bfd_elf_version_expr
*
8397 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
8398 struct bfd_elf_version_expr
*prev
,
8402 const char *cxx_sym
= sym
;
8403 const char *java_sym
= sym
;
8404 struct bfd_elf_version_expr
*expr
= NULL
;
8405 enum demangling_styles curr_style
;
8407 curr_style
= CURRENT_DEMANGLING_STYLE
;
8408 cplus_demangle_set_style (no_demangling
);
8409 c_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_NO_OPTS
);
8412 cplus_demangle_set_style (curr_style
);
8414 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8416 cxx_sym
= bfd_demangle (link_info
.output_bfd
, sym
,
8417 DMGL_PARAMS
| DMGL_ANSI
);
8421 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8423 java_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_JAVA
);
8428 if (head
->htab
&& (prev
== NULL
|| prev
->literal
))
8430 struct bfd_elf_version_expr e
;
8432 switch (prev
? prev
->mask
: 0)
8435 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
8438 expr
= (struct bfd_elf_version_expr
*)
8439 htab_find ((htab_t
) head
->htab
, &e
);
8440 while (expr
&& strcmp (expr
->pattern
, c_sym
) == 0)
8441 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
8447 case BFD_ELF_VERSION_C_TYPE
:
8448 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8450 e
.pattern
= cxx_sym
;
8451 expr
= (struct bfd_elf_version_expr
*)
8452 htab_find ((htab_t
) head
->htab
, &e
);
8453 while (expr
&& strcmp (expr
->pattern
, cxx_sym
) == 0)
8454 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
8460 case BFD_ELF_VERSION_CXX_TYPE
:
8461 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8463 e
.pattern
= java_sym
;
8464 expr
= (struct bfd_elf_version_expr
*)
8465 htab_find ((htab_t
) head
->htab
, &e
);
8466 while (expr
&& strcmp (expr
->pattern
, java_sym
) == 0)
8467 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8478 /* Finally, try the wildcards. */
8479 if (prev
== NULL
|| prev
->literal
)
8480 expr
= head
->remaining
;
8483 for (; expr
; expr
= expr
->next
)
8490 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
8493 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8495 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
8499 if (fnmatch (expr
->pattern
, s
, 0) == 0)
8505 free ((char *) c_sym
);
8507 free ((char *) cxx_sym
);
8508 if (java_sym
!= sym
)
8509 free ((char *) java_sym
);
8513 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
8514 return a pointer to the symbol name with any backslash quotes removed. */
8517 realsymbol (const char *pattern
)
8520 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
8521 char *s
, *symbol
= (char *) xmalloc (strlen (pattern
) + 1);
8523 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
8525 /* It is a glob pattern only if there is no preceding
8529 /* Remove the preceding backslash. */
8536 if (*p
== '?' || *p
== '*' || *p
== '[')
8543 backslash
= *p
== '\\';
8559 /* This is called for each variable name or match expression. NEW_NAME is
8560 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
8561 pattern to be matched against symbol names. */
8563 struct bfd_elf_version_expr
*
8564 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
8565 const char *new_name
,
8567 bfd_boolean literal_p
)
8569 struct bfd_elf_version_expr
*ret
;
8571 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
8575 ret
->literal
= TRUE
;
8576 ret
->pattern
= literal_p
? new_name
: realsymbol (new_name
);
8577 if (ret
->pattern
== NULL
)
8579 ret
->pattern
= new_name
;
8580 ret
->literal
= FALSE
;
8583 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
8584 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
8585 else if (strcasecmp (lang
, "C++") == 0)
8586 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
8587 else if (strcasecmp (lang
, "Java") == 0)
8588 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
8591 einfo (_("%X%P: unknown language `%s' in version information\n"),
8593 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
8596 return ldemul_new_vers_pattern (ret
);
8599 /* This is called for each set of variable names and match
8602 struct bfd_elf_version_tree
*
8603 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
8604 struct bfd_elf_version_expr
*locals
)
8606 struct bfd_elf_version_tree
*ret
;
8608 ret
= (struct bfd_elf_version_tree
*) xcalloc (1, sizeof *ret
);
8609 ret
->globals
.list
= globals
;
8610 ret
->locals
.list
= locals
;
8611 ret
->match
= lang_vers_match
;
8612 ret
->name_indx
= (unsigned int) -1;
8616 /* This static variable keeps track of version indices. */
8618 static int version_index
;
8621 version_expr_head_hash (const void *p
)
8623 const struct bfd_elf_version_expr
*e
=
8624 (const struct bfd_elf_version_expr
*) p
;
8626 return htab_hash_string (e
->pattern
);
8630 version_expr_head_eq (const void *p1
, const void *p2
)
8632 const struct bfd_elf_version_expr
*e1
=
8633 (const struct bfd_elf_version_expr
*) p1
;
8634 const struct bfd_elf_version_expr
*e2
=
8635 (const struct bfd_elf_version_expr
*) p2
;
8637 return strcmp (e1
->pattern
, e2
->pattern
) == 0;
8641 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
8644 struct bfd_elf_version_expr
*e
, *next
;
8645 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
8647 for (e
= head
->list
; e
; e
= e
->next
)
8651 head
->mask
|= e
->mask
;
8656 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
8657 version_expr_head_eq
, NULL
);
8658 list_loc
= &head
->list
;
8659 remaining_loc
= &head
->remaining
;
8660 for (e
= head
->list
; e
; e
= next
)
8666 remaining_loc
= &e
->next
;
8670 void **loc
= htab_find_slot ((htab_t
) head
->htab
, e
, INSERT
);
8674 struct bfd_elf_version_expr
*e1
, *last
;
8676 e1
= (struct bfd_elf_version_expr
*) *loc
;
8680 if (e1
->mask
== e
->mask
)
8688 while (e1
&& strcmp (e1
->pattern
, e
->pattern
) == 0);
8692 /* This is a duplicate. */
8693 /* FIXME: Memory leak. Sometimes pattern is not
8694 xmalloced alone, but in larger chunk of memory. */
8695 /* free (e->pattern); */
8700 e
->next
= last
->next
;
8708 list_loc
= &e
->next
;
8712 *remaining_loc
= NULL
;
8713 *list_loc
= head
->remaining
;
8716 head
->remaining
= head
->list
;
8719 /* This is called when we know the name and dependencies of the
8723 lang_register_vers_node (const char *name
,
8724 struct bfd_elf_version_tree
*version
,
8725 struct bfd_elf_version_deps
*deps
)
8727 struct bfd_elf_version_tree
*t
, **pp
;
8728 struct bfd_elf_version_expr
*e1
;
8733 if (link_info
.version_info
!= NULL
8734 && (name
[0] == '\0' || link_info
.version_info
->name
[0] == '\0'))
8736 einfo (_("%X%P: anonymous version tag cannot be combined"
8737 " with other version tags\n"));
8742 /* Make sure this node has a unique name. */
8743 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8744 if (strcmp (t
->name
, name
) == 0)
8745 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
8747 lang_finalize_version_expr_head (&version
->globals
);
8748 lang_finalize_version_expr_head (&version
->locals
);
8750 /* Check the global and local match names, and make sure there
8751 aren't any duplicates. */
8753 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
8755 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8757 struct bfd_elf_version_expr
*e2
;
8759 if (t
->locals
.htab
&& e1
->literal
)
8761 e2
= (struct bfd_elf_version_expr
*)
8762 htab_find ((htab_t
) t
->locals
.htab
, e1
);
8763 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
8765 if (e1
->mask
== e2
->mask
)
8766 einfo (_("%X%P: duplicate expression `%s'"
8767 " in version information\n"), e1
->pattern
);
8771 else if (!e1
->literal
)
8772 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
8773 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
8774 && e1
->mask
== e2
->mask
)
8775 einfo (_("%X%P: duplicate expression `%s'"
8776 " in version information\n"), e1
->pattern
);
8780 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
8782 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8784 struct bfd_elf_version_expr
*e2
;
8786 if (t
->globals
.htab
&& e1
->literal
)
8788 e2
= (struct bfd_elf_version_expr
*)
8789 htab_find ((htab_t
) t
->globals
.htab
, e1
);
8790 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
8792 if (e1
->mask
== e2
->mask
)
8793 einfo (_("%X%P: duplicate expression `%s'"
8794 " in version information\n"),
8799 else if (!e1
->literal
)
8800 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
8801 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
8802 && e1
->mask
== e2
->mask
)
8803 einfo (_("%X%P: duplicate expression `%s'"
8804 " in version information\n"), e1
->pattern
);
8808 version
->deps
= deps
;
8809 version
->name
= name
;
8810 if (name
[0] != '\0')
8813 version
->vernum
= version_index
;
8816 version
->vernum
= 0;
8818 for (pp
= &link_info
.version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
8823 /* This is called when we see a version dependency. */
8825 struct bfd_elf_version_deps
*
8826 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
8828 struct bfd_elf_version_deps
*ret
;
8829 struct bfd_elf_version_tree
*t
;
8831 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
8834 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8836 if (strcmp (t
->name
, name
) == 0)
8838 ret
->version_needed
= t
;
8843 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
8845 ret
->version_needed
= NULL
;
8850 lang_do_version_exports_section (void)
8852 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
8854 LANG_FOR_EACH_INPUT_STATEMENT (is
)
8856 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
8864 contents
= (char *) xmalloc (len
);
8865 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
8866 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
8869 while (p
< contents
+ len
)
8871 greg
= lang_new_vers_pattern (greg
, p
, NULL
, FALSE
);
8872 p
= strchr (p
, '\0') + 1;
8875 /* Do not free the contents, as we used them creating the regex. */
8877 /* Do not include this section in the link. */
8878 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
8881 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, FALSE
);
8882 lang_register_vers_node (command_line
.version_exports_section
,
8883 lang_new_vers_node (greg
, lreg
), NULL
);
8886 /* Evaluate LENGTH and ORIGIN parts of MEMORY spec */
8889 lang_do_memory_regions (void)
8891 lang_memory_region_type
*r
= lang_memory_region_list
;
8893 for (; r
!= NULL
; r
= r
->next
)
8897 exp_fold_tree_no_dot (r
->origin_exp
);
8898 if (expld
.result
.valid_p
)
8900 r
->origin
= expld
.result
.value
;
8901 r
->current
= r
->origin
;
8904 einfo (_("%F%P: invalid origin for memory region %s\n"),
8909 exp_fold_tree_no_dot (r
->length_exp
);
8910 if (expld
.result
.valid_p
)
8911 r
->length
= expld
.result
.value
;
8913 einfo (_("%F%P: invalid length for memory region %s\n"),
8920 lang_add_unique (const char *name
)
8922 struct unique_sections
*ent
;
8924 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
8925 if (strcmp (ent
->name
, name
) == 0)
8928 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
8929 ent
->name
= xstrdup (name
);
8930 ent
->next
= unique_section_list
;
8931 unique_section_list
= ent
;
8934 /* Append the list of dynamic symbols to the existing one. */
8937 lang_append_dynamic_list (struct bfd_elf_version_expr
*dynamic
)
8939 if (link_info
.dynamic_list
)
8941 struct bfd_elf_version_expr
*tail
;
8942 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
8944 tail
->next
= link_info
.dynamic_list
->head
.list
;
8945 link_info
.dynamic_list
->head
.list
= dynamic
;
8949 struct bfd_elf_dynamic_list
*d
;
8951 d
= (struct bfd_elf_dynamic_list
*) xcalloc (1, sizeof *d
);
8952 d
->head
.list
= dynamic
;
8953 d
->match
= lang_vers_match
;
8954 link_info
.dynamic_list
= d
;
8958 /* Append the list of C++ typeinfo dynamic symbols to the existing
8962 lang_append_dynamic_list_cpp_typeinfo (void)
8964 const char *symbols
[] =
8966 "typeinfo name for*",
8969 struct bfd_elf_version_expr
*dynamic
= NULL
;
8972 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
8973 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
8976 lang_append_dynamic_list (dynamic
);
8979 /* Append the list of C++ operator new and delete dynamic symbols to the
8983 lang_append_dynamic_list_cpp_new (void)
8985 const char *symbols
[] =
8990 struct bfd_elf_version_expr
*dynamic
= NULL
;
8993 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
8994 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
8997 lang_append_dynamic_list (dynamic
);
9000 /* Scan a space and/or comma separated string of features. */
9003 lang_ld_feature (char *str
)
9011 while (*p
== ',' || ISSPACE (*p
))
9016 while (*q
&& *q
!= ',' && !ISSPACE (*q
))
9020 if (strcasecmp (p
, "SANE_EXPR") == 0)
9021 config
.sane_expr
= TRUE
;
9023 einfo (_("%X%P: unknown feature `%s'\n"), p
);
9029 /* Pretty print memory amount. */
9032 lang_print_memory_size (bfd_vma sz
)
9034 if ((sz
& 0x3fffffff) == 0)
9035 printf ("%10" BFD_VMA_FMT
"u GB", sz
>> 30);
9036 else if ((sz
& 0xfffff) == 0)
9037 printf ("%10" BFD_VMA_FMT
"u MB", sz
>> 20);
9038 else if ((sz
& 0x3ff) == 0)
9039 printf ("%10" BFD_VMA_FMT
"u KB", sz
>> 10);
9041 printf (" %10" BFD_VMA_FMT
"u B", sz
);
9044 /* Implement --print-memory-usage: disply per region memory usage. */
9047 lang_print_memory_usage (void)
9049 lang_memory_region_type
*r
;
9051 printf ("Memory region Used Size Region Size %%age Used\n");
9052 for (r
= lang_memory_region_list
; r
->next
!= NULL
; r
= r
->next
)
9054 bfd_vma used_length
= r
->current
- r
->origin
;
9057 printf ("%16s: ",r
->name_list
.name
);
9058 lang_print_memory_size (used_length
);
9059 lang_print_memory_size ((bfd_vma
) r
->length
);
9061 percent
= used_length
* 100.0 / r
->length
;
9063 printf (" %6.2f%%\n", percent
);