1 /* Linker command language support.
2 Copyright (C) 1991-2022 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. */
24 #include "libiberty.h"
25 #include "filenames.h"
26 #include "safe-ctype.h"
45 #if BFD_SUPPORTS_PLUGINS
47 #endif /* BFD_SUPPORTS_PLUGINS */
50 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
53 /* Convert between addresses in bytes and sizes in octets.
54 For currently supported targets, octets_per_byte is always a power
55 of two, so we can use shifts. */
56 #define TO_ADDR(X) ((X) >> opb_shift)
57 #define TO_SIZE(X) ((X) << opb_shift)
59 /* Local variables. */
60 static struct obstack stat_obstack
;
61 static struct obstack map_obstack
;
63 #define obstack_chunk_alloc xmalloc
64 #define obstack_chunk_free free
65 static const char *entry_symbol_default
= "start";
66 static bool map_head_is_link_order
= false;
67 static lang_output_section_statement_type
*default_common_section
;
68 static bool map_option_f
;
69 static bfd_vma print_dot
;
70 static lang_input_statement_type
*first_file
;
71 static const char *current_target
;
72 static lang_statement_list_type
*stat_save
[10];
73 static lang_statement_list_type
**stat_save_ptr
= &stat_save
[0];
74 static struct unique_sections
*unique_section_list
;
75 static struct asneeded_minfo
*asneeded_list_head
;
76 static unsigned int opb_shift
= 0;
78 /* Forward declarations. */
79 static void exp_init_os (etree_type
*);
80 static lang_input_statement_type
*lookup_name (const char *);
81 static void insert_undefined (const char *);
82 static bool sort_def_symbol (struct bfd_link_hash_entry
*, void *);
83 static void print_statement (lang_statement_union_type
*,
84 lang_output_section_statement_type
*);
85 static void print_statement_list (lang_statement_union_type
*,
86 lang_output_section_statement_type
*);
87 static void print_statements (void);
88 static void print_input_section (asection
*, bool);
89 static bool lang_one_common (struct bfd_link_hash_entry
*, void *);
90 static void lang_record_phdrs (void);
91 static void lang_do_version_exports_section (void);
92 static void lang_finalize_version_expr_head
93 (struct bfd_elf_version_expr_head
*);
94 static void lang_do_memory_regions (bool);
96 /* Exported variables. */
97 const char *output_target
;
98 lang_output_section_statement_type
*abs_output_section
;
99 /* Header for list of statements corresponding to any files involved in the
100 link, either specified from the command-line or added implicitely (eg.
101 archive member used to resolved undefined symbol, wildcard statement from
102 linker script, etc.). Next pointer is in next field of a
103 lang_statement_header_type (reached via header field in a
104 lang_statement_union). */
105 lang_statement_list_type statement_list
;
106 lang_statement_list_type lang_os_list
;
107 lang_statement_list_type
*stat_ptr
= &statement_list
;
108 /* Header for list of statements corresponding to files used in the final
109 executable. This can be either object file specified on the command-line
110 or library member resolving an undefined reference. Next pointer is in next
111 field of a lang_input_statement_type (reached via input_statement field in a
112 lang_statement_union). */
113 lang_statement_list_type file_chain
= { NULL
, NULL
};
114 /* Header for list of statements corresponding to files specified on the
115 command-line for linking. It thus contains real object files and archive
116 but not archive members. Next pointer is in next_real_file field of a
117 lang_input_statement_type statement (reached via input_statement field in a
118 lang_statement_union). */
119 lang_statement_list_type input_file_chain
;
120 static const char *current_input_file
;
121 struct bfd_elf_dynamic_list
**current_dynamic_list_p
;
122 struct bfd_sym_chain entry_symbol
= { NULL
, NULL
};
123 const char *entry_section
= ".text";
124 struct lang_input_statement_flags input_flags
;
125 bool entry_from_cmdline
;
126 bool lang_has_input_file
= false;
127 bool had_output_filename
= false;
128 bool lang_float_flag
= false;
129 bool delete_output_file_on_failure
= false;
130 struct lang_phdr
*lang_phdr_list
;
131 struct lang_nocrossrefs
*nocrossref_list
;
132 struct asneeded_minfo
**asneeded_list_tail
;
134 static ctf_dict_t
*ctf_output
;
137 /* Functions that traverse the linker script and might evaluate
138 DEFINED() need to increment this at the start of the traversal. */
139 int lang_statement_iteration
= 0;
141 /* Count times through one_lang_size_sections_pass after mark phase. */
142 static int lang_sizing_iteration
= 0;
144 /* Return TRUE if the PATTERN argument is a wildcard pattern.
145 Although backslashes are treated specially if a pattern contains
146 wildcards, we do not consider the mere presence of a backslash to
147 be enough to cause the pattern to be treated as a wildcard.
148 That lets us handle DOS filenames more naturally. */
149 #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
151 #define new_stat(x, y) \
152 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
154 #define outside_section_address(q) \
155 ((q)->output_offset + (q)->output_section->vma)
157 #define outside_symbol_address(q) \
158 ((q)->value + outside_section_address (q->section))
160 /* CTF sections smaller than this are not compressed: compression of
161 dictionaries this small doesn't gain much, and this lets consumers mmap the
162 sections directly out of the ELF file and use them with no decompression
163 overhead if they want to. */
164 #define CTF_COMPRESSION_THRESHOLD 4096
167 stat_alloc (size_t size
)
169 return obstack_alloc (&stat_obstack
, size
);
173 name_match (const char *pattern
, const char *name
)
175 if (wildcardp (pattern
))
176 return fnmatch (pattern
, name
, 0);
177 return strcmp (pattern
, name
);
181 ldirname (const char *name
)
183 const char *base
= lbasename (name
);
186 while (base
> name
&& IS_DIR_SEPARATOR (base
[-1]))
190 dirname
= strdup (name
);
191 dirname
[base
- name
] = '\0';
195 /* If PATTERN is of the form archive:file, return a pointer to the
196 separator. If not, return NULL. */
199 archive_path (const char *pattern
)
203 if (link_info
.path_separator
== 0)
206 p
= strchr (pattern
, link_info
.path_separator
);
207 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
208 if (p
== NULL
|| link_info
.path_separator
!= ':')
211 /* Assume a match on the second char is part of drive specifier,
212 as in "c:\silly.dos". */
213 if (p
== pattern
+ 1 && ISALPHA (*pattern
))
214 p
= strchr (p
+ 1, link_info
.path_separator
);
219 /* Given that FILE_SPEC results in a non-NULL SEP result from archive_path,
220 return whether F matches FILE_SPEC. */
223 input_statement_is_archive_path (const char *file_spec
, char *sep
,
224 lang_input_statement_type
*f
)
229 || name_match (sep
+ 1, f
->filename
) == 0)
230 && ((sep
!= file_spec
)
231 == (f
->the_bfd
!= NULL
&& f
->the_bfd
->my_archive
!= NULL
)))
235 if (sep
!= file_spec
)
237 const char *aname
= bfd_get_filename (f
->the_bfd
->my_archive
);
239 match
= name_match (file_spec
, aname
) == 0;
240 *sep
= link_info
.path_separator
;
247 unique_section_p (const asection
*sec
,
248 const lang_output_section_statement_type
*os
)
250 struct unique_sections
*unam
;
253 if (!link_info
.resolve_section_groups
254 && sec
->owner
!= NULL
255 && bfd_is_group_section (sec
->owner
, sec
))
257 && strcmp (os
->name
, DISCARD_SECTION_NAME
) == 0);
260 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
261 if (name_match (unam
->name
, secnam
) == 0)
267 /* Generic traversal routines for finding matching sections. */
269 /* Return true if FILE matches a pattern in EXCLUDE_LIST, otherwise return
273 walk_wild_file_in_exclude_list (struct name_list
*exclude_list
,
274 lang_input_statement_type
*file
)
276 struct name_list
*list_tmp
;
278 for (list_tmp
= exclude_list
;
280 list_tmp
= list_tmp
->next
)
282 char *p
= archive_path (list_tmp
->name
);
286 if (input_statement_is_archive_path (list_tmp
->name
, p
, file
))
290 else if (name_match (list_tmp
->name
, file
->filename
) == 0)
293 /* FIXME: Perhaps remove the following at some stage? Matching
294 unadorned archives like this was never documented and has
295 been superceded by the archive:path syntax. */
296 else if (file
->the_bfd
!= NULL
297 && file
->the_bfd
->my_archive
!= NULL
298 && name_match (list_tmp
->name
,
299 bfd_get_filename (file
->the_bfd
->my_archive
)) == 0)
306 /* Try processing a section against a wildcard. This just calls
307 the callback unless the filename exclusion list is present
308 and excludes the file. It's hardly ever present so this
309 function is very fast. */
312 walk_wild_consider_section (lang_wild_statement_type
*ptr
,
313 lang_input_statement_type
*file
,
315 struct wildcard_list
*sec
,
319 /* Don't process sections from files which were excluded. */
320 if (walk_wild_file_in_exclude_list (sec
->spec
.exclude_name_list
, file
))
323 (*callback
) (ptr
, sec
, s
, file
, data
);
326 /* Lowest common denominator routine that can handle everything correctly,
330 walk_wild_section_general (lang_wild_statement_type
*ptr
,
331 lang_input_statement_type
*file
,
336 struct wildcard_list
*sec
;
338 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
340 sec
= ptr
->section_list
;
342 (*callback
) (ptr
, sec
, s
, file
, data
);
348 if (sec
->spec
.name
!= NULL
)
350 const char *sname
= bfd_section_name (s
);
352 skip
= name_match (sec
->spec
.name
, sname
) != 0;
356 walk_wild_consider_section (ptr
, file
, s
, sec
, callback
, data
);
363 /* Routines to find a single section given its name. If there's more
364 than one section with that name, we report that. */
368 asection
*found_section
;
369 bool multiple_sections_found
;
370 } section_iterator_callback_data
;
373 section_iterator_callback (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*s
, void *data
)
375 section_iterator_callback_data
*d
= (section_iterator_callback_data
*) data
;
377 if (d
->found_section
!= NULL
)
379 d
->multiple_sections_found
= true;
383 d
->found_section
= s
;
388 find_section (lang_input_statement_type
*file
,
389 struct wildcard_list
*sec
,
390 bool *multiple_sections_found
)
392 section_iterator_callback_data cb_data
= { NULL
, false };
394 bfd_get_section_by_name_if (file
->the_bfd
, sec
->spec
.name
,
395 section_iterator_callback
, &cb_data
);
396 *multiple_sections_found
= cb_data
.multiple_sections_found
;
397 return cb_data
.found_section
;
400 /* Code for handling simple wildcards without going through fnmatch,
401 which can be expensive because of charset translations etc. */
403 /* A simple wild is a literal string followed by a single '*',
404 where the literal part is at least 4 characters long. */
407 is_simple_wild (const char *name
)
409 size_t len
= strcspn (name
, "*?[");
410 return len
>= 4 && name
[len
] == '*' && name
[len
+ 1] == '\0';
414 match_simple_wild (const char *pattern
, const char *name
)
416 /* The first four characters of the pattern are guaranteed valid
417 non-wildcard characters. So we can go faster. */
418 if (pattern
[0] != name
[0] || pattern
[1] != name
[1]
419 || pattern
[2] != name
[2] || pattern
[3] != name
[3])
424 while (*pattern
!= '*')
425 if (*name
++ != *pattern
++)
431 /* Return the numerical value of the init_priority attribute from
432 section name NAME. */
435 get_init_priority (const asection
*sec
)
437 const char *name
= bfd_section_name (sec
);
440 /* GCC uses the following section names for the init_priority
441 attribute with numerical values 101 to 65535 inclusive. A
442 lower value means a higher priority.
444 1: .init_array.NNNNN/.fini_array.NNNNN: Where NNNNN is the
445 decimal numerical value of the init_priority attribute.
446 The order of execution in .init_array is forward and
447 .fini_array is backward.
448 2: .ctors.NNNNN/.dtors.NNNNN: Where NNNNN is 65535 minus the
449 decimal numerical value of the init_priority attribute.
450 The order of execution in .ctors is backward and .dtors
453 .init_array.NNNNN sections would normally be placed in an output
454 .init_array section, .fini_array.NNNNN in .fini_array,
455 .ctors.NNNNN in .ctors, and .dtors.NNNNN in .dtors. This means
456 we should sort by increasing number (and could just use
457 SORT_BY_NAME in scripts). However if .ctors.NNNNN sections are
458 being placed in .init_array (which may also contain
459 .init_array.NNNNN sections) or .dtors.NNNNN sections are being
460 placed in .fini_array then we need to extract the init_priority
461 attribute and sort on that. */
462 dot
= strrchr (name
, '.');
463 if (dot
!= NULL
&& ISDIGIT (dot
[1]))
466 unsigned long init_priority
= strtoul (dot
+ 1, &end
, 10);
470 && (strncmp (name
, ".ctors", 6) == 0
471 || strncmp (name
, ".dtors", 6) == 0))
472 init_priority
= 65535 - init_priority
;
473 if (init_priority
<= INT_MAX
)
474 return init_priority
;
480 /* Compare sections ASEC and BSEC according to SORT. */
483 compare_section (sort_type sort
, asection
*asec
, asection
*bsec
)
486 int a_priority
, b_priority
;
493 case by_init_priority
:
494 a_priority
= get_init_priority (asec
);
495 b_priority
= get_init_priority (bsec
);
496 if (a_priority
< 0 || b_priority
< 0)
498 ret
= a_priority
- b_priority
;
504 case by_alignment_name
:
505 ret
= bfd_section_alignment (bsec
) - bfd_section_alignment (asec
);
512 ret
= strcmp (bfd_section_name (asec
), bfd_section_name (bsec
));
515 case by_name_alignment
:
516 ret
= strcmp (bfd_section_name (asec
), bfd_section_name (bsec
));
522 ret
= bfd_section_alignment (bsec
) - bfd_section_alignment (asec
);
529 /* Build a Binary Search Tree to sort sections, unlike insertion sort
530 used in wild_sort(). BST is considerably faster if the number of
531 of sections are large. */
533 static lang_section_bst_type
**
534 wild_sort_fast (lang_wild_statement_type
*wild
,
535 struct wildcard_list
*sec
,
536 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
539 lang_section_bst_type
**tree
;
542 if (!wild
->filenames_sorted
543 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
545 /* Append at the right end of tree. */
547 tree
= &((*tree
)->right
);
553 /* Find the correct node to append this section. */
554 if (compare_section (sec
->spec
.sorted
, section
, (*tree
)->section
) < 0)
555 tree
= &((*tree
)->left
);
557 tree
= &((*tree
)->right
);
563 /* Use wild_sort_fast to build a BST to sort sections. */
566 output_section_callback_fast (lang_wild_statement_type
*ptr
,
567 struct wildcard_list
*sec
,
569 lang_input_statement_type
*file
,
572 lang_section_bst_type
*node
;
573 lang_section_bst_type
**tree
;
574 lang_output_section_statement_type
*os
;
576 os
= (lang_output_section_statement_type
*) output
;
578 if (unique_section_p (section
, os
))
581 node
= (lang_section_bst_type
*) xmalloc (sizeof (lang_section_bst_type
));
584 node
->section
= section
;
585 node
->pattern
= ptr
->section_list
;
587 tree
= wild_sort_fast (ptr
, sec
, file
, section
);
592 /* Convert a sorted sections' BST back to list form. */
595 output_section_callback_tree_to_list (lang_wild_statement_type
*ptr
,
596 lang_section_bst_type
*tree
,
600 output_section_callback_tree_to_list (ptr
, tree
->left
, output
);
602 lang_add_section (&ptr
->children
, tree
->section
, tree
->pattern
, NULL
,
603 (lang_output_section_statement_type
*) output
);
606 output_section_callback_tree_to_list (ptr
, tree
->right
, output
);
611 /* Specialized, optimized routines for handling different kinds of
615 walk_wild_section_specs1_wild0 (lang_wild_statement_type
*ptr
,
616 lang_input_statement_type
*file
,
620 /* We can just do a hash lookup for the section with the right name.
621 But if that lookup discovers more than one section with the name
622 (should be rare), we fall back to the general algorithm because
623 we would otherwise have to sort the sections to make sure they
624 get processed in the bfd's order. */
625 bool multiple_sections_found
;
626 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
627 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
629 if (multiple_sections_found
)
630 walk_wild_section_general (ptr
, file
, callback
, data
);
632 walk_wild_consider_section (ptr
, file
, s0
, sec0
, callback
, data
);
636 walk_wild_section_specs1_wild1 (lang_wild_statement_type
*ptr
,
637 lang_input_statement_type
*file
,
642 struct wildcard_list
*wildsec0
= ptr
->handler_data
[0];
644 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
646 const char *sname
= bfd_section_name (s
);
647 bool skip
= !match_simple_wild (wildsec0
->spec
.name
, sname
);
650 walk_wild_consider_section (ptr
, file
, s
, wildsec0
, callback
, data
);
655 walk_wild_section_specs2_wild1 (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 bool multiple_sections_found
;
664 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
666 if (multiple_sections_found
)
668 walk_wild_section_general (ptr
, file
, callback
, data
);
672 /* Note that if the section was not found, s0 is NULL and
673 we'll simply never succeed the s == s0 test below. */
674 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
676 /* Recall that in this code path, a section cannot satisfy more
677 than one spec, so if s == s0 then it cannot match
680 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
683 const char *sname
= bfd_section_name (s
);
684 bool skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
687 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
,
694 walk_wild_section_specs3_wild2 (lang_wild_statement_type
*ptr
,
695 lang_input_statement_type
*file
,
700 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
701 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
702 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
703 bool multiple_sections_found
;
704 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
706 if (multiple_sections_found
)
708 walk_wild_section_general (ptr
, file
, callback
, data
);
712 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
715 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
718 const char *sname
= bfd_section_name (s
);
719 bool skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
722 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
, data
);
725 skip
= !match_simple_wild (wildsec2
->spec
.name
, sname
);
727 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
735 walk_wild_section_specs4_wild2 (lang_wild_statement_type
*ptr
,
736 lang_input_statement_type
*file
,
741 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
742 struct wildcard_list
*sec1
= ptr
->handler_data
[1];
743 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
744 struct wildcard_list
*wildsec3
= ptr
->handler_data
[3];
745 bool multiple_sections_found
;
746 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
), *s1
;
748 if (multiple_sections_found
)
750 walk_wild_section_general (ptr
, file
, callback
, data
);
754 s1
= find_section (file
, sec1
, &multiple_sections_found
);
755 if (multiple_sections_found
)
757 walk_wild_section_general (ptr
, file
, callback
, data
);
761 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
764 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
767 walk_wild_consider_section (ptr
, file
, s
, sec1
, callback
, data
);
770 const char *sname
= bfd_section_name (s
);
771 bool skip
= !match_simple_wild (wildsec2
->spec
.name
, sname
);
774 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
778 skip
= !match_simple_wild (wildsec3
->spec
.name
, sname
);
780 walk_wild_consider_section (ptr
, file
, s
, wildsec3
,
788 walk_wild_section (lang_wild_statement_type
*ptr
,
789 lang_input_statement_type
*file
,
793 if (file
->flags
.just_syms
)
796 (*ptr
->walk_wild_section_handler
) (ptr
, file
, callback
, data
);
799 /* Returns TRUE when name1 is a wildcard spec that might match
800 something name2 can match. We're conservative: we return FALSE
801 only if the prefixes of name1 and name2 are different up to the
802 first wildcard character. */
805 wild_spec_can_overlap (const char *name1
, const char *name2
)
807 size_t prefix1_len
= strcspn (name1
, "?*[");
808 size_t prefix2_len
= strcspn (name2
, "?*[");
809 size_t min_prefix_len
;
811 /* Note that if there is no wildcard character, then we treat the
812 terminating 0 as part of the prefix. Thus ".text" won't match
813 ".text." or ".text.*", for example. */
814 if (name1
[prefix1_len
] == '\0')
816 if (name2
[prefix2_len
] == '\0')
819 min_prefix_len
= prefix1_len
< prefix2_len
? prefix1_len
: prefix2_len
;
821 return memcmp (name1
, name2
, min_prefix_len
) == 0;
824 /* Select specialized code to handle various kinds of wildcard
828 analyze_walk_wild_section_handler (lang_wild_statement_type
*ptr
)
831 int wild_name_count
= 0;
832 struct wildcard_list
*sec
;
836 ptr
->walk_wild_section_handler
= walk_wild_section_general
;
837 ptr
->handler_data
[0] = NULL
;
838 ptr
->handler_data
[1] = NULL
;
839 ptr
->handler_data
[2] = NULL
;
840 ptr
->handler_data
[3] = NULL
;
843 /* Count how many wildcard_specs there are, and how many of those
844 actually use wildcards in the name. Also, bail out if any of the
845 wildcard names are NULL. (Can this actually happen?
846 walk_wild_section used to test for it.) And bail out if any
847 of the wildcards are more complex than a simple string
848 ending in a single '*'. */
849 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
852 if (sec
->spec
.name
== NULL
)
854 if (wildcardp (sec
->spec
.name
))
857 if (!is_simple_wild (sec
->spec
.name
))
862 /* The zero-spec case would be easy to optimize but it doesn't
863 happen in practice. Likewise, more than 4 specs doesn't
864 happen in practice. */
865 if (sec_count
== 0 || sec_count
> 4)
868 /* Check that no two specs can match the same section. */
869 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
871 struct wildcard_list
*sec2
;
872 for (sec2
= sec
->next
; sec2
!= NULL
; sec2
= sec2
->next
)
874 if (wild_spec_can_overlap (sec
->spec
.name
, sec2
->spec
.name
))
879 signature
= (sec_count
<< 8) + wild_name_count
;
883 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild0
;
886 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild1
;
889 ptr
->walk_wild_section_handler
= walk_wild_section_specs2_wild1
;
892 ptr
->walk_wild_section_handler
= walk_wild_section_specs3_wild2
;
895 ptr
->walk_wild_section_handler
= walk_wild_section_specs4_wild2
;
901 /* Now fill the data array with pointers to the specs, first the
902 specs with non-wildcard names, then the specs with wildcard
903 names. It's OK to process the specs in different order from the
904 given order, because we've already determined that no section
905 will match more than one spec. */
907 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
908 if (!wildcardp (sec
->spec
.name
))
909 ptr
->handler_data
[data_counter
++] = sec
;
910 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
911 if (wildcardp (sec
->spec
.name
))
912 ptr
->handler_data
[data_counter
++] = sec
;
915 /* Handle a wild statement for a single file F. */
918 walk_wild_file (lang_wild_statement_type
*s
,
919 lang_input_statement_type
*f
,
923 if (walk_wild_file_in_exclude_list (s
->exclude_name_list
, f
))
926 if (f
->the_bfd
== NULL
927 || !bfd_check_format (f
->the_bfd
, bfd_archive
))
928 walk_wild_section (s
, f
, callback
, data
);
933 /* This is an archive file. We must map each member of the
934 archive separately. */
935 member
= bfd_openr_next_archived_file (f
->the_bfd
, NULL
);
936 while (member
!= NULL
)
938 /* When lookup_name is called, it will call the add_symbols
939 entry point for the archive. For each element of the
940 archive which is included, BFD will call ldlang_add_file,
941 which will set the usrdata field of the member to the
942 lang_input_statement. */
943 if (bfd_usrdata (member
) != NULL
)
944 walk_wild_section (s
, bfd_usrdata (member
), callback
, data
);
946 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
952 walk_wild (lang_wild_statement_type
*s
, callback_t callback
, void *data
)
954 const char *file_spec
= s
->filename
;
957 if (file_spec
== NULL
)
959 /* Perform the iteration over all files in the list. */
960 LANG_FOR_EACH_INPUT_STATEMENT (f
)
962 walk_wild_file (s
, f
, callback
, data
);
965 else if ((p
= archive_path (file_spec
)) != NULL
)
967 LANG_FOR_EACH_INPUT_STATEMENT (f
)
969 if (input_statement_is_archive_path (file_spec
, p
, f
))
970 walk_wild_file (s
, f
, callback
, data
);
973 else if (wildcardp (file_spec
))
975 LANG_FOR_EACH_INPUT_STATEMENT (f
)
977 if (fnmatch (file_spec
, f
->filename
, 0) == 0)
978 walk_wild_file (s
, f
, callback
, data
);
983 lang_input_statement_type
*f
;
985 /* Perform the iteration over a single file. */
986 f
= lookup_name (file_spec
);
988 walk_wild_file (s
, f
, callback
, data
);
992 /* lang_for_each_statement walks the parse tree and calls the provided
993 function for each node, except those inside output section statements
994 with constraint set to -1. */
997 lang_for_each_statement_worker (void (*func
) (lang_statement_union_type
*),
998 lang_statement_union_type
*s
)
1000 for (; s
!= NULL
; s
= s
->header
.next
)
1004 switch (s
->header
.type
)
1006 case lang_constructors_statement_enum
:
1007 lang_for_each_statement_worker (func
, constructor_list
.head
);
1009 case lang_output_section_statement_enum
:
1010 if (s
->output_section_statement
.constraint
!= -1)
1011 lang_for_each_statement_worker
1012 (func
, s
->output_section_statement
.children
.head
);
1014 case lang_wild_statement_enum
:
1015 lang_for_each_statement_worker (func
,
1016 s
->wild_statement
.children
.head
);
1018 case lang_group_statement_enum
:
1019 lang_for_each_statement_worker (func
,
1020 s
->group_statement
.children
.head
);
1022 case lang_data_statement_enum
:
1023 case lang_reloc_statement_enum
:
1024 case lang_object_symbols_statement_enum
:
1025 case lang_output_statement_enum
:
1026 case lang_target_statement_enum
:
1027 case lang_input_section_enum
:
1028 case lang_input_statement_enum
:
1029 case lang_assignment_statement_enum
:
1030 case lang_padding_statement_enum
:
1031 case lang_address_statement_enum
:
1032 case lang_fill_statement_enum
:
1033 case lang_insert_statement_enum
:
1043 lang_for_each_statement (void (*func
) (lang_statement_union_type
*))
1045 lang_for_each_statement_worker (func
, statement_list
.head
);
1048 /*----------------------------------------------------------------------*/
1051 lang_list_init (lang_statement_list_type
*list
)
1054 list
->tail
= &list
->head
;
1058 lang_statement_append (lang_statement_list_type
*list
,
1062 *(list
->tail
) = element
;
1067 push_stat_ptr (lang_statement_list_type
*new_ptr
)
1069 if (stat_save_ptr
>= stat_save
+ sizeof (stat_save
) / sizeof (stat_save
[0]))
1071 *stat_save_ptr
++ = stat_ptr
;
1078 if (stat_save_ptr
<= stat_save
)
1080 stat_ptr
= *--stat_save_ptr
;
1083 /* Build a new statement node for the parse tree. */
1085 static lang_statement_union_type
*
1086 new_statement (enum statement_enum type
,
1088 lang_statement_list_type
*list
)
1090 lang_statement_union_type
*new_stmt
;
1092 new_stmt
= stat_alloc (size
);
1093 new_stmt
->header
.type
= type
;
1094 new_stmt
->header
.next
= NULL
;
1095 lang_statement_append (list
, new_stmt
, &new_stmt
->header
.next
);
1099 /* Build a new input file node for the language. There are several
1100 ways in which we treat an input file, eg, we only look at symbols,
1101 or prefix it with a -l etc.
1103 We can be supplied with requests for input files more than once;
1104 they may, for example be split over several lines like foo.o(.text)
1105 foo.o(.data) etc, so when asked for a file we check that we haven't
1106 got it already so we don't duplicate the bfd. */
1108 static lang_input_statement_type
*
1109 new_afile (const char *name
,
1110 lang_input_file_enum_type file_type
,
1112 const char *from_filename
)
1114 lang_input_statement_type
*p
;
1116 lang_has_input_file
= true;
1118 p
= new_stat (lang_input_statement
, stat_ptr
);
1119 memset (&p
->the_bfd
, 0,
1120 sizeof (*p
) - offsetof (lang_input_statement_type
, the_bfd
));
1121 p
->extra_search_path
= NULL
;
1123 p
->flags
.dynamic
= input_flags
.dynamic
;
1124 p
->flags
.add_DT_NEEDED_for_dynamic
= input_flags
.add_DT_NEEDED_for_dynamic
;
1125 p
->flags
.add_DT_NEEDED_for_regular
= input_flags
.add_DT_NEEDED_for_regular
;
1126 p
->flags
.whole_archive
= input_flags
.whole_archive
;
1127 p
->flags
.sysrooted
= input_flags
.sysrooted
;
1131 case lang_input_file_is_symbols_only_enum
:
1133 p
->local_sym_name
= name
;
1134 p
->flags
.real
= true;
1135 p
->flags
.just_syms
= true;
1137 case lang_input_file_is_fake_enum
:
1139 p
->local_sym_name
= name
;
1141 case lang_input_file_is_l_enum
:
1142 if (name
[0] == ':' && name
[1] != '\0')
1144 p
->filename
= name
+ 1;
1145 p
->flags
.full_name_provided
= true;
1149 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
1150 p
->flags
.maybe_archive
= true;
1151 p
->flags
.real
= true;
1152 p
->flags
.search_dirs
= true;
1154 case lang_input_file_is_marker_enum
:
1156 p
->local_sym_name
= name
;
1157 p
->flags
.search_dirs
= true;
1159 case lang_input_file_is_search_file_enum
:
1161 p
->local_sym_name
= name
;
1162 /* If name is a relative path, search the directory of the current linker
1164 if (from_filename
&& !IS_ABSOLUTE_PATH (name
))
1165 p
->extra_search_path
= ldirname (from_filename
);
1166 p
->flags
.real
= true;
1167 p
->flags
.search_dirs
= true;
1169 case lang_input_file_is_file_enum
:
1171 p
->local_sym_name
= name
;
1172 p
->flags
.real
= true;
1178 lang_statement_append (&input_file_chain
, p
, &p
->next_real_file
);
1182 lang_input_statement_type
*
1183 lang_add_input_file (const char *name
,
1184 lang_input_file_enum_type file_type
,
1188 && (*name
== '=' || startswith (name
, "$SYSROOT")))
1190 lang_input_statement_type
*ret
;
1191 char *sysrooted_name
1192 = concat (ld_sysroot
,
1193 name
+ (*name
== '=' ? 1 : strlen ("$SYSROOT")),
1194 (const char *) NULL
);
1196 /* We've now forcibly prepended the sysroot, making the input
1197 file independent of the context. Therefore, temporarily
1198 force a non-sysrooted context for this statement, so it won't
1199 get the sysroot prepended again when opened. (N.B. if it's a
1200 script, any child nodes with input files starting with "/"
1201 will be handled as "sysrooted" as they'll be found to be
1202 within the sysroot subdirectory.) */
1203 unsigned int outer_sysrooted
= input_flags
.sysrooted
;
1204 input_flags
.sysrooted
= 0;
1205 ret
= new_afile (sysrooted_name
, file_type
, target
, NULL
);
1206 input_flags
.sysrooted
= outer_sysrooted
;
1210 return new_afile (name
, file_type
, target
, current_input_file
);
1213 struct out_section_hash_entry
1215 struct bfd_hash_entry root
;
1216 lang_statement_union_type s
;
1219 /* The hash table. */
1221 static struct bfd_hash_table output_section_statement_table
;
1223 /* Support routines for the hash table used by lang_output_section_find,
1224 initialize the table, fill in an entry and remove the table. */
1226 static struct bfd_hash_entry
*
1227 output_section_statement_newfunc (struct bfd_hash_entry
*entry
,
1228 struct bfd_hash_table
*table
,
1231 lang_output_section_statement_type
**nextp
;
1232 struct out_section_hash_entry
*ret
;
1236 entry
= (struct bfd_hash_entry
*) bfd_hash_allocate (table
,
1242 entry
= bfd_hash_newfunc (entry
, table
, string
);
1246 ret
= (struct out_section_hash_entry
*) entry
;
1247 memset (&ret
->s
, 0, sizeof (ret
->s
));
1248 ret
->s
.header
.type
= lang_output_section_statement_enum
;
1249 ret
->s
.output_section_statement
.subsection_alignment
= NULL
;
1250 ret
->s
.output_section_statement
.section_alignment
= NULL
;
1251 ret
->s
.output_section_statement
.block_value
= 1;
1252 lang_list_init (&ret
->s
.output_section_statement
.children
);
1253 lang_statement_append (stat_ptr
, &ret
->s
, &ret
->s
.header
.next
);
1255 /* For every output section statement added to the list, except the
1256 first one, lang_os_list.tail points to the "next"
1257 field of the last element of the list. */
1258 if (lang_os_list
.head
!= NULL
)
1259 ret
->s
.output_section_statement
.prev
1260 = ((lang_output_section_statement_type
*)
1261 ((char *) lang_os_list
.tail
1262 - offsetof (lang_output_section_statement_type
, next
)));
1264 /* GCC's strict aliasing rules prevent us from just casting the
1265 address, so we store the pointer in a variable and cast that
1267 nextp
= &ret
->s
.output_section_statement
.next
;
1268 lang_statement_append (&lang_os_list
, &ret
->s
, nextp
);
1273 output_section_statement_table_init (void)
1275 if (!bfd_hash_table_init_n (&output_section_statement_table
,
1276 output_section_statement_newfunc
,
1277 sizeof (struct out_section_hash_entry
),
1279 einfo (_("%F%P: can not create hash table: %E\n"));
1283 output_section_statement_table_free (void)
1285 bfd_hash_table_free (&output_section_statement_table
);
1288 /* Build enough state so that the parser can build its tree. */
1293 obstack_begin (&stat_obstack
, 1000);
1295 stat_ptr
= &statement_list
;
1297 output_section_statement_table_init ();
1299 lang_list_init (stat_ptr
);
1301 lang_list_init (&input_file_chain
);
1302 lang_list_init (&lang_os_list
);
1303 lang_list_init (&file_chain
);
1304 first_file
= lang_add_input_file (NULL
, lang_input_file_is_marker_enum
,
1306 abs_output_section
=
1307 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
, 0, 1);
1309 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
1311 asneeded_list_head
= NULL
;
1312 asneeded_list_tail
= &asneeded_list_head
;
1318 output_section_statement_table_free ();
1321 /*----------------------------------------------------------------------
1322 A region is an area of memory declared with the
1323 MEMORY { name:org=exp, len=exp ... }
1326 We maintain a list of all the regions here.
1328 If no regions are specified in the script, then the default is used
1329 which is created when looked up to be the entire data space.
1331 If create is true we are creating a region inside a MEMORY block.
1332 In this case it is probably an error to create a region that has
1333 already been created. If we are not inside a MEMORY block it is
1334 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1335 and so we issue a warning.
1337 Each region has at least one name. The first name is either
1338 DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add
1339 alias names to an existing region within a script with
1340 REGION_ALIAS (alias, region_name). Each name corresponds to at most one
1343 static lang_memory_region_type
*lang_memory_region_list
;
1344 static lang_memory_region_type
**lang_memory_region_list_tail
1345 = &lang_memory_region_list
;
1347 lang_memory_region_type
*
1348 lang_memory_region_lookup (const char *const name
, bool create
)
1350 lang_memory_region_name
*n
;
1351 lang_memory_region_type
*r
;
1352 lang_memory_region_type
*new_region
;
1354 /* NAME is NULL for LMA memspecs if no region was specified. */
1358 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1359 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1360 if (strcmp (n
->name
, name
) == 0)
1363 einfo (_("%P:%pS: warning: redeclaration of memory region `%s'\n"),
1368 if (!create
&& strcmp (name
, DEFAULT_MEMORY_REGION
))
1369 einfo (_("%P:%pS: warning: memory region `%s' not declared\n"),
1372 new_region
= stat_alloc (sizeof (lang_memory_region_type
));
1374 new_region
->name_list
.name
= xstrdup (name
);
1375 new_region
->name_list
.next
= NULL
;
1376 new_region
->next
= NULL
;
1377 new_region
->origin_exp
= NULL
;
1378 new_region
->origin
= 0;
1379 new_region
->length_exp
= NULL
;
1380 new_region
->length
= ~(bfd_size_type
) 0;
1381 new_region
->current
= 0;
1382 new_region
->last_os
= NULL
;
1383 new_region
->flags
= 0;
1384 new_region
->not_flags
= 0;
1385 new_region
->had_full_message
= false;
1387 *lang_memory_region_list_tail
= new_region
;
1388 lang_memory_region_list_tail
= &new_region
->next
;
1394 lang_memory_region_alias (const char *alias
, const char *region_name
)
1396 lang_memory_region_name
*n
;
1397 lang_memory_region_type
*r
;
1398 lang_memory_region_type
*region
;
1400 /* The default region must be unique. This ensures that it is not necessary
1401 to iterate through the name list if someone wants the check if a region is
1402 the default memory region. */
1403 if (strcmp (region_name
, DEFAULT_MEMORY_REGION
) == 0
1404 || strcmp (alias
, DEFAULT_MEMORY_REGION
) == 0)
1405 einfo (_("%F%P:%pS: error: alias for default memory region\n"), NULL
);
1407 /* Look for the target region and check if the alias is not already
1410 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1411 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1413 if (region
== NULL
&& strcmp (n
->name
, region_name
) == 0)
1415 if (strcmp (n
->name
, alias
) == 0)
1416 einfo (_("%F%P:%pS: error: redefinition of memory region "
1421 /* Check if the target region exists. */
1423 einfo (_("%F%P:%pS: error: memory region `%s' "
1424 "for alias `%s' does not exist\n"),
1425 NULL
, region_name
, alias
);
1427 /* Add alias to region name list. */
1428 n
= stat_alloc (sizeof (lang_memory_region_name
));
1429 n
->name
= xstrdup (alias
);
1430 n
->next
= region
->name_list
.next
;
1431 region
->name_list
.next
= n
;
1434 static lang_memory_region_type
*
1435 lang_memory_default (asection
*section
)
1437 lang_memory_region_type
*p
;
1439 flagword sec_flags
= section
->flags
;
1441 /* Override SEC_DATA to mean a writable section. */
1442 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
1443 sec_flags
|= SEC_DATA
;
1445 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
1447 if ((p
->flags
& sec_flags
) != 0
1448 && (p
->not_flags
& sec_flags
) == 0)
1453 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, false);
1456 /* Get the output section statement directly from the userdata. */
1458 lang_output_section_statement_type
*
1459 lang_output_section_get (const asection
*output_section
)
1461 return bfd_section_userdata (output_section
);
1464 /* Find or create an output_section_statement with the given NAME.
1465 If CONSTRAINT is non-zero match one with that constraint, otherwise
1466 match any non-negative constraint. If CREATE is 0 return NULL when
1467 no match exists. If CREATE is 1, create an output_section_statement
1468 when no match exists or if CONSTRAINT is SPECIAL. If CREATE is 2,
1469 always make a new output_section_statement. */
1471 lang_output_section_statement_type
*
1472 lang_output_section_statement_lookup (const char *name
,
1476 struct out_section_hash_entry
*entry
;
1478 entry
= ((struct out_section_hash_entry
*)
1479 bfd_hash_lookup (&output_section_statement_table
, name
,
1480 create
!= 0, false));
1484 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1488 if (entry
->s
.output_section_statement
.name
!= NULL
)
1490 /* We have a section of this name, but it might not have the correct
1492 struct out_section_hash_entry
*last_ent
;
1494 name
= entry
->s
.output_section_statement
.name
;
1498 && !(create
&& constraint
== SPECIAL
)
1499 && (constraint
== entry
->s
.output_section_statement
.constraint
1501 && entry
->s
.output_section_statement
.constraint
>= 0)))
1502 return &entry
->s
.output_section_statement
;
1504 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1506 while (entry
!= NULL
1507 && name
== entry
->s
.output_section_statement
.name
);
1513 = ((struct out_section_hash_entry
*)
1514 output_section_statement_newfunc (NULL
,
1515 &output_section_statement_table
,
1519 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1522 entry
->root
= last_ent
->root
;
1523 last_ent
->root
.next
= &entry
->root
;
1526 entry
->s
.output_section_statement
.name
= name
;
1527 entry
->s
.output_section_statement
.constraint
= constraint
;
1528 entry
->s
.output_section_statement
.dup_output
= (create
== 2
1529 || constraint
== SPECIAL
);
1530 return &entry
->s
.output_section_statement
;
1533 /* Find the next output_section_statement with the same name as OS.
1534 If CONSTRAINT is non-zero, find one with that constraint otherwise
1535 match any non-negative constraint. */
1537 lang_output_section_statement_type
*
1538 next_matching_output_section_statement (lang_output_section_statement_type
*os
,
1541 /* All output_section_statements are actually part of a
1542 struct out_section_hash_entry. */
1543 struct out_section_hash_entry
*entry
= (struct out_section_hash_entry
*)
1545 - offsetof (struct out_section_hash_entry
, s
.output_section_statement
));
1546 const char *name
= os
->name
;
1548 ASSERT (name
== entry
->root
.string
);
1551 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1553 || name
!= entry
->s
.output_section_statement
.name
)
1556 while (constraint
!= entry
->s
.output_section_statement
.constraint
1558 || entry
->s
.output_section_statement
.constraint
< 0));
1560 return &entry
->s
.output_section_statement
;
1563 /* A variant of lang_output_section_find used by place_orphan.
1564 Returns the output statement that should precede a new output
1565 statement for SEC. If an exact match is found on certain flags,
1568 lang_output_section_statement_type
*
1569 lang_output_section_find_by_flags (const asection
*sec
,
1571 lang_output_section_statement_type
**exact
,
1572 lang_match_sec_type_func match_type
)
1574 lang_output_section_statement_type
*first
, *look
, *found
;
1575 flagword look_flags
, differ
;
1577 /* We know the first statement on this list is *ABS*. May as well
1579 first
= (void *) lang_os_list
.head
;
1580 first
= first
->next
;
1582 /* First try for an exact match. */
1584 for (look
= first
; look
; look
= look
->next
)
1586 look_flags
= look
->flags
;
1587 if (look
->bfd_section
!= NULL
)
1589 look_flags
= look
->bfd_section
->flags
;
1590 if (match_type
&& !match_type (link_info
.output_bfd
,
1595 differ
= look_flags
^ sec_flags
;
1596 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1597 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1607 if ((sec_flags
& SEC_CODE
) != 0
1608 && (sec_flags
& SEC_ALLOC
) != 0)
1610 /* Try for a rw code section. */
1611 for (look
= first
; look
; look
= look
->next
)
1613 look_flags
= look
->flags
;
1614 if (look
->bfd_section
!= NULL
)
1616 look_flags
= look
->bfd_section
->flags
;
1617 if (match_type
&& !match_type (link_info
.output_bfd
,
1622 differ
= look_flags
^ sec_flags
;
1623 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1624 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1628 else if ((sec_flags
& SEC_READONLY
) != 0
1629 && (sec_flags
& SEC_ALLOC
) != 0)
1631 /* .rodata can go after .text, .sdata2 after .rodata. */
1632 for (look
= first
; look
; look
= look
->next
)
1634 look_flags
= look
->flags
;
1635 if (look
->bfd_section
!= NULL
)
1637 look_flags
= look
->bfd_section
->flags
;
1638 if (match_type
&& !match_type (link_info
.output_bfd
,
1643 differ
= look_flags
^ sec_flags
;
1644 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1645 | SEC_READONLY
| SEC_SMALL_DATA
))
1646 || (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1648 && !(look_flags
& SEC_SMALL_DATA
)))
1652 else if ((sec_flags
& SEC_THREAD_LOCAL
) != 0
1653 && (sec_flags
& SEC_ALLOC
) != 0)
1655 /* .tdata can go after .data, .tbss after .tdata. Treat .tbss
1656 as if it were a loaded section, and don't use match_type. */
1657 bool seen_thread_local
= false;
1660 for (look
= first
; look
; look
= look
->next
)
1662 look_flags
= look
->flags
;
1663 if (look
->bfd_section
!= NULL
)
1664 look_flags
= look
->bfd_section
->flags
;
1666 differ
= look_flags
^ (sec_flags
| SEC_LOAD
| SEC_HAS_CONTENTS
);
1667 if (!(differ
& (SEC_THREAD_LOCAL
| SEC_ALLOC
)))
1669 /* .tdata and .tbss must be adjacent and in that order. */
1670 if (!(look_flags
& SEC_LOAD
)
1671 && (sec_flags
& SEC_LOAD
))
1672 /* ..so if we're at a .tbss section and we're placing
1673 a .tdata section stop looking and return the
1674 previous section. */
1677 seen_thread_local
= true;
1679 else if (seen_thread_local
)
1681 else if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
)))
1685 else if ((sec_flags
& SEC_SMALL_DATA
) != 0
1686 && (sec_flags
& SEC_ALLOC
) != 0)
1688 /* .sdata goes after .data, .sbss after .sdata. */
1689 for (look
= first
; look
; look
= look
->next
)
1691 look_flags
= look
->flags
;
1692 if (look
->bfd_section
!= NULL
)
1694 look_flags
= look
->bfd_section
->flags
;
1695 if (match_type
&& !match_type (link_info
.output_bfd
,
1700 differ
= look_flags
^ sec_flags
;
1701 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1702 | SEC_THREAD_LOCAL
))
1703 || ((look_flags
& SEC_SMALL_DATA
)
1704 && !(sec_flags
& SEC_HAS_CONTENTS
)))
1708 else if ((sec_flags
& SEC_HAS_CONTENTS
) != 0
1709 && (sec_flags
& SEC_ALLOC
) != 0)
1711 /* .data goes after .rodata. */
1712 for (look
= first
; look
; look
= look
->next
)
1714 look_flags
= look
->flags
;
1715 if (look
->bfd_section
!= NULL
)
1717 look_flags
= look
->bfd_section
->flags
;
1718 if (match_type
&& !match_type (link_info
.output_bfd
,
1723 differ
= look_flags
^ sec_flags
;
1724 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1725 | SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1729 else if ((sec_flags
& SEC_ALLOC
) != 0)
1731 /* .bss goes after any other alloc section. */
1732 for (look
= first
; look
; look
= look
->next
)
1734 look_flags
= look
->flags
;
1735 if (look
->bfd_section
!= NULL
)
1737 look_flags
= look
->bfd_section
->flags
;
1738 if (match_type
&& !match_type (link_info
.output_bfd
,
1743 differ
= look_flags
^ sec_flags
;
1744 if (!(differ
& SEC_ALLOC
))
1750 /* non-alloc go last. */
1751 for (look
= first
; look
; look
= look
->next
)
1753 look_flags
= look
->flags
;
1754 if (look
->bfd_section
!= NULL
)
1755 look_flags
= look
->bfd_section
->flags
;
1756 differ
= look_flags
^ sec_flags
;
1757 if (!(differ
& SEC_DEBUGGING
))
1763 if (found
|| !match_type
)
1766 return lang_output_section_find_by_flags (sec
, sec_flags
, NULL
, NULL
);
1769 /* Find the last output section before given output statement.
1770 Used by place_orphan. */
1773 output_prev_sec_find (lang_output_section_statement_type
*os
)
1775 lang_output_section_statement_type
*lookup
;
1777 for (lookup
= os
->prev
; lookup
!= NULL
; lookup
= lookup
->prev
)
1779 if (lookup
->constraint
< 0)
1782 if (lookup
->bfd_section
!= NULL
&& lookup
->bfd_section
->owner
!= NULL
)
1783 return lookup
->bfd_section
;
1789 /* Look for a suitable place for a new output section statement. The
1790 idea is to skip over anything that might be inside a SECTIONS {}
1791 statement in a script, before we find another output section
1792 statement. Assignments to "dot" before an output section statement
1793 are assumed to belong to it, except in two cases; The first
1794 assignment to dot, and assignments before non-alloc sections.
1795 Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
1796 similar assignments that set the initial address, or we might
1797 insert non-alloc note sections among assignments setting end of
1800 static lang_statement_union_type
**
1801 insert_os_after (lang_output_section_statement_type
*after
)
1803 lang_statement_union_type
**where
;
1804 lang_statement_union_type
**assign
= NULL
;
1807 ignore_first
= after
== (void *) lang_os_list
.head
;
1809 for (where
= &after
->header
.next
;
1811 where
= &(*where
)->header
.next
)
1813 switch ((*where
)->header
.type
)
1815 case lang_assignment_statement_enum
:
1818 lang_assignment_statement_type
*ass
;
1820 ass
= &(*where
)->assignment_statement
;
1821 if (ass
->exp
->type
.node_class
!= etree_assert
1822 && ass
->exp
->assign
.dst
[0] == '.'
1823 && ass
->exp
->assign
.dst
[1] == 0)
1827 ignore_first
= false;
1831 case lang_wild_statement_enum
:
1832 case lang_input_section_enum
:
1833 case lang_object_symbols_statement_enum
:
1834 case lang_fill_statement_enum
:
1835 case lang_data_statement_enum
:
1836 case lang_reloc_statement_enum
:
1837 case lang_padding_statement_enum
:
1838 case lang_constructors_statement_enum
:
1840 ignore_first
= false;
1842 case lang_output_section_statement_enum
:
1845 asection
*s
= (*where
)->output_section_statement
.bfd_section
;
1848 || s
->map_head
.s
== NULL
1849 || (s
->flags
& SEC_ALLOC
) != 0)
1853 case lang_input_statement_enum
:
1854 case lang_address_statement_enum
:
1855 case lang_target_statement_enum
:
1856 case lang_output_statement_enum
:
1857 case lang_group_statement_enum
:
1858 case lang_insert_statement_enum
:
1867 lang_output_section_statement_type
*
1868 lang_insert_orphan (asection
*s
,
1869 const char *secname
,
1871 lang_output_section_statement_type
*after
,
1872 struct orphan_save
*place
,
1873 etree_type
*address
,
1874 lang_statement_list_type
*add_child
)
1876 lang_statement_list_type add
;
1877 lang_output_section_statement_type
*os
;
1878 lang_output_section_statement_type
**os_tail
;
1880 /* If we have found an appropriate place for the output section
1881 statements for this orphan, add them to our own private list,
1882 inserting them later into the global statement list. */
1885 lang_list_init (&add
);
1886 push_stat_ptr (&add
);
1889 if (bfd_link_relocatable (&link_info
)
1890 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
1891 address
= exp_intop (0);
1893 os_tail
= (lang_output_section_statement_type
**) lang_os_list
.tail
;
1894 os
= lang_enter_output_section_statement (
1895 secname
, address
, normal_section
, 0, NULL
, NULL
, NULL
, constraint
, 0);
1897 if (add_child
== NULL
)
1898 add_child
= &os
->children
;
1899 lang_add_section (add_child
, s
, NULL
, NULL
, os
);
1901 if (after
&& (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) != 0)
1903 const char *region
= (after
->region
1904 ? after
->region
->name_list
.name
1905 : DEFAULT_MEMORY_REGION
);
1906 const char *lma_region
= (after
->lma_region
1907 ? after
->lma_region
->name_list
.name
1909 lang_leave_output_section_statement (NULL
, region
, after
->phdrs
,
1913 lang_leave_output_section_statement (NULL
, DEFAULT_MEMORY_REGION
, NULL
,
1916 /* Restore the global list pointer. */
1920 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
1922 asection
*snew
, *as
;
1923 bool place_after
= place
->stmt
== NULL
;
1924 bool insert_after
= true;
1926 snew
= os
->bfd_section
;
1928 /* Shuffle the bfd section list to make the output file look
1929 neater. This is really only cosmetic. */
1930 if (place
->section
== NULL
1931 && after
!= (void *) lang_os_list
.head
)
1933 asection
*bfd_section
= after
->bfd_section
;
1935 /* If the output statement hasn't been used to place any input
1936 sections (and thus doesn't have an output bfd_section),
1937 look for the closest prior output statement having an
1939 if (bfd_section
== NULL
)
1940 bfd_section
= output_prev_sec_find (after
);
1942 if (bfd_section
!= NULL
&& bfd_section
!= snew
)
1943 place
->section
= &bfd_section
->next
;
1946 if (place
->section
== NULL
)
1947 place
->section
= &link_info
.output_bfd
->sections
;
1949 as
= *place
->section
;
1953 /* Put the section at the end of the list. */
1955 /* Unlink the section. */
1956 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1958 /* Now tack it back on in the right place. */
1959 bfd_section_list_append (link_info
.output_bfd
, snew
);
1961 else if ((bfd_get_flavour (link_info
.output_bfd
)
1962 == bfd_target_elf_flavour
)
1963 && (bfd_get_flavour (s
->owner
)
1964 == bfd_target_elf_flavour
)
1965 && ((elf_section_type (s
) == SHT_NOTE
1966 && (s
->flags
& SEC_LOAD
) != 0)
1967 || (elf_section_type (as
) == SHT_NOTE
1968 && (as
->flags
& SEC_LOAD
) != 0)))
1970 /* Make sure that output note sections are grouped and sorted
1971 by alignments when inserting a note section or insert a
1972 section after a note section, */
1974 /* A specific section after which the output note section
1975 should be placed. */
1976 asection
*after_sec
;
1977 /* True if we need to insert the orphan section after a
1978 specific section to maintain output note section order. */
1979 bool after_sec_note
= false;
1981 static asection
*first_orphan_note
= NULL
;
1983 /* Group and sort output note section by alignments in
1986 if (elf_section_type (s
) == SHT_NOTE
1987 && (s
->flags
& SEC_LOAD
) != 0)
1989 /* Search from the beginning for the last output note
1990 section with equal or larger alignments. NB: Don't
1991 place orphan note section after non-note sections. */
1993 first_orphan_note
= NULL
;
1994 for (sec
= link_info
.output_bfd
->sections
;
1996 && !bfd_is_abs_section (sec
));
1999 && elf_section_type (sec
) == SHT_NOTE
2000 && (sec
->flags
& SEC_LOAD
) != 0)
2002 if (!first_orphan_note
)
2003 first_orphan_note
= sec
;
2004 if (sec
->alignment_power
>= s
->alignment_power
)
2007 else if (first_orphan_note
)
2009 /* Stop if there is non-note section after the first
2010 orphan note section. */
2014 /* If this will be the first orphan note section, it can
2015 be placed at the default location. */
2016 after_sec_note
= first_orphan_note
!= NULL
;
2017 if (after_sec
== NULL
&& after_sec_note
)
2019 /* If all output note sections have smaller
2020 alignments, place the section before all
2021 output orphan note sections. */
2022 after_sec
= first_orphan_note
;
2023 insert_after
= false;
2026 else if (first_orphan_note
)
2028 /* Don't place non-note sections in the middle of orphan
2030 after_sec_note
= true;
2032 for (sec
= as
->next
;
2034 && !bfd_is_abs_section (sec
));
2036 if (elf_section_type (sec
) == SHT_NOTE
2037 && (sec
->flags
& SEC_LOAD
) != 0)
2045 /* Search forward to insert OS after AFTER_SEC output
2047 lang_output_section_statement_type
*stmt
, *next
;
2049 for (stmt
= after
; stmt
!= NULL
; stmt
= next
)
2054 if (stmt
->bfd_section
== after_sec
)
2064 /* If INSERT_AFTER is FALSE, place OS before
2065 AFTER_SEC output statement. */
2066 if (next
&& next
->bfd_section
== after_sec
)
2076 /* Search backward to insert OS after AFTER_SEC output
2079 for (stmt
= after
; stmt
!= NULL
; stmt
= stmt
->prev
)
2083 if (stmt
->bfd_section
== after_sec
)
2092 /* If INSERT_AFTER is FALSE, place OS before
2093 AFTER_SEC output statement. */
2094 if (stmt
->next
->bfd_section
== after_sec
)
2104 if (after_sec
== NULL
2105 || (insert_after
&& after_sec
->next
!= snew
)
2106 || (!insert_after
&& after_sec
->prev
!= snew
))
2108 /* Unlink the section. */
2109 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2111 /* Place SNEW after AFTER_SEC. If AFTER_SEC is NULL,
2116 bfd_section_list_insert_after (link_info
.output_bfd
,
2119 bfd_section_list_insert_before (link_info
.output_bfd
,
2123 bfd_section_list_prepend (link_info
.output_bfd
, snew
);
2126 else if (as
!= snew
&& as
->prev
!= snew
)
2128 /* Unlink the section. */
2129 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2131 /* Now tack it back on in the right place. */
2132 bfd_section_list_insert_before (link_info
.output_bfd
,
2136 else if (as
!= snew
&& as
->prev
!= snew
)
2138 /* Unlink the section. */
2139 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2141 /* Now tack it back on in the right place. */
2142 bfd_section_list_insert_before (link_info
.output_bfd
, as
, snew
);
2145 /* Save the end of this list. Further ophans of this type will
2146 follow the one we've just added. */
2147 place
->section
= &snew
->next
;
2149 /* The following is non-cosmetic. We try to put the output
2150 statements in some sort of reasonable order here, because they
2151 determine the final load addresses of the orphan sections.
2152 In addition, placing output statements in the wrong order may
2153 require extra segments. For instance, given a typical
2154 situation of all read-only sections placed in one segment and
2155 following that a segment containing all the read-write
2156 sections, we wouldn't want to place an orphan read/write
2157 section before or amongst the read-only ones. */
2158 if (add
.head
!= NULL
)
2160 lang_output_section_statement_type
*newly_added_os
;
2162 /* Place OS after AFTER if AFTER_NOTE is TRUE. */
2165 lang_statement_union_type
**where
= insert_os_after (after
);
2170 place
->os_tail
= &after
->next
;
2174 /* Put it after the last orphan statement we added. */
2175 *add
.tail
= *place
->stmt
;
2176 *place
->stmt
= add
.head
;
2179 /* Fix the global list pointer if we happened to tack our
2180 new list at the tail. */
2181 if (*stat_ptr
->tail
== add
.head
)
2182 stat_ptr
->tail
= add
.tail
;
2184 /* Save the end of this list. */
2185 place
->stmt
= add
.tail
;
2187 /* Do the same for the list of output section statements. */
2188 newly_added_os
= *os_tail
;
2190 newly_added_os
->prev
= (lang_output_section_statement_type
*)
2191 ((char *) place
->os_tail
2192 - offsetof (lang_output_section_statement_type
, next
));
2193 newly_added_os
->next
= *place
->os_tail
;
2194 if (newly_added_os
->next
!= NULL
)
2195 newly_added_os
->next
->prev
= newly_added_os
;
2196 *place
->os_tail
= newly_added_os
;
2197 place
->os_tail
= &newly_added_os
->next
;
2199 /* Fixing the global list pointer here is a little different.
2200 We added to the list in lang_enter_output_section_statement,
2201 trimmed off the new output_section_statment above when
2202 assigning *os_tail = NULL, but possibly added it back in
2203 the same place when assigning *place->os_tail. */
2204 if (*os_tail
== NULL
)
2205 lang_os_list
.tail
= (lang_statement_union_type
**) os_tail
;
2212 lang_print_asneeded (void)
2214 struct asneeded_minfo
*m
;
2216 if (asneeded_list_head
== NULL
)
2219 minfo (_("\nAs-needed library included to satisfy reference by file (symbol)\n\n"));
2221 for (m
= asneeded_list_head
; m
!= NULL
; m
= m
->next
)
2225 minfo ("%s", m
->soname
);
2226 len
= strlen (m
->soname
);
2240 minfo ("%pB ", m
->ref
);
2241 minfo ("(%pT)\n", m
->name
);
2246 lang_map_flags (flagword flag
)
2248 if (flag
& SEC_ALLOC
)
2251 if (flag
& SEC_CODE
)
2254 if (flag
& SEC_READONLY
)
2257 if (flag
& SEC_DATA
)
2260 if (flag
& SEC_LOAD
)
2267 lang_memory_region_type
*m
;
2268 bool dis_header_printed
= false;
2270 LANG_FOR_EACH_INPUT_STATEMENT (file
)
2274 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
2275 || file
->flags
.just_syms
)
2278 if (config
.print_map_discarded
)
2279 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2280 if ((s
->output_section
== NULL
2281 || s
->output_section
->owner
!= link_info
.output_bfd
)
2282 && (s
->flags
& (SEC_LINKER_CREATED
| SEC_KEEP
)) == 0)
2284 if (! dis_header_printed
)
2286 fprintf (config
.map_file
, _("\nDiscarded input sections\n\n"));
2287 dis_header_printed
= true;
2290 print_input_section (s
, true);
2294 minfo (_("\nMemory Configuration\n\n"));
2295 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
2296 _("Name"), _("Origin"), _("Length"), _("Attributes"));
2298 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
2303 fprintf (config
.map_file
, "%-16s ", m
->name_list
.name
);
2305 sprintf_vma (buf
, m
->origin
);
2306 minfo ("0x%s ", buf
);
2314 minfo ("0x%V", m
->length
);
2315 if (m
->flags
|| m
->not_flags
)
2323 lang_map_flags (m
->flags
);
2329 lang_map_flags (m
->not_flags
);
2336 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
2338 if (!link_info
.reduce_memory_overheads
)
2340 obstack_begin (&map_obstack
, 1000);
2341 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
2343 expld
.phase
= lang_fixed_phase_enum
;
2344 lang_statement_iteration
++;
2345 print_statements ();
2347 ldemul_extra_map_file_text (link_info
.output_bfd
, &link_info
,
2352 sort_def_symbol (struct bfd_link_hash_entry
*hash_entry
,
2353 void *info ATTRIBUTE_UNUSED
)
2355 if ((hash_entry
->type
== bfd_link_hash_defined
2356 || hash_entry
->type
== bfd_link_hash_defweak
)
2357 && hash_entry
->u
.def
.section
->owner
!= link_info
.output_bfd
2358 && hash_entry
->u
.def
.section
->owner
!= NULL
)
2360 input_section_userdata_type
*ud
;
2361 struct map_symbol_def
*def
;
2363 ud
= bfd_section_userdata (hash_entry
->u
.def
.section
);
2366 ud
= stat_alloc (sizeof (*ud
));
2367 bfd_set_section_userdata (hash_entry
->u
.def
.section
, ud
);
2368 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2369 ud
->map_symbol_def_count
= 0;
2371 else if (!ud
->map_symbol_def_tail
)
2372 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2374 def
= (struct map_symbol_def
*) obstack_alloc (&map_obstack
, sizeof *def
);
2375 def
->entry
= hash_entry
;
2376 *(ud
->map_symbol_def_tail
) = def
;
2377 ud
->map_symbol_def_tail
= &def
->next
;
2378 ud
->map_symbol_def_count
++;
2383 /* Initialize an output section. */
2386 init_os (lang_output_section_statement_type
*s
, flagword flags
)
2388 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
2389 einfo (_("%F%P: illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
2392 s
->bfd_section
= bfd_get_section_by_name (link_info
.output_bfd
, s
->name
);
2393 if (s
->bfd_section
== NULL
)
2394 s
->bfd_section
= bfd_make_section_anyway_with_flags (link_info
.output_bfd
,
2396 if (s
->bfd_section
== NULL
)
2398 einfo (_("%F%P: output format %s cannot represent section"
2399 " called %s: %E\n"),
2400 link_info
.output_bfd
->xvec
->name
, s
->name
);
2402 s
->bfd_section
->output_section
= s
->bfd_section
;
2403 s
->bfd_section
->output_offset
= 0;
2405 /* Set the userdata of the output section to the output section
2406 statement to avoid lookup. */
2407 bfd_set_section_userdata (s
->bfd_section
, s
);
2409 /* If there is a base address, make sure that any sections it might
2410 mention are initialized. */
2411 if (s
->addr_tree
!= NULL
)
2412 exp_init_os (s
->addr_tree
);
2414 if (s
->load_base
!= NULL
)
2415 exp_init_os (s
->load_base
);
2417 /* If supplied an alignment, set it. */
2418 if (s
->section_alignment
!= NULL
)
2419 s
->bfd_section
->alignment_power
= exp_get_power (s
->section_alignment
,
2420 "section alignment");
2423 /* Make sure that all output sections mentioned in an expression are
2427 exp_init_os (etree_type
*exp
)
2429 switch (exp
->type
.node_class
)
2433 case etree_provided
:
2434 exp_init_os (exp
->assign
.src
);
2438 exp_init_os (exp
->binary
.lhs
);
2439 exp_init_os (exp
->binary
.rhs
);
2443 exp_init_os (exp
->trinary
.cond
);
2444 exp_init_os (exp
->trinary
.lhs
);
2445 exp_init_os (exp
->trinary
.rhs
);
2449 exp_init_os (exp
->assert_s
.child
);
2453 exp_init_os (exp
->unary
.child
);
2457 switch (exp
->type
.node_code
)
2463 lang_output_section_statement_type
*os
;
2465 os
= lang_output_section_find (exp
->name
.name
);
2466 if (os
!= NULL
&& os
->bfd_section
== NULL
)
2478 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
2480 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
2482 /* If we are only reading symbols from this object, then we want to
2483 discard all sections. */
2484 if (entry
->flags
.just_syms
)
2486 bfd_link_just_syms (abfd
, sec
, &link_info
);
2490 /* Deal with SHF_EXCLUDE ELF sections. */
2491 if (!bfd_link_relocatable (&link_info
)
2492 && (abfd
->flags
& BFD_PLUGIN
) == 0
2493 && (sec
->flags
& (SEC_GROUP
| SEC_KEEP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
2494 sec
->output_section
= bfd_abs_section_ptr
;
2496 if (!(abfd
->flags
& DYNAMIC
))
2497 bfd_section_already_linked (abfd
, sec
, &link_info
);
2501 /* Returns true if SECTION is one we know will be discarded based on its
2502 section flags, otherwise returns false. */
2505 lang_discard_section_p (asection
*section
)
2508 flagword flags
= section
->flags
;
2510 /* Discard sections marked with SEC_EXCLUDE. */
2511 discard
= (flags
& SEC_EXCLUDE
) != 0;
2513 /* Discard the group descriptor sections when we're finally placing the
2514 sections from within the group. */
2515 if ((flags
& SEC_GROUP
) != 0
2516 && link_info
.resolve_section_groups
)
2519 /* Discard debugging sections if we are stripping debugging
2521 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
2522 && (flags
& SEC_DEBUGGING
) != 0)
2528 /* The wild routines.
2530 These expand statements like *(.text) and foo.o to a list of
2531 explicit actions, like foo.o(.text), bar.o(.text) and
2532 foo.o(.text, .data). */
2534 /* Add SECTION to the output section OUTPUT. Do this by creating a
2535 lang_input_section statement which is placed at PTR. */
2538 lang_add_section (lang_statement_list_type
*ptr
,
2540 struct wildcard_list
*pattern
,
2541 struct flag_info
*sflag_info
,
2542 lang_output_section_statement_type
*output
)
2544 flagword flags
= section
->flags
;
2547 lang_input_section_type
*new_section
;
2548 bfd
*abfd
= link_info
.output_bfd
;
2550 /* Is this section one we know should be discarded? */
2551 discard
= lang_discard_section_p (section
);
2553 /* Discard input sections which are assigned to a section named
2554 DISCARD_SECTION_NAME. */
2555 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
2560 if (section
->output_section
== NULL
)
2562 /* This prevents future calls from assigning this section. */
2563 section
->output_section
= bfd_abs_section_ptr
;
2565 else if (link_info
.non_contiguous_regions_warnings
)
2566 einfo (_("%P:%pS: warning: --enable-non-contiguous-regions makes "
2567 "section `%pA' from '%pB' match /DISCARD/ clause.\n"),
2568 NULL
, section
, section
->owner
);
2577 keep
= bfd_lookup_section_flags (&link_info
, sflag_info
, section
);
2582 if (section
->output_section
!= NULL
)
2584 if (!link_info
.non_contiguous_regions
)
2587 /* SECTION has already been handled in a special way
2588 (eg. LINK_ONCE): skip it. */
2589 if (bfd_is_abs_section (section
->output_section
))
2592 /* Already assigned to the same output section, do not process
2593 it again, to avoid creating loops between duplicate sections
2595 if (section
->output_section
== output
->bfd_section
)
2598 if (link_info
.non_contiguous_regions_warnings
&& output
->bfd_section
)
2599 einfo (_("%P:%pS: warning: --enable-non-contiguous-regions may "
2600 "change behaviour for section `%pA' from '%pB' (assigned to "
2601 "%pA, but additional match: %pA)\n"),
2602 NULL
, section
, section
->owner
, section
->output_section
,
2603 output
->bfd_section
);
2605 /* SECTION has already been assigned to an output section, but
2606 the user allows it to be mapped to another one in case it
2607 overflows. We'll later update the actual output section in
2608 size_input_section as appropriate. */
2611 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2612 to an output section, because we want to be able to include a
2613 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2614 section (I don't know why we want to do this, but we do).
2615 build_link_order in ldwrite.c handles this case by turning
2616 the embedded SEC_NEVER_LOAD section into a fill. */
2617 flags
&= ~ SEC_NEVER_LOAD
;
2619 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2620 already been processed. One reason to do this is that on pe
2621 format targets, .text$foo sections go into .text and it's odd
2622 to see .text with SEC_LINK_ONCE set. */
2623 if ((flags
& (SEC_LINK_ONCE
| SEC_GROUP
)) == (SEC_LINK_ONCE
| SEC_GROUP
))
2625 if (link_info
.resolve_section_groups
)
2626 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2628 flags
&= ~(SEC_LINK_DUPLICATES
| SEC_RELOC
);
2630 else if (!bfd_link_relocatable (&link_info
))
2631 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2633 switch (output
->sectype
)
2635 case normal_section
:
2636 case overlay_section
:
2637 case first_overlay_section
:
2640 case noalloc_section
:
2641 flags
&= ~SEC_ALLOC
;
2643 case typed_readonly_section
:
2644 case readonly_section
:
2645 flags
|= SEC_READONLY
;
2647 case noload_section
:
2649 flags
|= SEC_NEVER_LOAD
;
2650 /* Unfortunately GNU ld has managed to evolve two different
2651 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2652 alloc, no contents section. All others get a noload, noalloc
2654 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
2655 flags
&= ~SEC_HAS_CONTENTS
;
2657 flags
&= ~SEC_ALLOC
;
2661 if (output
->bfd_section
== NULL
)
2662 init_os (output
, flags
);
2664 /* If SEC_READONLY is not set in the input section, then clear
2665 it from the output section. */
2666 output
->bfd_section
->flags
&= flags
| ~SEC_READONLY
;
2668 if (output
->bfd_section
->linker_has_input
)
2670 /* Only set SEC_READONLY flag on the first input section. */
2671 flags
&= ~ SEC_READONLY
;
2673 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2674 if ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2675 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2676 || ((flags
& SEC_MERGE
) != 0
2677 && output
->bfd_section
->entsize
!= section
->entsize
))
2679 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2680 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2683 output
->bfd_section
->flags
|= flags
;
2685 if (!output
->bfd_section
->linker_has_input
)
2687 output
->bfd_section
->linker_has_input
= 1;
2688 /* This must happen after flags have been updated. The output
2689 section may have been created before we saw its first input
2690 section, eg. for a data statement. */
2691 bfd_init_private_section_data (section
->owner
, section
,
2692 link_info
.output_bfd
,
2693 output
->bfd_section
,
2695 if ((flags
& SEC_MERGE
) != 0)
2696 output
->bfd_section
->entsize
= section
->entsize
;
2699 if ((flags
& SEC_TIC54X_BLOCK
) != 0
2700 && bfd_get_arch (section
->owner
) == bfd_arch_tic54x
)
2702 /* FIXME: This value should really be obtained from the bfd... */
2703 output
->block_value
= 128;
2706 /* When a .ctors section is placed in .init_array it must be copied
2707 in reverse order. Similarly for .dtors. Set that up. */
2708 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
2709 && ((startswith (section
->name
, ".ctors")
2710 && strcmp (output
->bfd_section
->name
, ".init_array") == 0)
2711 || (startswith (section
->name
, ".dtors")
2712 && strcmp (output
->bfd_section
->name
, ".fini_array") == 0))
2713 && (section
->name
[6] == 0 || section
->name
[6] == '.'))
2714 section
->flags
|= SEC_ELF_REVERSE_COPY
;
2716 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2717 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2719 section
->output_section
= output
->bfd_section
;
2721 if (!map_head_is_link_order
)
2723 asection
*s
= output
->bfd_section
->map_tail
.s
;
2724 output
->bfd_section
->map_tail
.s
= section
;
2725 section
->map_head
.s
= NULL
;
2726 section
->map_tail
.s
= s
;
2728 s
->map_head
.s
= section
;
2730 output
->bfd_section
->map_head
.s
= section
;
2733 /* Add a section reference to the list. */
2734 new_section
= new_stat (lang_input_section
, ptr
);
2735 new_section
->section
= section
;
2736 new_section
->pattern
= pattern
;
2739 /* Handle wildcard sorting. This returns the lang_input_section which
2740 should follow the one we are going to create for SECTION and FILE,
2741 based on the sorting requirements of WILD. It returns NULL if the
2742 new section should just go at the end of the current list. */
2744 static lang_statement_union_type
*
2745 wild_sort (lang_wild_statement_type
*wild
,
2746 struct wildcard_list
*sec
,
2747 lang_input_statement_type
*file
,
2750 lang_statement_union_type
*l
;
2752 if (!wild
->filenames_sorted
2753 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
2756 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
2758 lang_input_section_type
*ls
;
2760 if (l
->header
.type
!= lang_input_section_enum
)
2762 ls
= &l
->input_section
;
2764 /* Sorting by filename takes precedence over sorting by section
2767 if (wild
->filenames_sorted
)
2769 const char *fn
, *ln
;
2773 /* The PE support for the .idata section as generated by
2774 dlltool assumes that files will be sorted by the name of
2775 the archive and then the name of the file within the
2778 if (file
->the_bfd
!= NULL
2779 && file
->the_bfd
->my_archive
!= NULL
)
2781 fn
= bfd_get_filename (file
->the_bfd
->my_archive
);
2786 fn
= file
->filename
;
2790 if (ls
->section
->owner
->my_archive
!= NULL
)
2792 ln
= bfd_get_filename (ls
->section
->owner
->my_archive
);
2797 ln
= bfd_get_filename (ls
->section
->owner
);
2801 i
= filename_cmp (fn
, ln
);
2810 fn
= file
->filename
;
2812 ln
= bfd_get_filename (ls
->section
->owner
);
2814 i
= filename_cmp (fn
, ln
);
2822 /* Here either the files are not sorted by name, or we are
2823 looking at the sections for this file. */
2826 && sec
->spec
.sorted
!= none
2827 && sec
->spec
.sorted
!= by_none
)
2828 if (compare_section (sec
->spec
.sorted
, section
, ls
->section
) < 0)
2835 /* Expand a wild statement for a particular FILE. SECTION may be
2836 NULL, in which case it is a wild card. */
2839 output_section_callback (lang_wild_statement_type
*ptr
,
2840 struct wildcard_list
*sec
,
2842 lang_input_statement_type
*file
,
2845 lang_statement_union_type
*before
;
2846 lang_output_section_statement_type
*os
;
2848 os
= (lang_output_section_statement_type
*) output
;
2850 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2851 if (unique_section_p (section
, os
))
2854 before
= wild_sort (ptr
, sec
, file
, section
);
2856 /* Here BEFORE points to the lang_input_section which
2857 should follow the one we are about to add. If BEFORE
2858 is NULL, then the section should just go at the end
2859 of the current list. */
2862 lang_add_section (&ptr
->children
, section
, ptr
->section_list
,
2863 ptr
->section_flag_list
, os
);
2866 lang_statement_list_type list
;
2867 lang_statement_union_type
**pp
;
2869 lang_list_init (&list
);
2870 lang_add_section (&list
, section
, ptr
->section_list
,
2871 ptr
->section_flag_list
, os
);
2873 /* If we are discarding the section, LIST.HEAD will
2875 if (list
.head
!= NULL
)
2877 ASSERT (list
.head
->header
.next
== NULL
);
2879 for (pp
= &ptr
->children
.head
;
2881 pp
= &(*pp
)->header
.next
)
2882 ASSERT (*pp
!= NULL
);
2884 list
.head
->header
.next
= *pp
;
2890 /* Check if all sections in a wild statement for a particular FILE
2894 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2895 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2897 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2900 lang_output_section_statement_type
*os
;
2902 os
= (lang_output_section_statement_type
*) output
;
2904 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2905 if (unique_section_p (section
, os
))
2908 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2909 os
->all_input_readonly
= false;
2912 /* This is passed a file name which must have been seen already and
2913 added to the statement tree. We will see if it has been opened
2914 already and had its symbols read. If not then we'll read it. */
2916 static lang_input_statement_type
*
2917 lookup_name (const char *name
)
2919 lang_input_statement_type
*search
;
2921 for (search
= (void *) input_file_chain
.head
;
2923 search
= search
->next_real_file
)
2925 /* Use the local_sym_name as the name of the file that has
2926 already been loaded as filename might have been transformed
2927 via the search directory lookup mechanism. */
2928 const char *filename
= search
->local_sym_name
;
2930 if (filename
!= NULL
2931 && filename_cmp (filename
, name
) == 0)
2937 /* Arrange to splice the input statement added by new_afile into
2938 statement_list after the current input_file_chain tail.
2939 We know input_file_chain is not an empty list, and that
2940 lookup_name was called via open_input_bfds. Later calls to
2941 lookup_name should always match an existing input_statement. */
2942 lang_statement_union_type
**tail
= stat_ptr
->tail
;
2943 lang_statement_union_type
**after
2944 = (void *) ((char *) input_file_chain
.tail
2945 - offsetof (lang_input_statement_type
, next_real_file
)
2946 + offsetof (lang_input_statement_type
, header
.next
));
2947 lang_statement_union_type
*rest
= *after
;
2948 stat_ptr
->tail
= after
;
2949 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2950 default_target
, NULL
);
2951 *stat_ptr
->tail
= rest
;
2953 stat_ptr
->tail
= tail
;
2956 /* If we have already added this file, or this file is not real
2957 don't add this file. */
2958 if (search
->flags
.loaded
|| !search
->flags
.real
)
2961 if (!load_symbols (search
, NULL
))
2967 /* Save LIST as a list of libraries whose symbols should not be exported. */
2972 struct excluded_lib
*next
;
2974 static struct excluded_lib
*excluded_libs
;
2977 add_excluded_libs (const char *list
)
2979 const char *p
= list
, *end
;
2983 struct excluded_lib
*entry
;
2984 end
= strpbrk (p
, ",:");
2986 end
= p
+ strlen (p
);
2987 entry
= (struct excluded_lib
*) xmalloc (sizeof (*entry
));
2988 entry
->next
= excluded_libs
;
2989 entry
->name
= (char *) xmalloc (end
- p
+ 1);
2990 memcpy (entry
->name
, p
, end
- p
);
2991 entry
->name
[end
- p
] = '\0';
2992 excluded_libs
= entry
;
3000 check_excluded_libs (bfd
*abfd
)
3002 struct excluded_lib
*lib
= excluded_libs
;
3006 int len
= strlen (lib
->name
);
3007 const char *filename
= lbasename (bfd_get_filename (abfd
));
3009 if (strcmp (lib
->name
, "ALL") == 0)
3011 abfd
->no_export
= true;
3015 if (filename_ncmp (lib
->name
, filename
, len
) == 0
3016 && (filename
[len
] == '\0'
3017 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
3018 && filename
[len
+ 2] == '\0')))
3020 abfd
->no_export
= true;
3028 /* Get the symbols for an input file. */
3031 load_symbols (lang_input_statement_type
*entry
,
3032 lang_statement_list_type
*place
)
3036 if (entry
->flags
.loaded
)
3039 ldfile_open_file (entry
);
3041 /* Do not process further if the file was missing. */
3042 if (entry
->flags
.missing_file
)
3045 if (trace_files
|| verbose
)
3046 info_msg ("%pI\n", entry
);
3048 if (!bfd_check_format (entry
->the_bfd
, bfd_archive
)
3049 && !bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
3052 struct lang_input_statement_flags save_flags
;
3055 err
= bfd_get_error ();
3057 /* See if the emulation has some special knowledge. */
3058 if (ldemul_unrecognized_file (entry
))
3061 if (err
== bfd_error_file_ambiguously_recognized
)
3065 einfo (_("%P: %pB: file not recognized: %E;"
3066 " matching formats:"), entry
->the_bfd
);
3067 for (p
= matching
; *p
!= NULL
; p
++)
3071 else if (err
!= bfd_error_file_not_recognized
3073 einfo (_("%F%P: %pB: file not recognized: %E\n"), entry
->the_bfd
);
3075 bfd_close (entry
->the_bfd
);
3076 entry
->the_bfd
= NULL
;
3078 /* Try to interpret the file as a linker script. */
3079 save_flags
= input_flags
;
3080 ldfile_open_command_file (entry
->filename
);
3082 push_stat_ptr (place
);
3083 input_flags
.add_DT_NEEDED_for_regular
3084 = entry
->flags
.add_DT_NEEDED_for_regular
;
3085 input_flags
.add_DT_NEEDED_for_dynamic
3086 = entry
->flags
.add_DT_NEEDED_for_dynamic
;
3087 input_flags
.whole_archive
= entry
->flags
.whole_archive
;
3088 input_flags
.dynamic
= entry
->flags
.dynamic
;
3090 ldfile_assumed_script
= true;
3091 parser_input
= input_script
;
3092 current_input_file
= entry
->filename
;
3094 current_input_file
= NULL
;
3095 ldfile_assumed_script
= false;
3097 /* missing_file is sticky. sysrooted will already have been
3098 restored when seeing EOF in yyparse, but no harm to restore
3100 save_flags
.missing_file
|= input_flags
.missing_file
;
3101 input_flags
= save_flags
;
3105 entry
->flags
.loaded
= true;
3110 if (ldemul_recognized_file (entry
))
3113 /* We don't call ldlang_add_file for an archive. Instead, the
3114 add_symbols entry point will call ldlang_add_file, via the
3115 add_archive_element callback, for each element of the archive
3117 switch (bfd_get_format (entry
->the_bfd
))
3123 if (!entry
->flags
.reload
)
3124 ldlang_add_file (entry
);
3128 check_excluded_libs (entry
->the_bfd
);
3130 bfd_set_usrdata (entry
->the_bfd
, entry
);
3131 if (entry
->flags
.whole_archive
)
3139 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
3144 if (!bfd_check_format (member
, bfd_object
))
3146 einfo (_("%F%P: %pB: member %pB in archive is not an object\n"),
3147 entry
->the_bfd
, member
);
3152 if (!(*link_info
.callbacks
3153 ->add_archive_element
) (&link_info
, member
,
3154 "--whole-archive", &subsbfd
))
3157 /* Potentially, the add_archive_element hook may have set a
3158 substitute BFD for us. */
3159 if (!bfd_link_add_symbols (subsbfd
, &link_info
))
3161 einfo (_("%F%P: %pB: error adding symbols: %E\n"), member
);
3166 entry
->flags
.loaded
= loaded
;
3172 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
3173 entry
->flags
.loaded
= true;
3175 einfo (_("%F%P: %pB: error adding symbols: %E\n"), entry
->the_bfd
);
3177 return entry
->flags
.loaded
;
3180 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
3181 may be NULL, indicating that it is a wildcard. Separate
3182 lang_input_section statements are created for each part of the
3183 expansion; they are added after the wild statement S. OUTPUT is
3184 the output section. */
3187 wild (lang_wild_statement_type
*s
,
3188 const char *target ATTRIBUTE_UNUSED
,
3189 lang_output_section_statement_type
*output
)
3191 struct wildcard_list
*sec
;
3193 if (s
->handler_data
[0]
3194 && s
->handler_data
[0]->spec
.sorted
== by_name
3195 && !s
->filenames_sorted
)
3197 lang_section_bst_type
*tree
;
3199 walk_wild (s
, output_section_callback_fast
, output
);
3204 output_section_callback_tree_to_list (s
, tree
, output
);
3209 walk_wild (s
, output_section_callback
, output
);
3211 if (default_common_section
== NULL
)
3212 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
3213 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
3215 /* Remember the section that common is going to in case we
3216 later get something which doesn't know where to put it. */
3217 default_common_section
= output
;
3222 /* Return TRUE iff target is the sought target. */
3225 get_target (const bfd_target
*target
, void *data
)
3227 const char *sought
= (const char *) data
;
3229 return strcmp (target
->name
, sought
) == 0;
3232 /* Like strcpy() but convert to lower case as well. */
3235 stricpy (char *dest
, const char *src
)
3239 while ((c
= *src
++) != 0)
3240 *dest
++ = TOLOWER (c
);
3245 /* Remove the first occurrence of needle (if any) in haystack
3249 strcut (char *haystack
, const char *needle
)
3251 haystack
= strstr (haystack
, needle
);
3257 for (src
= haystack
+ strlen (needle
); *src
;)
3258 *haystack
++ = *src
++;
3264 /* Compare two target format name strings.
3265 Return a value indicating how "similar" they are. */
3268 name_compare (const char *first
, const char *second
)
3274 copy1
= (char *) xmalloc (strlen (first
) + 1);
3275 copy2
= (char *) xmalloc (strlen (second
) + 1);
3277 /* Convert the names to lower case. */
3278 stricpy (copy1
, first
);
3279 stricpy (copy2
, second
);
3281 /* Remove size and endian strings from the name. */
3282 strcut (copy1
, "big");
3283 strcut (copy1
, "little");
3284 strcut (copy2
, "big");
3285 strcut (copy2
, "little");
3287 /* Return a value based on how many characters match,
3288 starting from the beginning. If both strings are
3289 the same then return 10 * their length. */
3290 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
3291 if (copy1
[result
] == 0)
3303 /* Set by closest_target_match() below. */
3304 static const bfd_target
*winner
;
3306 /* Scan all the valid bfd targets looking for one that has the endianness
3307 requirement that was specified on the command line, and is the nearest
3308 match to the original output target. */
3311 closest_target_match (const bfd_target
*target
, void *data
)
3313 const bfd_target
*original
= (const bfd_target
*) data
;
3315 if (command_line
.endian
== ENDIAN_BIG
3316 && target
->byteorder
!= BFD_ENDIAN_BIG
)
3319 if (command_line
.endian
== ENDIAN_LITTLE
3320 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
3323 /* Must be the same flavour. */
3324 if (target
->flavour
!= original
->flavour
)
3327 /* Ignore generic big and little endian elf vectors. */
3328 if (strcmp (target
->name
, "elf32-big") == 0
3329 || strcmp (target
->name
, "elf64-big") == 0
3330 || strcmp (target
->name
, "elf32-little") == 0
3331 || strcmp (target
->name
, "elf64-little") == 0)
3334 /* If we have not found a potential winner yet, then record this one. */
3341 /* Oh dear, we now have two potential candidates for a successful match.
3342 Compare their names and choose the better one. */
3343 if (name_compare (target
->name
, original
->name
)
3344 > name_compare (winner
->name
, original
->name
))
3347 /* Keep on searching until wqe have checked them all. */
3351 /* Return the BFD target format of the first input file. */
3354 get_first_input_target (void)
3356 const char *target
= NULL
;
3358 LANG_FOR_EACH_INPUT_STATEMENT (s
)
3360 if (s
->header
.type
== lang_input_statement_enum
3363 ldfile_open_file (s
);
3365 if (s
->the_bfd
!= NULL
3366 && bfd_check_format (s
->the_bfd
, bfd_object
))
3368 target
= bfd_get_target (s
->the_bfd
);
3380 lang_get_output_target (void)
3384 /* Has the user told us which output format to use? */
3385 if (output_target
!= NULL
)
3386 return output_target
;
3388 /* No - has the current target been set to something other than
3390 if (current_target
!= default_target
&& current_target
!= NULL
)
3391 return current_target
;
3393 /* No - can we determine the format of the first input file? */
3394 target
= get_first_input_target ();
3398 /* Failed - use the default output target. */
3399 return default_target
;
3402 /* Open the output file. */
3405 open_output (const char *name
)
3407 lang_input_statement_type
*f
;
3408 char *out
= lrealpath (name
);
3410 for (f
= (void *) input_file_chain
.head
;
3412 f
= f
->next_real_file
)
3415 char *in
= lrealpath (f
->local_sym_name
);
3416 if (filename_cmp (in
, out
) == 0)
3417 einfo (_("%F%P: input file '%s' is the same as output file\n"),
3423 output_target
= lang_get_output_target ();
3425 /* Has the user requested a particular endianness on the command
3427 if (command_line
.endian
!= ENDIAN_UNSET
)
3429 /* Get the chosen target. */
3430 const bfd_target
*target
3431 = bfd_iterate_over_targets (get_target
, (void *) output_target
);
3433 /* If the target is not supported, we cannot do anything. */
3436 enum bfd_endian desired_endian
;
3438 if (command_line
.endian
== ENDIAN_BIG
)
3439 desired_endian
= BFD_ENDIAN_BIG
;
3441 desired_endian
= BFD_ENDIAN_LITTLE
;
3443 /* See if the target has the wrong endianness. This should
3444 not happen if the linker script has provided big and
3445 little endian alternatives, but some scrips don't do
3447 if (target
->byteorder
!= desired_endian
)
3449 /* If it does, then see if the target provides
3450 an alternative with the correct endianness. */
3451 if (target
->alternative_target
!= NULL
3452 && (target
->alternative_target
->byteorder
== desired_endian
))
3453 output_target
= target
->alternative_target
->name
;
3456 /* Try to find a target as similar as possible to
3457 the default target, but which has the desired
3458 endian characteristic. */
3459 bfd_iterate_over_targets (closest_target_match
,
3462 /* Oh dear - we could not find any targets that
3463 satisfy our requirements. */
3465 einfo (_("%P: warning: could not find any targets"
3466 " that match endianness requirement\n"));
3468 output_target
= winner
->name
;
3474 link_info
.output_bfd
= bfd_openw (name
, output_target
);
3476 if (link_info
.output_bfd
== NULL
)
3478 if (bfd_get_error () == bfd_error_invalid_target
)
3479 einfo (_("%F%P: target %s not found\n"), output_target
);
3481 einfo (_("%F%P: cannot open output file %s: %E\n"), name
);
3484 delete_output_file_on_failure
= true;
3486 if (!bfd_set_format (link_info
.output_bfd
, bfd_object
))
3487 einfo (_("%F%P: %s: can not make object file: %E\n"), name
);
3488 if (!bfd_set_arch_mach (link_info
.output_bfd
,
3489 ldfile_output_architecture
,
3490 ldfile_output_machine
))
3491 einfo (_("%F%P: %s: can not set architecture: %E\n"), name
);
3493 link_info
.hash
= bfd_link_hash_table_create (link_info
.output_bfd
);
3494 if (link_info
.hash
== NULL
)
3495 einfo (_("%F%P: can not create hash table: %E\n"));
3497 bfd_set_gp_size (link_info
.output_bfd
, g_switch_value
);
3501 ldlang_open_output (lang_statement_union_type
*statement
)
3503 switch (statement
->header
.type
)
3505 case lang_output_statement_enum
:
3506 ASSERT (link_info
.output_bfd
== NULL
);
3507 open_output (statement
->output_statement
.name
);
3508 ldemul_set_output_arch ();
3509 if (config
.magic_demand_paged
3510 && !bfd_link_relocatable (&link_info
))
3511 link_info
.output_bfd
->flags
|= D_PAGED
;
3513 link_info
.output_bfd
->flags
&= ~D_PAGED
;
3514 if (config
.text_read_only
)
3515 link_info
.output_bfd
->flags
|= WP_TEXT
;
3517 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
3518 if (link_info
.traditional_format
)
3519 link_info
.output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
3521 link_info
.output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
3524 case lang_target_statement_enum
:
3525 current_target
= statement
->target_statement
.target
;
3533 init_opb (asection
*s
)
3538 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
3540 && (s
->flags
& SEC_ELF_OCTETS
) != 0)
3543 x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3544 ldfile_output_machine
);
3546 while ((x
& 1) == 0)
3554 /* Open all the input files. */
3558 OPEN_BFD_NORMAL
= 0,
3562 #if BFD_SUPPORTS_PLUGINS
3563 static lang_input_statement_type
*plugin_insert
= NULL
;
3564 static struct bfd_link_hash_entry
*plugin_undefs
= NULL
;
3568 open_input_bfds (lang_statement_union_type
*s
, enum open_bfd_mode mode
)
3570 for (; s
!= NULL
; s
= s
->header
.next
)
3572 switch (s
->header
.type
)
3574 case lang_constructors_statement_enum
:
3575 open_input_bfds (constructor_list
.head
, mode
);
3577 case lang_output_section_statement_enum
:
3578 open_input_bfds (s
->output_section_statement
.children
.head
, mode
);
3580 case lang_wild_statement_enum
:
3581 /* Maybe we should load the file's symbols. */
3582 if ((mode
& OPEN_BFD_RESCAN
) == 0
3583 && s
->wild_statement
.filename
3584 && !wildcardp (s
->wild_statement
.filename
)
3585 && !archive_path (s
->wild_statement
.filename
))
3586 lookup_name (s
->wild_statement
.filename
);
3587 open_input_bfds (s
->wild_statement
.children
.head
, mode
);
3589 case lang_group_statement_enum
:
3591 struct bfd_link_hash_entry
*undefs
;
3592 #if BFD_SUPPORTS_PLUGINS
3593 lang_input_statement_type
*plugin_insert_save
;
3596 /* We must continually search the entries in the group
3597 until no new symbols are added to the list of undefined
3602 #if BFD_SUPPORTS_PLUGINS
3603 plugin_insert_save
= plugin_insert
;
3605 undefs
= link_info
.hash
->undefs_tail
;
3606 open_input_bfds (s
->group_statement
.children
.head
,
3607 mode
| OPEN_BFD_FORCE
);
3609 while (undefs
!= link_info
.hash
->undefs_tail
3610 #if BFD_SUPPORTS_PLUGINS
3611 /* Objects inserted by a plugin, which are loaded
3612 before we hit this loop, may have added new
3614 || (plugin_insert
!= plugin_insert_save
&& plugin_undefs
)
3619 case lang_target_statement_enum
:
3620 current_target
= s
->target_statement
.target
;
3622 case lang_input_statement_enum
:
3623 if (s
->input_statement
.flags
.real
)
3625 lang_statement_union_type
**os_tail
;
3626 lang_statement_list_type add
;
3629 s
->input_statement
.target
= current_target
;
3631 /* If we are being called from within a group, and this
3632 is an archive which has already been searched, then
3633 force it to be researched unless the whole archive
3634 has been loaded already. Do the same for a rescan.
3635 Likewise reload --as-needed shared libs. */
3636 if (mode
!= OPEN_BFD_NORMAL
3637 #if BFD_SUPPORTS_PLUGINS
3638 && ((mode
& OPEN_BFD_RESCAN
) == 0
3639 || plugin_insert
== NULL
)
3641 && s
->input_statement
.flags
.loaded
3642 && (abfd
= s
->input_statement
.the_bfd
) != NULL
3643 && ((bfd_get_format (abfd
) == bfd_archive
3644 && !s
->input_statement
.flags
.whole_archive
)
3645 || (bfd_get_format (abfd
) == bfd_object
3646 && ((abfd
->flags
) & DYNAMIC
) != 0
3647 && s
->input_statement
.flags
.add_DT_NEEDED_for_regular
3648 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3649 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)))
3651 s
->input_statement
.flags
.loaded
= false;
3652 s
->input_statement
.flags
.reload
= true;
3655 os_tail
= lang_os_list
.tail
;
3656 lang_list_init (&add
);
3658 if (!load_symbols (&s
->input_statement
, &add
))
3659 config
.make_executable
= false;
3661 if (add
.head
!= NULL
)
3663 /* If this was a script with output sections then
3664 tack any added statements on to the end of the
3665 list. This avoids having to reorder the output
3666 section statement list. Very likely the user
3667 forgot -T, and whatever we do here will not meet
3668 naive user expectations. */
3669 if (os_tail
!= lang_os_list
.tail
)
3671 einfo (_("%P: warning: %s contains output sections;"
3672 " did you forget -T?\n"),
3673 s
->input_statement
.filename
);
3674 *stat_ptr
->tail
= add
.head
;
3675 stat_ptr
->tail
= add
.tail
;
3679 *add
.tail
= s
->header
.next
;
3680 s
->header
.next
= add
.head
;
3684 #if BFD_SUPPORTS_PLUGINS
3685 /* If we have found the point at which a plugin added new
3686 files, clear plugin_insert to enable archive rescan. */
3687 if (&s
->input_statement
== plugin_insert
)
3688 plugin_insert
= NULL
;
3691 case lang_assignment_statement_enum
:
3692 if (s
->assignment_statement
.exp
->type
.node_class
!= etree_assert
)
3693 exp_fold_tree_no_dot (s
->assignment_statement
.exp
);
3700 /* Exit if any of the files were missing. */
3701 if (input_flags
.missing_file
)
3705 #ifdef ENABLE_LIBCTF
3706 /* Emit CTF errors and warnings. fp can be NULL to report errors/warnings
3707 that happened specifically at CTF open time. */
3709 lang_ctf_errs_warnings (ctf_dict_t
*fp
)
3711 ctf_next_t
*i
= NULL
;
3716 while ((text
= ctf_errwarning_next (fp
, &i
, &is_warning
, &err
)) != NULL
)
3718 einfo (_("%s: %s\n"), is_warning
? _("CTF warning"): _("CTF error"),
3722 if (err
!= ECTF_NEXT_END
)
3724 einfo (_("CTF error: cannot get CTF errors: `%s'\n"),
3728 /* `err' returns errors from the error/warning iterator in particular.
3729 These never assert. But if we have an fp, that could have recorded
3730 an assertion failure: assert if it has done so. */
3731 ASSERT (!fp
|| ctf_errno (fp
) != ECTF_INTERNAL
);
3734 /* Open the CTF sections in the input files with libctf: if any were opened,
3735 create a fake input file that we'll write the merged CTF data to later
3739 ldlang_open_ctf (void)
3744 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3748 /* Incoming files from the compiler have a single ctf_dict_t in them
3749 (which is presented to us by the libctf API in a ctf_archive_t
3750 wrapper): files derived from a previous relocatable link have a CTF
3751 archive containing possibly many CTF files. */
3753 if ((file
->the_ctf
= ctf_bfdopen (file
->the_bfd
, &err
)) == NULL
)
3755 if (err
!= ECTF_NOCTFDATA
)
3757 lang_ctf_errs_warnings (NULL
);
3758 einfo (_("%P: warning: CTF section in %pB not loaded; "
3759 "its types will be discarded: %s\n"), file
->the_bfd
,
3765 /* Prevent the contents of this section from being written, while
3766 requiring the section itself to be duplicated in the output, but only
3768 /* This section must exist if ctf_bfdopen() succeeded. */
3769 sect
= bfd_get_section_by_name (file
->the_bfd
, ".ctf");
3771 sect
->flags
|= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
| SEC_LINKER_CREATED
;
3774 sect
->flags
|= SEC_EXCLUDE
;
3784 if ((ctf_output
= ctf_create (&err
)) != NULL
)
3787 einfo (_("%P: warning: CTF output not created: `%s'\n"),
3790 LANG_FOR_EACH_INPUT_STATEMENT (errfile
)
3791 ctf_close (errfile
->the_ctf
);
3794 /* Merge together CTF sections. After this, only the symtab-dependent
3795 function and data object sections need adjustment. */
3798 lang_merge_ctf (void)
3800 asection
*output_sect
;
3806 output_sect
= bfd_get_section_by_name (link_info
.output_bfd
, ".ctf");
3808 /* If the section was discarded, don't waste time merging. */
3809 if (output_sect
== NULL
)
3811 ctf_dict_close (ctf_output
);
3814 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3816 ctf_close (file
->the_ctf
);
3817 file
->the_ctf
= NULL
;
3822 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3827 /* Takes ownership of file->the_ctf. */
3828 if (ctf_link_add_ctf (ctf_output
, file
->the_ctf
, file
->filename
) < 0)
3830 einfo (_("%P: warning: CTF section in %pB cannot be linked: `%s'\n"),
3831 file
->the_bfd
, ctf_errmsg (ctf_errno (ctf_output
)));
3832 ctf_close (file
->the_ctf
);
3833 file
->the_ctf
= NULL
;
3838 if (!config
.ctf_share_duplicated
)
3839 flags
= CTF_LINK_SHARE_UNCONFLICTED
;
3841 flags
= CTF_LINK_SHARE_DUPLICATED
;
3842 if (!config
.ctf_variables
)
3843 flags
|= CTF_LINK_OMIT_VARIABLES_SECTION
;
3844 if (bfd_link_relocatable (&link_info
))
3845 flags
|= CTF_LINK_NO_FILTER_REPORTED_SYMS
;
3847 if (ctf_link (ctf_output
, flags
) < 0)
3849 lang_ctf_errs_warnings (ctf_output
);
3850 einfo (_("%P: warning: CTF linking failed; "
3851 "output will have no CTF section: %s\n"),
3852 ctf_errmsg (ctf_errno (ctf_output
)));
3855 output_sect
->size
= 0;
3856 output_sect
->flags
|= SEC_EXCLUDE
;
3859 /* Output any lingering errors that didn't come from ctf_link. */
3860 lang_ctf_errs_warnings (ctf_output
);
3863 /* Let the emulation acquire strings from the dynamic strtab to help it optimize
3864 the CTF, if supported. */
3867 ldlang_ctf_acquire_strings (struct elf_strtab_hash
*dynstrtab
)
3869 ldemul_acquire_strings_for_ctf (ctf_output
, dynstrtab
);
3872 /* Inform the emulation about the addition of a new dynamic symbol, in BFD
3874 void ldlang_ctf_new_dynsym (int symidx
, struct elf_internal_sym
*sym
)
3876 ldemul_new_dynsym_for_ctf (ctf_output
, symidx
, sym
);
3879 /* Write out the CTF section. Called early, if the emulation isn't going to
3880 need to dedup against the strtab and symtab, then possibly called from the
3881 target linker code if the dedup has happened. */
3883 lang_write_ctf (int late
)
3886 asection
*output_sect
;
3893 /* Emit CTF late if this emulation says it can do so. */
3894 if (ldemul_emit_ctf_early ())
3899 if (!ldemul_emit_ctf_early ())
3903 /* Inform the emulation that all the symbols that will be received have
3906 ldemul_new_dynsym_for_ctf (ctf_output
, 0, NULL
);
3910 output_sect
= bfd_get_section_by_name (link_info
.output_bfd
, ".ctf");
3913 output_sect
->contents
= ctf_link_write (ctf_output
, &output_size
,
3914 CTF_COMPRESSION_THRESHOLD
);
3915 output_sect
->size
= output_size
;
3916 output_sect
->flags
|= SEC_IN_MEMORY
| SEC_KEEP
;
3918 lang_ctf_errs_warnings (ctf_output
);
3919 if (!output_sect
->contents
)
3921 einfo (_("%P: warning: CTF section emission failed; "
3922 "output will have no CTF section: %s\n"),
3923 ctf_errmsg (ctf_errno (ctf_output
)));
3924 output_sect
->size
= 0;
3925 output_sect
->flags
|= SEC_EXCLUDE
;
3929 /* This also closes every CTF input file used in the link. */
3930 ctf_dict_close (ctf_output
);
3933 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3934 file
->the_ctf
= NULL
;
3937 /* Write out the CTF section late, if the emulation needs that. */
3940 ldlang_write_ctf_late (void)
3942 /* Trigger a "late call", if the emulation needs one. */
3948 ldlang_open_ctf (void)
3950 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3954 /* If built without CTF, warn and delete all CTF sections from the output.
3955 (The alternative would be to simply concatenate them, which does not
3956 yield a valid CTF section.) */
3958 if ((sect
= bfd_get_section_by_name (file
->the_bfd
, ".ctf")) != NULL
)
3960 einfo (_("%P: warning: CTF section in %pB not linkable: "
3961 "%P was built without support for CTF\n"), file
->the_bfd
);
3963 sect
->flags
|= SEC_EXCLUDE
;
3968 static void lang_merge_ctf (void) {}
3970 ldlang_ctf_acquire_strings (struct elf_strtab_hash
*dynstrtab
3971 ATTRIBUTE_UNUSED
) {}
3973 ldlang_ctf_new_dynsym (int symidx ATTRIBUTE_UNUSED
,
3974 struct elf_internal_sym
*sym ATTRIBUTE_UNUSED
) {}
3975 static void lang_write_ctf (int late ATTRIBUTE_UNUSED
) {}
3976 void ldlang_write_ctf_late (void) {}
3979 /* Add the supplied name to the symbol table as an undefined reference.
3980 This is a two step process as the symbol table doesn't even exist at
3981 the time the ld command line is processed. First we put the name
3982 on a list, then, once the output file has been opened, transfer the
3983 name to the symbol table. */
3985 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3987 #define ldlang_undef_chain_list_head entry_symbol.next
3990 ldlang_add_undef (const char *const name
, bool cmdline ATTRIBUTE_UNUSED
)
3992 ldlang_undef_chain_list_type
*new_undef
;
3994 new_undef
= stat_alloc (sizeof (*new_undef
));
3995 new_undef
->next
= ldlang_undef_chain_list_head
;
3996 ldlang_undef_chain_list_head
= new_undef
;
3998 new_undef
->name
= xstrdup (name
);
4000 if (link_info
.output_bfd
!= NULL
)
4001 insert_undefined (new_undef
->name
);
4004 /* Insert NAME as undefined in the symbol table. */
4007 insert_undefined (const char *name
)
4009 struct bfd_link_hash_entry
*h
;
4011 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, false, true);
4013 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
4014 if (h
->type
== bfd_link_hash_new
)
4016 h
->type
= bfd_link_hash_undefined
;
4017 h
->u
.undef
.abfd
= NULL
;
4018 h
->non_ir_ref_regular
= true;
4019 bfd_link_add_undef (link_info
.hash
, h
);
4023 /* Run through the list of undefineds created above and place them
4024 into the linker hash table as undefined symbols belonging to the
4028 lang_place_undefineds (void)
4030 ldlang_undef_chain_list_type
*ptr
;
4032 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
4033 insert_undefined (ptr
->name
);
4036 /* Mark -u symbols against garbage collection. */
4039 lang_mark_undefineds (void)
4041 ldlang_undef_chain_list_type
*ptr
;
4043 if (is_elf_hash_table (link_info
.hash
))
4044 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
4046 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*)
4047 bfd_link_hash_lookup (link_info
.hash
, ptr
->name
, false, false, true);
4053 /* Structure used to build the list of symbols that the user has required
4056 struct require_defined_symbol
4059 struct require_defined_symbol
*next
;
4062 /* The list of symbols that the user has required be defined. */
4064 static struct require_defined_symbol
*require_defined_symbol_list
;
4066 /* Add a new symbol NAME to the list of symbols that are required to be
4070 ldlang_add_require_defined (const char *const name
)
4072 struct require_defined_symbol
*ptr
;
4074 ldlang_add_undef (name
, true);
4075 ptr
= stat_alloc (sizeof (*ptr
));
4076 ptr
->next
= require_defined_symbol_list
;
4077 ptr
->name
= strdup (name
);
4078 require_defined_symbol_list
= ptr
;
4081 /* Check that all symbols the user required to be defined, are defined,
4082 raise an error if we find a symbol that is not defined. */
4085 ldlang_check_require_defined_symbols (void)
4087 struct require_defined_symbol
*ptr
;
4089 for (ptr
= require_defined_symbol_list
; ptr
!= NULL
; ptr
= ptr
->next
)
4091 struct bfd_link_hash_entry
*h
;
4093 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
,
4094 false, false, true);
4096 || (h
->type
!= bfd_link_hash_defined
4097 && h
->type
!= bfd_link_hash_defweak
))
4098 einfo(_("%X%P: required symbol `%s' not defined\n"), ptr
->name
);
4102 /* Check for all readonly or some readwrite sections. */
4105 check_input_sections
4106 (lang_statement_union_type
*s
,
4107 lang_output_section_statement_type
*output_section_statement
)
4109 for (; s
!= NULL
; s
= s
->header
.next
)
4111 switch (s
->header
.type
)
4113 case lang_wild_statement_enum
:
4114 walk_wild (&s
->wild_statement
, check_section_callback
,
4115 output_section_statement
);
4116 if (!output_section_statement
->all_input_readonly
)
4119 case lang_constructors_statement_enum
:
4120 check_input_sections (constructor_list
.head
,
4121 output_section_statement
);
4122 if (!output_section_statement
->all_input_readonly
)
4125 case lang_group_statement_enum
:
4126 check_input_sections (s
->group_statement
.children
.head
,
4127 output_section_statement
);
4128 if (!output_section_statement
->all_input_readonly
)
4137 /* Update wildcard statements if needed. */
4140 update_wild_statements (lang_statement_union_type
*s
)
4142 struct wildcard_list
*sec
;
4144 switch (sort_section
)
4154 for (; s
!= NULL
; s
= s
->header
.next
)
4156 switch (s
->header
.type
)
4161 case lang_wild_statement_enum
:
4162 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
4164 /* Don't sort .init/.fini sections. */
4165 if (strcmp (sec
->spec
.name
, ".init") != 0
4166 && strcmp (sec
->spec
.name
, ".fini") != 0)
4167 switch (sec
->spec
.sorted
)
4170 sec
->spec
.sorted
= sort_section
;
4173 if (sort_section
== by_alignment
)
4174 sec
->spec
.sorted
= by_name_alignment
;
4177 if (sort_section
== by_name
)
4178 sec
->spec
.sorted
= by_alignment_name
;
4185 case lang_constructors_statement_enum
:
4186 update_wild_statements (constructor_list
.head
);
4189 case lang_output_section_statement_enum
:
4190 update_wild_statements
4191 (s
->output_section_statement
.children
.head
);
4194 case lang_group_statement_enum
:
4195 update_wild_statements (s
->group_statement
.children
.head
);
4203 /* Open input files and attach to output sections. */
4206 map_input_to_output_sections
4207 (lang_statement_union_type
*s
, const char *target
,
4208 lang_output_section_statement_type
*os
)
4210 for (; s
!= NULL
; s
= s
->header
.next
)
4212 lang_output_section_statement_type
*tos
;
4214 unsigned int type
= 0;
4216 switch (s
->header
.type
)
4218 case lang_wild_statement_enum
:
4219 wild (&s
->wild_statement
, target
, os
);
4221 case lang_constructors_statement_enum
:
4222 map_input_to_output_sections (constructor_list
.head
,
4226 case lang_output_section_statement_enum
:
4227 tos
= &s
->output_section_statement
;
4228 if (tos
->constraint
== ONLY_IF_RW
4229 || tos
->constraint
== ONLY_IF_RO
)
4231 tos
->all_input_readonly
= true;
4232 check_input_sections (tos
->children
.head
, tos
);
4233 if (tos
->all_input_readonly
!= (tos
->constraint
== ONLY_IF_RO
))
4234 tos
->constraint
= -1;
4236 if (tos
->constraint
>= 0)
4237 map_input_to_output_sections (tos
->children
.head
,
4241 case lang_output_statement_enum
:
4243 case lang_target_statement_enum
:
4244 target
= s
->target_statement
.target
;
4246 case lang_group_statement_enum
:
4247 map_input_to_output_sections (s
->group_statement
.children
.head
,
4251 case lang_data_statement_enum
:
4252 /* Make sure that any sections mentioned in the expression
4254 exp_init_os (s
->data_statement
.exp
);
4255 /* The output section gets CONTENTS, ALLOC and LOAD, but
4256 these may be overridden by the script. */
4257 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
;
4258 switch (os
->sectype
)
4260 case normal_section
:
4261 case overlay_section
:
4262 case first_overlay_section
:
4264 case noalloc_section
:
4265 flags
= SEC_HAS_CONTENTS
;
4267 case readonly_section
:
4268 flags
|= SEC_READONLY
;
4270 case typed_readonly_section
:
4271 flags
|= SEC_READONLY
;
4274 if (os
->sectype_value
->type
.node_class
== etree_name
4275 && os
->sectype_value
->type
.node_code
== NAME
)
4277 const char *name
= os
->sectype_value
->name
.name
;
4278 if (strcmp (name
, "SHT_PROGBITS") == 0)
4279 type
= SHT_PROGBITS
;
4280 else if (strcmp (name
, "SHT_STRTAB") == 0)
4282 else if (strcmp (name
, "SHT_NOTE") == 0)
4284 else if (strcmp (name
, "SHT_NOBITS") == 0)
4286 else if (strcmp (name
, "SHT_INIT_ARRAY") == 0)
4287 type
= SHT_INIT_ARRAY
;
4288 else if (strcmp (name
, "SHT_FINI_ARRAY") == 0)
4289 type
= SHT_FINI_ARRAY
;
4290 else if (strcmp (name
, "SHT_PREINIT_ARRAY") == 0)
4291 type
= SHT_PREINIT_ARRAY
;
4293 einfo (_ ("%F%P: invalid type for output section `%s'\n"),
4298 exp_fold_tree_no_dot (os
->sectype_value
);
4299 if (expld
.result
.valid_p
)
4300 type
= expld
.result
.value
;
4302 einfo (_ ("%F%P: invalid type for output section `%s'\n"),
4306 case noload_section
:
4307 if (bfd_get_flavour (link_info
.output_bfd
)
4308 == bfd_target_elf_flavour
)
4309 flags
= SEC_NEVER_LOAD
| SEC_ALLOC
;
4311 flags
= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
;
4314 if (os
->bfd_section
== NULL
)
4315 init_os (os
, flags
| SEC_READONLY
);
4317 os
->bfd_section
->flags
|= flags
;
4318 os
->bfd_section
->type
= type
;
4320 case lang_input_section_enum
:
4322 case lang_fill_statement_enum
:
4323 case lang_object_symbols_statement_enum
:
4324 case lang_reloc_statement_enum
:
4325 case lang_padding_statement_enum
:
4326 case lang_input_statement_enum
:
4327 if (os
!= NULL
&& os
->bfd_section
== NULL
)
4330 case lang_assignment_statement_enum
:
4331 if (os
!= NULL
&& os
->bfd_section
== NULL
)
4334 /* Make sure that any sections mentioned in the assignment
4336 exp_init_os (s
->assignment_statement
.exp
);
4338 case lang_address_statement_enum
:
4339 /* Mark the specified section with the supplied address.
4340 If this section was actually a segment marker, then the
4341 directive is ignored if the linker script explicitly
4342 processed the segment marker. Originally, the linker
4343 treated segment directives (like -Ttext on the
4344 command-line) as section directives. We honor the
4345 section directive semantics for backwards compatibility;
4346 linker scripts that do not specifically check for
4347 SEGMENT_START automatically get the old semantics. */
4348 if (!s
->address_statement
.segment
4349 || !s
->address_statement
.segment
->used
)
4351 const char *name
= s
->address_statement
.section_name
;
4353 /* Create the output section statement here so that
4354 orphans with a set address will be placed after other
4355 script sections. If we let the orphan placement code
4356 place them in amongst other sections then the address
4357 will affect following script sections, which is
4358 likely to surprise naive users. */
4359 tos
= lang_output_section_statement_lookup (name
, 0, 1);
4360 tos
->addr_tree
= s
->address_statement
.address
;
4361 if (tos
->bfd_section
== NULL
)
4365 case lang_insert_statement_enum
:
4371 /* An insert statement snips out all the linker statements from the
4372 start of the list and places them after the output section
4373 statement specified by the insert. This operation is complicated
4374 by the fact that we keep a doubly linked list of output section
4375 statements as well as the singly linked list of all statements.
4376 FIXME someday: Twiddling with the list not only moves statements
4377 from the user's script but also input and group statements that are
4378 built from command line object files and --start-group. We only
4379 get away with this because the list pointers used by file_chain
4380 and input_file_chain are not reordered, and processing via
4381 statement_list after this point mostly ignores input statements.
4382 One exception is the map file, where LOAD and START GROUP/END GROUP
4383 can end up looking odd. */
4386 process_insert_statements (lang_statement_union_type
**start
)
4388 lang_statement_union_type
**s
;
4389 lang_output_section_statement_type
*first_os
= NULL
;
4390 lang_output_section_statement_type
*last_os
= NULL
;
4391 lang_output_section_statement_type
*os
;
4396 if ((*s
)->header
.type
== lang_output_section_statement_enum
)
4398 /* Keep pointers to the first and last output section
4399 statement in the sequence we may be about to move. */
4400 os
= &(*s
)->output_section_statement
;
4402 ASSERT (last_os
== NULL
|| last_os
->next
== os
);
4405 /* Set constraint negative so that lang_output_section_find
4406 won't match this output section statement. At this
4407 stage in linking constraint has values in the range
4408 [-1, ONLY_IN_RW]. */
4409 last_os
->constraint
= -2 - last_os
->constraint
;
4410 if (first_os
== NULL
)
4413 else if ((*s
)->header
.type
== lang_group_statement_enum
)
4415 /* A user might put -T between --start-group and
4416 --end-group. One way this odd construct might arise is
4417 from a wrapper around ld to change library search
4418 behaviour. For example:
4420 exec real_ld --start-group "$@" --end-group
4421 This isn't completely unreasonable so go looking inside a
4422 group statement for insert statements. */
4423 process_insert_statements (&(*s
)->group_statement
.children
.head
);
4425 else if ((*s
)->header
.type
== lang_insert_statement_enum
)
4427 lang_insert_statement_type
*i
= &(*s
)->insert_statement
;
4428 lang_output_section_statement_type
*where
;
4429 lang_statement_union_type
**ptr
;
4430 lang_statement_union_type
*first
;
4432 if (link_info
.non_contiguous_regions
)
4434 einfo (_("warning: INSERT statement in linker script is "
4435 "incompatible with --enable-non-contiguous-regions.\n"));
4438 where
= lang_output_section_find (i
->where
);
4439 if (where
!= NULL
&& i
->is_before
)
4442 where
= where
->prev
;
4443 while (where
!= NULL
&& where
->constraint
< 0);
4447 einfo (_("%F%P: %s not found for insert\n"), i
->where
);
4451 /* Deal with reordering the output section statement list. */
4452 if (last_os
!= NULL
)
4454 asection
*first_sec
, *last_sec
;
4455 struct lang_output_section_statement_struct
**next
;
4457 /* Snip out the output sections we are moving. */
4458 first_os
->prev
->next
= last_os
->next
;
4459 if (last_os
->next
== NULL
)
4461 next
= &first_os
->prev
->next
;
4462 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4465 last_os
->next
->prev
= first_os
->prev
;
4466 /* Add them in at the new position. */
4467 last_os
->next
= where
->next
;
4468 if (where
->next
== NULL
)
4470 next
= &last_os
->next
;
4471 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4474 where
->next
->prev
= last_os
;
4475 first_os
->prev
= where
;
4476 where
->next
= first_os
;
4478 /* Move the bfd sections in the same way. */
4481 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4483 os
->constraint
= -2 - os
->constraint
;
4484 if (os
->bfd_section
!= NULL
4485 && os
->bfd_section
->owner
!= NULL
)
4487 last_sec
= os
->bfd_section
;
4488 if (first_sec
== NULL
)
4489 first_sec
= last_sec
;
4494 if (last_sec
!= NULL
)
4496 asection
*sec
= where
->bfd_section
;
4498 sec
= output_prev_sec_find (where
);
4500 /* The place we want to insert must come after the
4501 sections we are moving. So if we find no
4502 section or if the section is the same as our
4503 last section, then no move is needed. */
4504 if (sec
!= NULL
&& sec
!= last_sec
)
4506 /* Trim them off. */
4507 if (first_sec
->prev
!= NULL
)
4508 first_sec
->prev
->next
= last_sec
->next
;
4510 link_info
.output_bfd
->sections
= last_sec
->next
;
4511 if (last_sec
->next
!= NULL
)
4512 last_sec
->next
->prev
= first_sec
->prev
;
4514 link_info
.output_bfd
->section_last
= first_sec
->prev
;
4516 last_sec
->next
= sec
->next
;
4517 if (sec
->next
!= NULL
)
4518 sec
->next
->prev
= last_sec
;
4520 link_info
.output_bfd
->section_last
= last_sec
;
4521 first_sec
->prev
= sec
;
4522 sec
->next
= first_sec
;
4530 ptr
= insert_os_after (where
);
4531 /* Snip everything from the start of the list, up to and
4532 including the insert statement we are currently processing. */
4534 *start
= (*s
)->header
.next
;
4535 /* Add them back where they belong, minus the insert. */
4538 statement_list
.tail
= s
;
4543 s
= &(*s
)->header
.next
;
4546 /* Undo constraint twiddling. */
4547 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4549 os
->constraint
= -2 - os
->constraint
;
4555 /* An output section might have been removed after its statement was
4556 added. For example, ldemul_before_allocation can remove dynamic
4557 sections if they turn out to be not needed. Clean them up here. */
4560 strip_excluded_output_sections (void)
4562 lang_output_section_statement_type
*os
;
4564 /* Run lang_size_sections (if not already done). */
4565 if (expld
.phase
!= lang_mark_phase_enum
)
4567 expld
.phase
= lang_mark_phase_enum
;
4568 expld
.dataseg
.phase
= exp_seg_none
;
4569 one_lang_size_sections_pass (NULL
, false);
4570 lang_reset_memory_regions ();
4573 for (os
= (void *) lang_os_list
.head
;
4577 asection
*output_section
;
4580 if (os
->constraint
< 0)
4583 output_section
= os
->bfd_section
;
4584 if (output_section
== NULL
)
4587 exclude
= (output_section
->rawsize
== 0
4588 && (output_section
->flags
& SEC_KEEP
) == 0
4589 && !bfd_section_removed_from_list (link_info
.output_bfd
,
4592 /* Some sections have not yet been sized, notably .gnu.version,
4593 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
4594 input sections, so don't drop output sections that have such
4595 input sections unless they are also marked SEC_EXCLUDE. */
4596 if (exclude
&& output_section
->map_head
.s
!= NULL
)
4600 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
4601 if ((s
->flags
& SEC_EXCLUDE
) == 0
4602 && ((s
->flags
& SEC_LINKER_CREATED
) != 0
4603 || link_info
.emitrelocations
))
4612 /* We don't set bfd_section to NULL since bfd_section of the
4613 removed output section statement may still be used. */
4614 if (!os
->update_dot
)
4616 output_section
->flags
|= SEC_EXCLUDE
;
4617 bfd_section_list_remove (link_info
.output_bfd
, output_section
);
4618 link_info
.output_bfd
->section_count
--;
4623 /* Called from ldwrite to clear out asection.map_head and
4624 asection.map_tail for use as link_orders in ldwrite. */
4627 lang_clear_os_map (void)
4629 lang_output_section_statement_type
*os
;
4631 if (map_head_is_link_order
)
4634 for (os
= (void *) lang_os_list
.head
;
4638 asection
*output_section
;
4640 if (os
->constraint
< 0)
4643 output_section
= os
->bfd_section
;
4644 if (output_section
== NULL
)
4647 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
4648 output_section
->map_head
.link_order
= NULL
;
4649 output_section
->map_tail
.link_order
= NULL
;
4652 /* Stop future calls to lang_add_section from messing with map_head
4653 and map_tail link_order fields. */
4654 map_head_is_link_order
= true;
4658 print_output_section_statement
4659 (lang_output_section_statement_type
*output_section_statement
)
4661 asection
*section
= output_section_statement
->bfd_section
;
4664 if (output_section_statement
!= abs_output_section
)
4666 minfo ("\n%s", output_section_statement
->name
);
4668 if (section
!= NULL
)
4670 print_dot
= section
->vma
;
4672 len
= strlen (output_section_statement
->name
);
4673 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4678 while (len
< SECTION_NAME_MAP_LENGTH
)
4684 minfo ("0x%V %W", section
->vma
, TO_ADDR (section
->size
));
4686 if (section
->vma
!= section
->lma
)
4687 minfo (_(" load address 0x%V"), section
->lma
);
4689 if (output_section_statement
->update_dot_tree
!= NULL
)
4690 exp_fold_tree (output_section_statement
->update_dot_tree
,
4691 bfd_abs_section_ptr
, &print_dot
);
4697 print_statement_list (output_section_statement
->children
.head
,
4698 output_section_statement
);
4702 print_assignment (lang_assignment_statement_type
*assignment
,
4703 lang_output_section_statement_type
*output_section
)
4710 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4713 if (assignment
->exp
->type
.node_class
== etree_assert
)
4716 tree
= assignment
->exp
->assert_s
.child
;
4720 const char *dst
= assignment
->exp
->assign
.dst
;
4722 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
4723 tree
= assignment
->exp
;
4726 osec
= output_section
->bfd_section
;
4728 osec
= bfd_abs_section_ptr
;
4730 if (assignment
->exp
->type
.node_class
!= etree_provide
)
4731 exp_fold_tree (tree
, osec
, &print_dot
);
4733 expld
.result
.valid_p
= false;
4735 if (expld
.result
.valid_p
)
4739 if (assignment
->exp
->type
.node_class
== etree_assert
4741 || expld
.assign_name
!= NULL
)
4743 value
= expld
.result
.value
;
4745 if (expld
.result
.section
!= NULL
)
4746 value
+= expld
.result
.section
->vma
;
4748 minfo ("0x%V", value
);
4754 struct bfd_link_hash_entry
*h
;
4756 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
4757 false, false, true);
4759 && (h
->type
== bfd_link_hash_defined
4760 || h
->type
== bfd_link_hash_defweak
))
4762 value
= h
->u
.def
.value
;
4763 value
+= h
->u
.def
.section
->output_section
->vma
;
4764 value
+= h
->u
.def
.section
->output_offset
;
4766 minfo ("[0x%V]", value
);
4769 minfo ("[unresolved]");
4774 if (assignment
->exp
->type
.node_class
== etree_provide
)
4775 minfo ("[!provide]");
4782 expld
.assign_name
= NULL
;
4785 exp_print_tree (assignment
->exp
);
4790 print_input_statement (lang_input_statement_type
*statm
)
4792 if (statm
->filename
!= NULL
)
4793 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
4796 /* Print all symbols defined in a particular section. This is called
4797 via bfd_link_hash_traverse, or by print_all_symbols. */
4800 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
4802 asection
*sec
= (asection
*) ptr
;
4804 if ((hash_entry
->type
== bfd_link_hash_defined
4805 || hash_entry
->type
== bfd_link_hash_defweak
)
4806 && sec
== hash_entry
->u
.def
.section
)
4810 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4813 (hash_entry
->u
.def
.value
4814 + hash_entry
->u
.def
.section
->output_offset
4815 + hash_entry
->u
.def
.section
->output_section
->vma
));
4817 minfo (" %pT\n", hash_entry
->root
.string
);
4824 hash_entry_addr_cmp (const void *a
, const void *b
)
4826 const struct bfd_link_hash_entry
*l
= *(const struct bfd_link_hash_entry
**)a
;
4827 const struct bfd_link_hash_entry
*r
= *(const struct bfd_link_hash_entry
**)b
;
4829 if (l
->u
.def
.value
< r
->u
.def
.value
)
4831 else if (l
->u
.def
.value
> r
->u
.def
.value
)
4838 print_all_symbols (asection
*sec
)
4840 input_section_userdata_type
*ud
= bfd_section_userdata (sec
);
4841 struct map_symbol_def
*def
;
4842 struct bfd_link_hash_entry
**entries
;
4848 *ud
->map_symbol_def_tail
= 0;
4850 /* Sort the symbols by address. */
4851 entries
= (struct bfd_link_hash_entry
**)
4852 obstack_alloc (&map_obstack
,
4853 ud
->map_symbol_def_count
* sizeof (*entries
));
4855 for (i
= 0, def
= ud
->map_symbol_def_head
; def
; def
= def
->next
, i
++)
4856 entries
[i
] = def
->entry
;
4858 qsort (entries
, ud
->map_symbol_def_count
, sizeof (*entries
),
4859 hash_entry_addr_cmp
);
4861 /* Print the symbols. */
4862 for (i
= 0; i
< ud
->map_symbol_def_count
; i
++)
4863 ldemul_print_symbol (entries
[i
], sec
);
4865 obstack_free (&map_obstack
, entries
);
4868 /* Print information about an input section to the map file. */
4871 print_input_section (asection
*i
, bool is_discarded
)
4873 bfd_size_type size
= i
->size
;
4880 minfo ("%s", i
->name
);
4882 len
= 1 + strlen (i
->name
);
4883 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4888 while (len
< SECTION_NAME_MAP_LENGTH
)
4894 if (i
->output_section
!= NULL
4895 && i
->output_section
->owner
== link_info
.output_bfd
)
4896 addr
= i
->output_section
->vma
+ i
->output_offset
;
4904 minfo ("0x%V %W %pB\n", addr
, TO_ADDR (size
), i
->owner
);
4906 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
4908 len
= SECTION_NAME_MAP_LENGTH
+ 3;
4920 minfo (_("%W (size before relaxing)\n"), TO_ADDR (i
->rawsize
));
4923 if (i
->output_section
!= NULL
4924 && i
->output_section
->owner
== link_info
.output_bfd
)
4926 if (link_info
.reduce_memory_overheads
)
4927 bfd_link_hash_traverse (link_info
.hash
, ldemul_print_symbol
, i
);
4929 print_all_symbols (i
);
4931 /* Update print_dot, but make sure that we do not move it
4932 backwards - this could happen if we have overlays and a
4933 later overlay is shorter than an earier one. */
4934 if (addr
+ TO_ADDR (size
) > print_dot
)
4935 print_dot
= addr
+ TO_ADDR (size
);
4940 print_fill_statement (lang_fill_statement_type
*fill
)
4944 fputs (" FILL mask 0x", config
.map_file
);
4945 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
4946 fprintf (config
.map_file
, "%02x", *p
);
4947 fputs ("\n", config
.map_file
);
4951 print_data_statement (lang_data_statement_type
*data
)
4958 init_opb (data
->output_section
);
4959 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4962 addr
= data
->output_offset
;
4963 if (data
->output_section
!= NULL
)
4964 addr
+= data
->output_section
->vma
;
4992 if (size
< TO_SIZE ((unsigned) 1))
4993 size
= TO_SIZE ((unsigned) 1);
4994 minfo ("0x%V %W %s 0x%v", addr
, TO_ADDR (size
), name
, data
->value
);
4996 if (data
->exp
->type
.node_class
!= etree_value
)
4999 exp_print_tree (data
->exp
);
5004 print_dot
= addr
+ TO_ADDR (size
);
5007 /* Print an address statement. These are generated by options like
5011 print_address_statement (lang_address_statement_type
*address
)
5013 minfo (_("Address of section %s set to "), address
->section_name
);
5014 exp_print_tree (address
->address
);
5018 /* Print a reloc statement. */
5021 print_reloc_statement (lang_reloc_statement_type
*reloc
)
5027 init_opb (reloc
->output_section
);
5028 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
5031 addr
= reloc
->output_offset
;
5032 if (reloc
->output_section
!= NULL
)
5033 addr
+= reloc
->output_section
->vma
;
5035 size
= bfd_get_reloc_size (reloc
->howto
);
5037 minfo ("0x%V %W RELOC %s ", addr
, TO_ADDR (size
), reloc
->howto
->name
);
5039 if (reloc
->name
!= NULL
)
5040 minfo ("%s+", reloc
->name
);
5042 minfo ("%s+", reloc
->section
->name
);
5044 exp_print_tree (reloc
->addend_exp
);
5048 print_dot
= addr
+ TO_ADDR (size
);
5052 print_padding_statement (lang_padding_statement_type
*s
)
5057 init_opb (s
->output_section
);
5060 len
= sizeof " *fill*" - 1;
5061 while (len
< SECTION_NAME_MAP_LENGTH
)
5067 addr
= s
->output_offset
;
5068 if (s
->output_section
!= NULL
)
5069 addr
+= s
->output_section
->vma
;
5070 minfo ("0x%V %W ", addr
, TO_ADDR (s
->size
));
5072 if (s
->fill
->size
!= 0)
5076 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
5077 fprintf (config
.map_file
, "%02x", *p
);
5082 print_dot
= addr
+ TO_ADDR (s
->size
);
5086 print_wild_statement (lang_wild_statement_type
*w
,
5087 lang_output_section_statement_type
*os
)
5089 struct wildcard_list
*sec
;
5093 if (w
->exclude_name_list
)
5096 minfo ("EXCLUDE_FILE(%s", w
->exclude_name_list
->name
);
5097 for (tmp
= w
->exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
5098 minfo (" %s", tmp
->name
);
5102 if (w
->filenames_sorted
)
5103 minfo ("SORT_BY_NAME(");
5104 if (w
->filename
!= NULL
)
5105 minfo ("%s", w
->filename
);
5108 if (w
->filenames_sorted
)
5112 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
5114 int closing_paren
= 0;
5116 switch (sec
->spec
.sorted
)
5122 minfo ("SORT_BY_NAME(");
5127 minfo ("SORT_BY_ALIGNMENT(");
5131 case by_name_alignment
:
5132 minfo ("SORT_BY_NAME(SORT_BY_ALIGNMENT(");
5136 case by_alignment_name
:
5137 minfo ("SORT_BY_ALIGNMENT(SORT_BY_NAME(");
5142 minfo ("SORT_NONE(");
5146 case by_init_priority
:
5147 minfo ("SORT_BY_INIT_PRIORITY(");
5152 if (sec
->spec
.exclude_name_list
!= NULL
)
5155 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
5156 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
5157 minfo (" %s", tmp
->name
);
5160 if (sec
->spec
.name
!= NULL
)
5161 minfo ("%s", sec
->spec
.name
);
5164 for (;closing_paren
> 0; closing_paren
--)
5173 print_statement_list (w
->children
.head
, os
);
5176 /* Print a group statement. */
5179 print_group (lang_group_statement_type
*s
,
5180 lang_output_section_statement_type
*os
)
5182 fprintf (config
.map_file
, "START GROUP\n");
5183 print_statement_list (s
->children
.head
, os
);
5184 fprintf (config
.map_file
, "END GROUP\n");
5187 /* Print the list of statements in S.
5188 This can be called for any statement type. */
5191 print_statement_list (lang_statement_union_type
*s
,
5192 lang_output_section_statement_type
*os
)
5196 print_statement (s
, os
);
5201 /* Print the first statement in statement list S.
5202 This can be called for any statement type. */
5205 print_statement (lang_statement_union_type
*s
,
5206 lang_output_section_statement_type
*os
)
5208 switch (s
->header
.type
)
5211 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
5214 case lang_constructors_statement_enum
:
5215 if (constructor_list
.head
!= NULL
)
5217 if (constructors_sorted
)
5218 minfo (" SORT (CONSTRUCTORS)\n");
5220 minfo (" CONSTRUCTORS\n");
5221 print_statement_list (constructor_list
.head
, os
);
5224 case lang_wild_statement_enum
:
5225 print_wild_statement (&s
->wild_statement
, os
);
5227 case lang_address_statement_enum
:
5228 print_address_statement (&s
->address_statement
);
5230 case lang_object_symbols_statement_enum
:
5231 minfo (" CREATE_OBJECT_SYMBOLS\n");
5233 case lang_fill_statement_enum
:
5234 print_fill_statement (&s
->fill_statement
);
5236 case lang_data_statement_enum
:
5237 print_data_statement (&s
->data_statement
);
5239 case lang_reloc_statement_enum
:
5240 print_reloc_statement (&s
->reloc_statement
);
5242 case lang_input_section_enum
:
5243 print_input_section (s
->input_section
.section
, false);
5245 case lang_padding_statement_enum
:
5246 print_padding_statement (&s
->padding_statement
);
5248 case lang_output_section_statement_enum
:
5249 print_output_section_statement (&s
->output_section_statement
);
5251 case lang_assignment_statement_enum
:
5252 print_assignment (&s
->assignment_statement
, os
);
5254 case lang_target_statement_enum
:
5255 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
5257 case lang_output_statement_enum
:
5258 minfo ("OUTPUT(%s", s
->output_statement
.name
);
5259 if (output_target
!= NULL
)
5260 minfo (" %s", output_target
);
5263 case lang_input_statement_enum
:
5264 print_input_statement (&s
->input_statement
);
5266 case lang_group_statement_enum
:
5267 print_group (&s
->group_statement
, os
);
5269 case lang_insert_statement_enum
:
5270 minfo ("INSERT %s %s\n",
5271 s
->insert_statement
.is_before
? "BEFORE" : "AFTER",
5272 s
->insert_statement
.where
);
5278 print_statements (void)
5280 print_statement_list (statement_list
.head
, abs_output_section
);
5283 /* Print the first N statements in statement list S to STDERR.
5284 If N == 0, nothing is printed.
5285 If N < 0, the entire list is printed.
5286 Intended to be called from GDB. */
5289 dprint_statement (lang_statement_union_type
*s
, int n
)
5291 FILE *map_save
= config
.map_file
;
5293 config
.map_file
= stderr
;
5296 print_statement_list (s
, abs_output_section
);
5299 while (s
&& --n
>= 0)
5301 print_statement (s
, abs_output_section
);
5306 config
.map_file
= map_save
;
5310 insert_pad (lang_statement_union_type
**ptr
,
5312 bfd_size_type alignment_needed
,
5313 asection
*output_section
,
5316 static fill_type zero_fill
;
5317 lang_statement_union_type
*pad
= NULL
;
5319 if (ptr
!= &statement_list
.head
)
5320 pad
= ((lang_statement_union_type
*)
5321 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
5323 && pad
->header
.type
== lang_padding_statement_enum
5324 && pad
->padding_statement
.output_section
== output_section
)
5326 /* Use the existing pad statement. */
5328 else if ((pad
= *ptr
) != NULL
5329 && pad
->header
.type
== lang_padding_statement_enum
5330 && pad
->padding_statement
.output_section
== output_section
)
5332 /* Use the existing pad statement. */
5336 /* Make a new padding statement, linked into existing chain. */
5337 pad
= stat_alloc (sizeof (lang_padding_statement_type
));
5338 pad
->header
.next
= *ptr
;
5340 pad
->header
.type
= lang_padding_statement_enum
;
5341 pad
->padding_statement
.output_section
= output_section
;
5344 pad
->padding_statement
.fill
= fill
;
5346 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
5347 pad
->padding_statement
.size
= alignment_needed
;
5348 if (!(output_section
->flags
& SEC_FIXED_SIZE
))
5349 output_section
->size
= TO_SIZE (dot
+ TO_ADDR (alignment_needed
)
5350 - output_section
->vma
);
5353 /* Work out how much this section will move the dot point. */
5357 (lang_statement_union_type
**this_ptr
,
5358 lang_output_section_statement_type
*output_section_statement
,
5363 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
5364 asection
*i
= is
->section
;
5365 asection
*o
= output_section_statement
->bfd_section
;
5368 if (link_info
.non_contiguous_regions
)
5370 /* If the input section I has already been successfully assigned
5371 to an output section other than O, don't bother with it and
5372 let the caller remove it from the list. Keep processing in
5373 case we have already handled O, because the repeated passes
5374 have reinitialized its size. */
5375 if (i
->already_assigned
&& i
->already_assigned
!= o
)
5382 if (i
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
5383 i
->output_offset
= i
->vma
- o
->vma
;
5384 else if (((i
->flags
& SEC_EXCLUDE
) != 0)
5385 || output_section_statement
->ignored
)
5386 i
->output_offset
= dot
- o
->vma
;
5389 bfd_size_type alignment_needed
;
5391 /* Align this section first to the input sections requirement,
5392 then to the output section's requirement. If this alignment
5393 is greater than any seen before, then record it too. Perform
5394 the alignment by inserting a magic 'padding' statement. */
5396 if (output_section_statement
->subsection_alignment
!= NULL
)
5398 = exp_get_power (output_section_statement
->subsection_alignment
,
5399 "subsection alignment");
5401 if (o
->alignment_power
< i
->alignment_power
)
5402 o
->alignment_power
= i
->alignment_power
;
5404 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
5406 if (alignment_needed
!= 0)
5408 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
5409 dot
+= alignment_needed
;
5412 if (link_info
.non_contiguous_regions
)
5414 /* If I would overflow O, let the caller remove I from the
5416 if (output_section_statement
->region
)
5418 bfd_vma end
= output_section_statement
->region
->origin
5419 + output_section_statement
->region
->length
;
5421 if (dot
+ TO_ADDR (i
->size
) > end
)
5423 if (i
->flags
& SEC_LINKER_CREATED
)
5424 einfo (_("%F%P: Output section '%s' not large enough for the "
5425 "linker-created stubs section '%s'.\n"),
5426 i
->output_section
->name
, i
->name
);
5428 if (i
->rawsize
&& i
->rawsize
!= i
->size
)
5429 einfo (_("%F%P: Relaxation not supported with "
5430 "--enable-non-contiguous-regions (section '%s' "
5431 "would overflow '%s' after it changed size).\n"),
5432 i
->name
, i
->output_section
->name
);
5436 i
->output_section
= NULL
;
5442 /* Remember where in the output section this input section goes. */
5443 i
->output_offset
= dot
- o
->vma
;
5445 /* Mark how big the output section must be to contain this now. */
5446 dot
+= TO_ADDR (i
->size
);
5447 if (!(o
->flags
& SEC_FIXED_SIZE
))
5448 o
->size
= TO_SIZE (dot
- o
->vma
);
5450 if (link_info
.non_contiguous_regions
)
5452 /* Record that I was successfully assigned to O, and update
5453 its actual output section too. */
5454 i
->already_assigned
= o
;
5455 i
->output_section
= o
;
5469 sort_sections_by_lma (const void *arg1
, const void *arg2
)
5471 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
5472 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
5474 if (sec1
->lma
< sec2
->lma
)
5476 else if (sec1
->lma
> sec2
->lma
)
5478 else if (sec1
->id
< sec2
->id
)
5480 else if (sec1
->id
> sec2
->id
)
5487 sort_sections_by_vma (const void *arg1
, const void *arg2
)
5489 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
5490 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
5492 if (sec1
->vma
< sec2
->vma
)
5494 else if (sec1
->vma
> sec2
->vma
)
5496 else if (sec1
->id
< sec2
->id
)
5498 else if (sec1
->id
> sec2
->id
)
5504 #define IS_TBSS(s) \
5505 ((s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == SEC_THREAD_LOCAL)
5507 #define IGNORE_SECTION(s) \
5508 ((s->flags & SEC_ALLOC) == 0 || IS_TBSS (s))
5510 /* Check to see if any allocated sections overlap with other allocated
5511 sections. This can happen if a linker script specifies the output
5512 section addresses of the two sections. Also check whether any memory
5513 region has overflowed. */
5516 lang_check_section_addresses (void)
5519 struct check_sec
*sections
;
5524 bfd_vma p_start
= 0;
5526 lang_memory_region_type
*m
;
5529 /* Detect address space overflow on allocated sections. */
5530 addr_mask
= ((bfd_vma
) 1 <<
5531 (bfd_arch_bits_per_address (link_info
.output_bfd
) - 1)) - 1;
5532 addr_mask
= (addr_mask
<< 1) + 1;
5533 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5534 if ((s
->flags
& SEC_ALLOC
) != 0)
5536 s_end
= (s
->vma
+ s
->size
) & addr_mask
;
5537 if (s_end
!= 0 && s_end
< (s
->vma
& addr_mask
))
5538 einfo (_("%X%P: section %s VMA wraps around address space\n"),
5542 s_end
= (s
->lma
+ s
->size
) & addr_mask
;
5543 if (s_end
!= 0 && s_end
< (s
->lma
& addr_mask
))
5544 einfo (_("%X%P: section %s LMA wraps around address space\n"),
5549 if (bfd_count_sections (link_info
.output_bfd
) <= 1)
5552 count
= bfd_count_sections (link_info
.output_bfd
);
5553 sections
= XNEWVEC (struct check_sec
, count
);
5555 /* Scan all sections in the output list. */
5557 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5559 if (IGNORE_SECTION (s
)
5563 sections
[count
].sec
= s
;
5564 sections
[count
].warned
= false;
5574 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_lma
);
5576 /* First check section LMAs. There should be no overlap of LMAs on
5577 loadable sections, even with overlays. */
5578 for (p
= NULL
, i
= 0; i
< count
; i
++)
5580 s
= sections
[i
].sec
;
5582 if ((s
->flags
& SEC_LOAD
) != 0)
5585 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5587 /* Look for an overlap. We have sorted sections by lma, so
5588 we know that s_start >= p_start. Besides the obvious
5589 case of overlap when the current section starts before
5590 the previous one ends, we also must have overlap if the
5591 previous section wraps around the address space. */
5593 && (s_start
<= p_end
5594 || p_end
< p_start
))
5596 einfo (_("%X%P: section %s LMA [%V,%V]"
5597 " overlaps section %s LMA [%V,%V]\n"),
5598 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5599 sections
[i
].warned
= true;
5607 /* If any non-zero size allocated section (excluding tbss) starts at
5608 exactly the same VMA as another such section, then we have
5609 overlays. Overlays generated by the OVERLAY keyword will have
5610 this property. It is possible to intentionally generate overlays
5611 that fail this test, but it would be unusual. */
5612 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_vma
);
5614 p_start
= sections
[0].sec
->vma
;
5615 for (i
= 1; i
< count
; i
++)
5617 s_start
= sections
[i
].sec
->vma
;
5618 if (p_start
== s_start
)
5626 /* Now check section VMAs if no overlays were detected. */
5629 for (p
= NULL
, i
= 0; i
< count
; i
++)
5631 s
= sections
[i
].sec
;
5634 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5637 && !sections
[i
].warned
5638 && (s_start
<= p_end
5639 || p_end
< p_start
))
5640 einfo (_("%X%P: section %s VMA [%V,%V]"
5641 " overlaps section %s VMA [%V,%V]\n"),
5642 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5651 /* If any memory region has overflowed, report by how much.
5652 We do not issue this diagnostic for regions that had sections
5653 explicitly placed outside their bounds; os_region_check's
5654 diagnostics are adequate for that case.
5656 FIXME: It is conceivable that m->current - (m->origin + m->length)
5657 might overflow a 32-bit integer. There is, alas, no way to print
5658 a bfd_vma quantity in decimal. */
5659 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
5660 if (m
->had_full_message
)
5662 unsigned long over
= m
->current
- (m
->origin
+ m
->length
);
5663 einfo (ngettext ("%X%P: region `%s' overflowed by %lu byte\n",
5664 "%X%P: region `%s' overflowed by %lu bytes\n",
5666 m
->name_list
.name
, over
);
5670 /* Make sure the new address is within the region. We explicitly permit the
5671 current address to be at the exact end of the region when the address is
5672 non-zero, in case the region is at the end of addressable memory and the
5673 calculation wraps around. */
5676 os_region_check (lang_output_section_statement_type
*os
,
5677 lang_memory_region_type
*region
,
5681 if ((region
->current
< region
->origin
5682 || (region
->current
- region
->origin
> region
->length
))
5683 && ((region
->current
!= region
->origin
+ region
->length
)
5688 einfo (_("%X%P: address 0x%v of %pB section `%s'"
5689 " is not within region `%s'\n"),
5691 os
->bfd_section
->owner
,
5692 os
->bfd_section
->name
,
5693 region
->name_list
.name
);
5695 else if (!region
->had_full_message
)
5697 region
->had_full_message
= true;
5699 einfo (_("%X%P: %pB section `%s' will not fit in region `%s'\n"),
5700 os
->bfd_section
->owner
,
5701 os
->bfd_section
->name
,
5702 region
->name_list
.name
);
5708 ldlang_check_relro_region (lang_statement_union_type
*s
)
5710 seg_align_type
*seg
= &expld
.dataseg
;
5712 if (seg
->relro
== exp_seg_relro_start
)
5714 if (!seg
->relro_start_stat
)
5715 seg
->relro_start_stat
= s
;
5718 ASSERT (seg
->relro_start_stat
== s
);
5721 else if (seg
->relro
== exp_seg_relro_end
)
5723 if (!seg
->relro_end_stat
)
5724 seg
->relro_end_stat
= s
;
5727 ASSERT (seg
->relro_end_stat
== s
);
5732 /* Set the sizes for all the output sections. */
5735 lang_size_sections_1
5736 (lang_statement_union_type
**prev
,
5737 lang_output_section_statement_type
*output_section_statement
,
5743 lang_statement_union_type
*s
;
5744 lang_statement_union_type
*prev_s
= NULL
;
5745 bool removed_prev_s
= false;
5747 /* Size up the sections from their constituent parts. */
5748 for (s
= *prev
; s
!= NULL
; prev_s
= s
, s
= s
->header
.next
)
5750 bool removed
= false;
5752 switch (s
->header
.type
)
5754 case lang_output_section_statement_enum
:
5756 bfd_vma newdot
, after
, dotdelta
;
5757 lang_output_section_statement_type
*os
;
5758 lang_memory_region_type
*r
;
5759 int section_alignment
= 0;
5761 os
= &s
->output_section_statement
;
5762 init_opb (os
->bfd_section
);
5763 if (os
->constraint
== -1)
5766 /* FIXME: We shouldn't need to zero section vmas for ld -r
5767 here, in lang_insert_orphan, or in the default linker scripts.
5768 This is covering for coff backend linker bugs. See PR6945. */
5769 if (os
->addr_tree
== NULL
5770 && bfd_link_relocatable (&link_info
)
5771 && (bfd_get_flavour (link_info
.output_bfd
)
5772 == bfd_target_coff_flavour
))
5773 os
->addr_tree
= exp_intop (0);
5774 if (os
->addr_tree
!= NULL
)
5776 os
->processed_vma
= false;
5777 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
5779 if (expld
.result
.valid_p
)
5781 dot
= expld
.result
.value
;
5782 if (expld
.result
.section
!= NULL
)
5783 dot
+= expld
.result
.section
->vma
;
5785 else if (expld
.phase
!= lang_mark_phase_enum
)
5786 einfo (_("%F%P:%pS: non constant or forward reference"
5787 " address expression for section %s\n"),
5788 os
->addr_tree
, os
->name
);
5791 if (os
->bfd_section
== NULL
)
5792 /* This section was removed or never actually created. */
5795 /* If this is a COFF shared library section, use the size and
5796 address from the input section. FIXME: This is COFF
5797 specific; it would be cleaner if there were some other way
5798 to do this, but nothing simple comes to mind. */
5799 if (((bfd_get_flavour (link_info
.output_bfd
)
5800 == bfd_target_ecoff_flavour
)
5801 || (bfd_get_flavour (link_info
.output_bfd
)
5802 == bfd_target_coff_flavour
))
5803 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
5807 if (os
->children
.head
== NULL
5808 || os
->children
.head
->header
.next
!= NULL
5809 || (os
->children
.head
->header
.type
5810 != lang_input_section_enum
))
5811 einfo (_("%X%P: internal error on COFF shared library"
5812 " section %s\n"), os
->name
);
5814 input
= os
->children
.head
->input_section
.section
;
5815 bfd_set_section_vma (os
->bfd_section
,
5816 bfd_section_vma (input
));
5817 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5818 os
->bfd_section
->size
= input
->size
;
5824 if (bfd_is_abs_section (os
->bfd_section
))
5826 /* No matter what happens, an abs section starts at zero. */
5827 ASSERT (os
->bfd_section
->vma
== 0);
5831 if (os
->addr_tree
== NULL
)
5833 /* No address specified for this section, get one
5834 from the region specification. */
5835 if (os
->region
== NULL
5836 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
5837 && os
->region
->name_list
.name
[0] == '*'
5838 && strcmp (os
->region
->name_list
.name
,
5839 DEFAULT_MEMORY_REGION
) == 0))
5841 os
->region
= lang_memory_default (os
->bfd_section
);
5844 /* If a loadable section is using the default memory
5845 region, and some non default memory regions were
5846 defined, issue an error message. */
5848 && !IGNORE_SECTION (os
->bfd_section
)
5849 && !bfd_link_relocatable (&link_info
)
5851 && strcmp (os
->region
->name_list
.name
,
5852 DEFAULT_MEMORY_REGION
) == 0
5853 && lang_memory_region_list
!= NULL
5854 && (strcmp (lang_memory_region_list
->name_list
.name
,
5855 DEFAULT_MEMORY_REGION
) != 0
5856 || lang_memory_region_list
->next
!= NULL
)
5857 && lang_sizing_iteration
== 1)
5859 /* By default this is an error rather than just a
5860 warning because if we allocate the section to the
5861 default memory region we can end up creating an
5862 excessively large binary, or even seg faulting when
5863 attempting to perform a negative seek. See
5864 sources.redhat.com/ml/binutils/2003-04/msg00423.html
5865 for an example of this. This behaviour can be
5866 overridden by the using the --no-check-sections
5868 if (command_line
.check_section_addresses
)
5869 einfo (_("%F%P: error: no memory region specified"
5870 " for loadable section `%s'\n"),
5871 bfd_section_name (os
->bfd_section
));
5873 einfo (_("%P: warning: no memory region specified"
5874 " for loadable section `%s'\n"),
5875 bfd_section_name (os
->bfd_section
));
5878 newdot
= os
->region
->current
;
5879 section_alignment
= os
->bfd_section
->alignment_power
;
5882 section_alignment
= exp_get_power (os
->section_alignment
,
5883 "section alignment");
5885 /* Align to what the section needs. */
5886 if (section_alignment
> 0)
5888 bfd_vma savedot
= newdot
;
5891 newdot
= align_power (newdot
, section_alignment
);
5892 dotdelta
= newdot
- savedot
;
5894 if (lang_sizing_iteration
== 1)
5896 else if (lang_sizing_iteration
> 1)
5898 /* Only report adjustments that would change
5899 alignment from what we have already reported. */
5900 diff
= newdot
- os
->bfd_section
->vma
;
5901 if (!(diff
& (((bfd_vma
) 1 << section_alignment
) - 1)))
5905 && (config
.warn_section_align
5906 || os
->addr_tree
!= NULL
))
5907 einfo (_("%P: warning: "
5908 "start of section %s changed by %ld\n"),
5909 os
->name
, (long) diff
);
5912 bfd_set_section_vma (os
->bfd_section
, newdot
);
5914 os
->bfd_section
->output_offset
= 0;
5917 lang_size_sections_1 (&os
->children
.head
, os
,
5918 os
->fill
, newdot
, relax
, check_regions
);
5920 os
->processed_vma
= true;
5922 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5923 /* Except for some special linker created sections,
5924 no output section should change from zero size
5925 after strip_excluded_output_sections. A non-zero
5926 size on an ignored section indicates that some
5927 input section was not sized early enough. */
5928 ASSERT (os
->bfd_section
->size
== 0);
5931 dot
= os
->bfd_section
->vma
;
5933 /* Put the section within the requested block size, or
5934 align at the block boundary. */
5936 + TO_ADDR (os
->bfd_section
->size
)
5937 + os
->block_value
- 1)
5938 & - (bfd_vma
) os
->block_value
);
5940 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5941 os
->bfd_section
->size
= TO_SIZE (after
5942 - os
->bfd_section
->vma
);
5945 /* Set section lma. */
5948 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, false);
5952 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
5953 os
->bfd_section
->lma
= lma
;
5955 else if (os
->lma_region
!= NULL
)
5957 bfd_vma lma
= os
->lma_region
->current
;
5959 if (os
->align_lma_with_input
)
5963 /* When LMA_REGION is the same as REGION, align the LMA
5964 as we did for the VMA, possibly including alignment
5965 from the bfd section. If a different region, then
5966 only align according to the value in the output
5968 if (os
->lma_region
!= os
->region
)
5969 section_alignment
= exp_get_power (os
->section_alignment
,
5970 "section alignment");
5971 if (section_alignment
> 0)
5972 lma
= align_power (lma
, section_alignment
);
5974 os
->bfd_section
->lma
= lma
;
5976 else if (r
->last_os
!= NULL
5977 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5982 last
= r
->last_os
->output_section_statement
.bfd_section
;
5984 /* A backwards move of dot should be accompanied by
5985 an explicit assignment to the section LMA (ie.
5986 os->load_base set) because backwards moves can
5987 create overlapping LMAs. */
5989 && os
->bfd_section
->size
!= 0
5990 && dot
+ TO_ADDR (os
->bfd_section
->size
) <= last
->vma
)
5992 /* If dot moved backwards then leave lma equal to
5993 vma. This is the old default lma, which might
5994 just happen to work when the backwards move is
5995 sufficiently large. Nag if this changes anything,
5996 so people can fix their linker scripts. */
5998 if (last
->vma
!= last
->lma
)
5999 einfo (_("%P: warning: dot moved backwards "
6000 "before `%s'\n"), os
->name
);
6004 /* If this is an overlay, set the current lma to that
6005 at the end of the previous section. */
6006 if (os
->sectype
== overlay_section
)
6007 lma
= last
->lma
+ TO_ADDR (last
->size
);
6009 /* Otherwise, keep the same lma to vma relationship
6010 as the previous section. */
6012 lma
= os
->bfd_section
->vma
+ last
->lma
- last
->vma
;
6014 if (section_alignment
> 0)
6015 lma
= align_power (lma
, section_alignment
);
6016 os
->bfd_section
->lma
= lma
;
6019 os
->processed_lma
= true;
6021 /* Keep track of normal sections using the default
6022 lma region. We use this to set the lma for
6023 following sections. Overlays or other linker
6024 script assignment to lma might mean that the
6025 default lma == vma is incorrect.
6026 To avoid warnings about dot moving backwards when using
6027 -Ttext, don't start tracking sections until we find one
6028 of non-zero size or with lma set differently to vma.
6029 Do this tracking before we short-cut the loop so that we
6030 track changes for the case where the section size is zero,
6031 but the lma is set differently to the vma. This is
6032 important, if an orphan section is placed after an
6033 otherwise empty output section that has an explicit lma
6034 set, we want that lma reflected in the orphans lma. */
6035 if (((!IGNORE_SECTION (os
->bfd_section
)
6036 && (os
->bfd_section
->size
!= 0
6037 || (r
->last_os
== NULL
6038 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
6039 || (r
->last_os
!= NULL
6040 && dot
>= (r
->last_os
->output_section_statement
6041 .bfd_section
->vma
))))
6042 || os
->sectype
== first_overlay_section
)
6043 && os
->lma_region
== NULL
6044 && !bfd_link_relocatable (&link_info
))
6047 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
6050 /* .tbss sections effectively have zero size. */
6051 if (!IS_TBSS (os
->bfd_section
)
6052 || bfd_link_relocatable (&link_info
))
6053 dotdelta
= TO_ADDR (os
->bfd_section
->size
);
6058 if (os
->update_dot_tree
!= 0)
6059 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
6061 /* Update dot in the region ?
6062 We only do this if the section is going to be allocated,
6063 since unallocated sections do not contribute to the region's
6064 overall size in memory. */
6065 if (os
->region
!= NULL
6066 && (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)))
6068 os
->region
->current
= dot
;
6071 /* Make sure the new address is within the region. */
6072 os_region_check (os
, os
->region
, os
->addr_tree
,
6073 os
->bfd_section
->vma
);
6075 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
6076 && ((os
->bfd_section
->flags
& SEC_LOAD
)
6077 || os
->align_lma_with_input
))
6079 os
->lma_region
->current
= os
->bfd_section
->lma
+ dotdelta
;
6082 os_region_check (os
, os
->lma_region
, NULL
,
6083 os
->bfd_section
->lma
);
6089 case lang_constructors_statement_enum
:
6090 dot
= lang_size_sections_1 (&constructor_list
.head
,
6091 output_section_statement
,
6092 fill
, dot
, relax
, check_regions
);
6095 case lang_data_statement_enum
:
6097 unsigned int size
= 0;
6099 s
->data_statement
.output_offset
=
6100 dot
- output_section_statement
->bfd_section
->vma
;
6101 s
->data_statement
.output_section
=
6102 output_section_statement
->bfd_section
;
6104 /* We might refer to provided symbols in the expression, and
6105 need to mark them as needed. */
6106 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
6108 switch (s
->data_statement
.type
)
6126 if (size
< TO_SIZE ((unsigned) 1))
6127 size
= TO_SIZE ((unsigned) 1);
6128 dot
+= TO_ADDR (size
);
6129 if (!(output_section_statement
->bfd_section
->flags
6131 output_section_statement
->bfd_section
->size
6132 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
6137 case lang_reloc_statement_enum
:
6141 s
->reloc_statement
.output_offset
=
6142 dot
- output_section_statement
->bfd_section
->vma
;
6143 s
->reloc_statement
.output_section
=
6144 output_section_statement
->bfd_section
;
6145 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
6146 dot
+= TO_ADDR (size
);
6147 if (!(output_section_statement
->bfd_section
->flags
6149 output_section_statement
->bfd_section
->size
6150 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
6154 case lang_wild_statement_enum
:
6155 dot
= lang_size_sections_1 (&s
->wild_statement
.children
.head
,
6156 output_section_statement
,
6157 fill
, dot
, relax
, check_regions
);
6160 case lang_object_symbols_statement_enum
:
6161 link_info
.create_object_symbols_section
6162 = output_section_statement
->bfd_section
;
6163 output_section_statement
->bfd_section
->flags
|= SEC_KEEP
;
6166 case lang_output_statement_enum
:
6167 case lang_target_statement_enum
:
6170 case lang_input_section_enum
:
6174 i
= s
->input_section
.section
;
6179 if (!bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
6180 einfo (_("%F%P: can't relax section: %E\n"));
6184 dot
= size_input_section (prev
, output_section_statement
,
6185 fill
, &removed
, dot
);
6189 case lang_input_statement_enum
:
6192 case lang_fill_statement_enum
:
6193 s
->fill_statement
.output_section
=
6194 output_section_statement
->bfd_section
;
6196 fill
= s
->fill_statement
.fill
;
6199 case lang_assignment_statement_enum
:
6201 bfd_vma newdot
= dot
;
6202 etree_type
*tree
= s
->assignment_statement
.exp
;
6204 expld
.dataseg
.relro
= exp_seg_relro_none
;
6206 exp_fold_tree (tree
,
6207 output_section_statement
->bfd_section
,
6210 ldlang_check_relro_region (s
);
6212 expld
.dataseg
.relro
= exp_seg_relro_none
;
6214 /* This symbol may be relative to this section. */
6215 if ((tree
->type
.node_class
== etree_provided
6216 || tree
->type
.node_class
== etree_assign
)
6217 && (tree
->assign
.dst
[0] != '.'
6218 || tree
->assign
.dst
[1] != '\0'))
6219 output_section_statement
->update_dot
= 1;
6221 if (!output_section_statement
->ignored
)
6223 if (output_section_statement
== abs_output_section
)
6225 /* If we don't have an output section, then just adjust
6226 the default memory address. */
6227 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
6228 false)->current
= newdot
;
6230 else if (newdot
!= dot
)
6232 /* Insert a pad after this statement. We can't
6233 put the pad before when relaxing, in case the
6234 assignment references dot. */
6235 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
6236 output_section_statement
->bfd_section
, dot
);
6238 /* Don't neuter the pad below when relaxing. */
6241 /* If dot is advanced, this implies that the section
6242 should have space allocated to it, unless the
6243 user has explicitly stated that the section
6244 should not be allocated. */
6245 if (output_section_statement
->sectype
!= noalloc_section
6246 && (output_section_statement
->sectype
!= noload_section
6247 || (bfd_get_flavour (link_info
.output_bfd
)
6248 == bfd_target_elf_flavour
)))
6249 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
6256 case lang_padding_statement_enum
:
6257 /* If this is the first time lang_size_sections is called,
6258 we won't have any padding statements. If this is the
6259 second or later passes when relaxing, we should allow
6260 padding to shrink. If padding is needed on this pass, it
6261 will be added back in. */
6262 s
->padding_statement
.size
= 0;
6264 /* Make sure output_offset is valid. If relaxation shrinks
6265 the section and this pad isn't needed, it's possible to
6266 have output_offset larger than the final size of the
6267 section. bfd_set_section_contents will complain even for
6268 a pad size of zero. */
6269 s
->padding_statement
.output_offset
6270 = dot
- output_section_statement
->bfd_section
->vma
;
6273 case lang_group_statement_enum
:
6274 dot
= lang_size_sections_1 (&s
->group_statement
.children
.head
,
6275 output_section_statement
,
6276 fill
, dot
, relax
, check_regions
);
6279 case lang_insert_statement_enum
:
6282 /* We can only get here when relaxing is turned on. */
6283 case lang_address_statement_enum
:
6291 /* If an input section doesn't fit in the current output
6292 section, remove it from the list. Handle the case where we
6293 have to remove an input_section statement here: there is a
6294 special case to remove the first element of the list. */
6295 if (link_info
.non_contiguous_regions
&& removed
)
6297 /* If we removed the first element during the previous
6298 iteration, override the loop assignment of prev_s. */
6304 /* If there was a real previous input section, just skip
6306 prev_s
->header
.next
=s
->header
.next
;
6308 removed_prev_s
= false;
6312 /* Remove the first input section of the list. */
6313 *prev
= s
->header
.next
;
6314 removed_prev_s
= true;
6317 /* Move to next element, unless we removed the head of the
6319 if (!removed_prev_s
)
6320 prev
= &s
->header
.next
;
6324 prev
= &s
->header
.next
;
6325 removed_prev_s
= false;
6331 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
6332 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
6333 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
6334 segments. We are allowed an opportunity to override this decision. */
6337 ldlang_override_segment_assignment (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6338 bfd
*abfd ATTRIBUTE_UNUSED
,
6339 asection
*current_section
,
6340 asection
*previous_section
,
6343 lang_output_section_statement_type
*cur
;
6344 lang_output_section_statement_type
*prev
;
6346 /* The checks below are only necessary when the BFD library has decided
6347 that the two sections ought to be placed into the same segment. */
6351 /* Paranoia checks. */
6352 if (current_section
== NULL
|| previous_section
== NULL
)
6355 /* If this flag is set, the target never wants code and non-code
6356 sections comingled in the same segment. */
6357 if (config
.separate_code
6358 && ((current_section
->flags
^ previous_section
->flags
) & SEC_CODE
))
6361 /* Find the memory regions associated with the two sections.
6362 We call lang_output_section_find() here rather than scanning the list
6363 of output sections looking for a matching section pointer because if
6364 we have a large number of sections then a hash lookup is faster. */
6365 cur
= lang_output_section_find (current_section
->name
);
6366 prev
= lang_output_section_find (previous_section
->name
);
6368 /* More paranoia. */
6369 if (cur
== NULL
|| prev
== NULL
)
6372 /* If the regions are different then force the sections to live in
6373 different segments. See the email thread starting at the following
6374 URL for the reasons why this is necessary:
6375 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
6376 return cur
->region
!= prev
->region
;
6380 one_lang_size_sections_pass (bool *relax
, bool check_regions
)
6382 lang_statement_iteration
++;
6383 if (expld
.phase
!= lang_mark_phase_enum
)
6384 lang_sizing_iteration
++;
6385 lang_size_sections_1 (&statement_list
.head
, abs_output_section
,
6386 0, 0, relax
, check_regions
);
6390 lang_size_segment (void)
6392 /* If XXX_SEGMENT_ALIGN XXX_SEGMENT_END pair was seen, check whether
6393 a page could be saved in the data segment. */
6394 seg_align_type
*seg
= &expld
.dataseg
;
6395 bfd_vma first
, last
;
6397 first
= -seg
->base
& (seg
->commonpagesize
- 1);
6398 last
= seg
->end
& (seg
->commonpagesize
- 1);
6400 && ((seg
->base
& ~(seg
->commonpagesize
- 1))
6401 != (seg
->end
& ~(seg
->commonpagesize
- 1)))
6402 && first
+ last
<= seg
->commonpagesize
)
6404 seg
->phase
= exp_seg_adjust
;
6408 seg
->phase
= exp_seg_done
;
6413 lang_size_relro_segment_1 (void)
6415 seg_align_type
*seg
= &expld
.dataseg
;
6416 bfd_vma relro_end
, desired_end
;
6419 /* Compute the expected PT_GNU_RELRO/PT_LOAD segment end. */
6420 relro_end
= (seg
->relro_end
+ seg
->relropagesize
- 1) & -seg
->relropagesize
;
6422 /* Adjust by the offset arg of XXX_SEGMENT_RELRO_END. */
6423 desired_end
= relro_end
- seg
->relro_offset
;
6425 /* For sections in the relro segment.. */
6426 for (sec
= link_info
.output_bfd
->section_last
; sec
; sec
= sec
->prev
)
6427 if ((sec
->flags
& SEC_ALLOC
) != 0
6428 && sec
->vma
>= seg
->base
6429 && sec
->vma
< seg
->relro_end
- seg
->relro_offset
)
6431 /* Where do we want to put this section so that it ends as
6433 bfd_vma start
, end
, bump
;
6435 end
= start
= sec
->vma
;
6437 end
+= TO_ADDR (sec
->size
);
6438 bump
= desired_end
- end
;
6439 /* We'd like to increase START by BUMP, but we must heed
6440 alignment so the increase might be less than optimum. */
6442 start
&= ~(((bfd_vma
) 1 << sec
->alignment_power
) - 1);
6443 /* This is now the desired end for the previous section. */
6444 desired_end
= start
;
6447 seg
->phase
= exp_seg_relro_adjust
;
6448 ASSERT (desired_end
>= seg
->base
);
6449 seg
->base
= desired_end
;
6454 lang_size_relro_segment (bool *relax
, bool check_regions
)
6456 bool do_reset
= false;
6458 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
6460 bfd_vma data_initial_base
= expld
.dataseg
.base
;
6461 bfd_vma data_relro_end
= lang_size_relro_segment_1 ();
6463 lang_reset_memory_regions ();
6464 one_lang_size_sections_pass (relax
, check_regions
);
6466 /* Assignments to dot, or to output section address in a user
6467 script have increased padding over the original. Revert. */
6468 if (expld
.dataseg
.relro_end
> data_relro_end
)
6470 expld
.dataseg
.base
= data_initial_base
;
6474 else if (lang_size_segment ())
6481 lang_size_sections (bool *relax
, bool check_regions
)
6483 expld
.phase
= lang_allocating_phase_enum
;
6484 expld
.dataseg
.phase
= exp_seg_none
;
6486 one_lang_size_sections_pass (relax
, check_regions
);
6488 if (expld
.dataseg
.phase
!= exp_seg_end_seen
)
6489 expld
.dataseg
.phase
= exp_seg_done
;
6491 if (expld
.dataseg
.phase
== exp_seg_end_seen
)
6494 = lang_size_relro_segment (relax
, check_regions
);
6498 lang_reset_memory_regions ();
6499 one_lang_size_sections_pass (relax
, check_regions
);
6502 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
6504 link_info
.relro_start
= expld
.dataseg
.base
;
6505 link_info
.relro_end
= expld
.dataseg
.relro_end
;
6510 static lang_output_section_statement_type
*current_section
;
6511 static lang_assignment_statement_type
*current_assign
;
6512 static bool prefer_next_section
;
6514 /* Worker function for lang_do_assignments. Recursiveness goes here. */
6517 lang_do_assignments_1 (lang_statement_union_type
*s
,
6518 lang_output_section_statement_type
*current_os
,
6523 for (; s
!= NULL
; s
= s
->header
.next
)
6525 switch (s
->header
.type
)
6527 case lang_constructors_statement_enum
:
6528 dot
= lang_do_assignments_1 (constructor_list
.head
,
6529 current_os
, fill
, dot
, found_end
);
6532 case lang_output_section_statement_enum
:
6534 lang_output_section_statement_type
*os
;
6537 os
= &(s
->output_section_statement
);
6538 os
->after_end
= *found_end
;
6539 init_opb (os
->bfd_section
);
6541 if (os
->bfd_section
!= NULL
)
6543 if (!os
->ignored
&& (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
6545 current_section
= os
;
6546 prefer_next_section
= false;
6548 newdot
= os
->bfd_section
->vma
;
6550 newdot
= lang_do_assignments_1 (os
->children
.head
,
6551 os
, os
->fill
, newdot
, found_end
);
6554 if (os
->bfd_section
!= NULL
)
6556 newdot
= os
->bfd_section
->vma
;
6558 /* .tbss sections effectively have zero size. */
6559 if (!IS_TBSS (os
->bfd_section
)
6560 || bfd_link_relocatable (&link_info
))
6561 newdot
+= TO_ADDR (os
->bfd_section
->size
);
6563 if (os
->update_dot_tree
!= NULL
)
6564 exp_fold_tree (os
->update_dot_tree
,
6565 bfd_abs_section_ptr
, &newdot
);
6572 case lang_wild_statement_enum
:
6574 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
6575 current_os
, fill
, dot
, found_end
);
6578 case lang_object_symbols_statement_enum
:
6579 case lang_output_statement_enum
:
6580 case lang_target_statement_enum
:
6583 case lang_data_statement_enum
:
6584 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
6585 if (expld
.result
.valid_p
)
6587 s
->data_statement
.value
= expld
.result
.value
;
6588 if (expld
.result
.section
!= NULL
)
6589 s
->data_statement
.value
+= expld
.result
.section
->vma
;
6591 else if (expld
.phase
== lang_final_phase_enum
)
6592 einfo (_("%F%P: invalid data statement\n"));
6595 switch (s
->data_statement
.type
)
6613 if (size
< TO_SIZE ((unsigned) 1))
6614 size
= TO_SIZE ((unsigned) 1);
6615 dot
+= TO_ADDR (size
);
6619 case lang_reloc_statement_enum
:
6620 exp_fold_tree (s
->reloc_statement
.addend_exp
,
6621 bfd_abs_section_ptr
, &dot
);
6622 if (expld
.result
.valid_p
)
6623 s
->reloc_statement
.addend_value
= expld
.result
.value
;
6624 else if (expld
.phase
== lang_final_phase_enum
)
6625 einfo (_("%F%P: invalid reloc statement\n"));
6626 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
6629 case lang_input_section_enum
:
6631 asection
*in
= s
->input_section
.section
;
6633 if ((in
->flags
& SEC_EXCLUDE
) == 0)
6634 dot
+= TO_ADDR (in
->size
);
6638 case lang_input_statement_enum
:
6641 case lang_fill_statement_enum
:
6642 fill
= s
->fill_statement
.fill
;
6645 case lang_assignment_statement_enum
:
6646 current_assign
= &s
->assignment_statement
;
6647 if (current_assign
->exp
->type
.node_class
!= etree_assert
)
6649 const char *p
= current_assign
->exp
->assign
.dst
;
6651 if (current_os
== abs_output_section
&& p
[0] == '.' && p
[1] == 0)
6652 prefer_next_section
= true;
6656 if (strcmp (p
, "end") == 0)
6659 exp_fold_tree (s
->assignment_statement
.exp
,
6660 (current_os
->bfd_section
!= NULL
6661 ? current_os
->bfd_section
: bfd_und_section_ptr
),
6665 case lang_padding_statement_enum
:
6666 dot
+= TO_ADDR (s
->padding_statement
.size
);
6669 case lang_group_statement_enum
:
6670 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
6671 current_os
, fill
, dot
, found_end
);
6674 case lang_insert_statement_enum
:
6677 case lang_address_statement_enum
:
6689 lang_do_assignments (lang_phase_type phase
)
6691 bool found_end
= false;
6693 current_section
= NULL
;
6694 prefer_next_section
= false;
6695 expld
.phase
= phase
;
6696 lang_statement_iteration
++;
6697 lang_do_assignments_1 (statement_list
.head
,
6698 abs_output_section
, NULL
, 0, &found_end
);
6701 /* For an assignment statement outside of an output section statement,
6702 choose the best of neighbouring output sections to use for values
6706 section_for_dot (void)
6710 /* Assignments belong to the previous output section, unless there
6711 has been an assignment to "dot", in which case following
6712 assignments belong to the next output section. (The assumption
6713 is that an assignment to "dot" is setting up the address for the
6714 next output section.) Except that past the assignment to "_end"
6715 we always associate with the previous section. This exception is
6716 for targets like SH that define an alloc .stack or other
6717 weirdness after non-alloc sections. */
6718 if (current_section
== NULL
|| prefer_next_section
)
6720 lang_statement_union_type
*stmt
;
6721 lang_output_section_statement_type
*os
;
6723 for (stmt
= (lang_statement_union_type
*) current_assign
;
6725 stmt
= stmt
->header
.next
)
6726 if (stmt
->header
.type
== lang_output_section_statement_enum
)
6729 os
= stmt
? &stmt
->output_section_statement
: NULL
;
6732 && (os
->bfd_section
== NULL
6733 || (os
->bfd_section
->flags
& SEC_EXCLUDE
) != 0
6734 || bfd_section_removed_from_list (link_info
.output_bfd
,
6738 if (current_section
== NULL
|| os
== NULL
|| !os
->after_end
)
6741 s
= os
->bfd_section
;
6743 s
= link_info
.output_bfd
->section_last
;
6745 && ((s
->flags
& SEC_ALLOC
) == 0
6746 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6751 return bfd_abs_section_ptr
;
6755 s
= current_section
->bfd_section
;
6757 /* The section may have been stripped. */
6759 && ((s
->flags
& SEC_EXCLUDE
) != 0
6760 || (s
->flags
& SEC_ALLOC
) == 0
6761 || (s
->flags
& SEC_THREAD_LOCAL
) != 0
6762 || bfd_section_removed_from_list (link_info
.output_bfd
, s
)))
6765 s
= link_info
.output_bfd
->sections
;
6767 && ((s
->flags
& SEC_ALLOC
) == 0
6768 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6773 return bfd_abs_section_ptr
;
6776 /* Array of __start/__stop/.startof./.sizeof/ symbols. */
6778 static struct bfd_link_hash_entry
**start_stop_syms
;
6779 static size_t start_stop_count
= 0;
6780 static size_t start_stop_alloc
= 0;
6782 /* Give start/stop SYMBOL for SEC a preliminary definition, and add it
6783 to start_stop_syms. */
6786 lang_define_start_stop (const char *symbol
, asection
*sec
)
6788 struct bfd_link_hash_entry
*h
;
6790 h
= bfd_define_start_stop (link_info
.output_bfd
, &link_info
, symbol
, sec
);
6793 if (start_stop_count
== start_stop_alloc
)
6795 start_stop_alloc
= 2 * start_stop_alloc
+ 10;
6797 = xrealloc (start_stop_syms
,
6798 start_stop_alloc
* sizeof (*start_stop_syms
));
6800 start_stop_syms
[start_stop_count
++] = h
;
6804 /* Check for input sections whose names match references to
6805 __start_SECNAME or __stop_SECNAME symbols. Give the symbols
6806 preliminary definitions. */
6809 lang_init_start_stop (void)
6813 char leading_char
= bfd_get_symbol_leading_char (link_info
.output_bfd
);
6815 for (abfd
= link_info
.input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6816 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6819 const char *secname
= s
->name
;
6821 for (ps
= secname
; *ps
!= '\0'; ps
++)
6822 if (!ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
6826 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6828 symbol
[0] = leading_char
;
6829 sprintf (symbol
+ (leading_char
!= 0), "__start_%s", secname
);
6830 lang_define_start_stop (symbol
, s
);
6832 symbol
[1] = leading_char
;
6833 memcpy (symbol
+ 1 + (leading_char
!= 0), "__stop", 6);
6834 lang_define_start_stop (symbol
+ 1, s
);
6841 /* Iterate over start_stop_syms. */
6844 foreach_start_stop (void (*func
) (struct bfd_link_hash_entry
*))
6848 for (i
= 0; i
< start_stop_count
; ++i
)
6849 func (start_stop_syms
[i
]);
6852 /* __start and __stop symbols are only supposed to be defined by the
6853 linker for orphan sections, but we now extend that to sections that
6854 map to an output section of the same name. The symbols were
6855 defined early for --gc-sections, before we mapped input to output
6856 sections, so undo those that don't satisfy this rule. */
6859 undef_start_stop (struct bfd_link_hash_entry
*h
)
6861 if (h
->ldscript_def
)
6864 if (h
->u
.def
.section
->output_section
== NULL
6865 || h
->u
.def
.section
->output_section
->owner
!= link_info
.output_bfd
6866 || strcmp (h
->u
.def
.section
->name
,
6867 h
->u
.def
.section
->output_section
->name
) != 0)
6869 asection
*sec
= bfd_get_section_by_name (link_info
.output_bfd
,
6870 h
->u
.def
.section
->name
);
6873 /* When there are more than one input sections with the same
6874 section name, SECNAME, linker picks the first one to define
6875 __start_SECNAME and __stop_SECNAME symbols. When the first
6876 input section is removed by comdat group, we need to check
6877 if there is still an output section with section name
6880 for (i
= sec
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
6881 if (strcmp (h
->u
.def
.section
->name
, i
->name
) == 0)
6883 h
->u
.def
.section
= i
;
6887 h
->type
= bfd_link_hash_undefined
;
6888 h
->u
.undef
.abfd
= NULL
;
6889 if (is_elf_hash_table (link_info
.hash
))
6891 const struct elf_backend_data
*bed
;
6892 struct elf_link_hash_entry
*eh
= (struct elf_link_hash_entry
*) h
;
6893 unsigned int was_forced
= eh
->forced_local
;
6895 bed
= get_elf_backend_data (link_info
.output_bfd
);
6896 (*bed
->elf_backend_hide_symbol
) (&link_info
, eh
, true);
6897 if (!eh
->ref_regular_nonweak
)
6898 h
->type
= bfd_link_hash_undefweak
;
6899 eh
->def_regular
= 0;
6900 eh
->forced_local
= was_forced
;
6906 lang_undef_start_stop (void)
6908 foreach_start_stop (undef_start_stop
);
6911 /* Check for output sections whose names match references to
6912 .startof.SECNAME or .sizeof.SECNAME symbols. Give the symbols
6913 preliminary definitions. */
6916 lang_init_startof_sizeof (void)
6920 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6922 const char *secname
= s
->name
;
6923 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6925 sprintf (symbol
, ".startof.%s", secname
);
6926 lang_define_start_stop (symbol
, s
);
6928 memcpy (symbol
+ 1, ".size", 5);
6929 lang_define_start_stop (symbol
+ 1, s
);
6934 /* Set .startof., .sizeof., __start and __stop symbols final values. */
6937 set_start_stop (struct bfd_link_hash_entry
*h
)
6940 || h
->type
!= bfd_link_hash_defined
)
6943 if (h
->root
.string
[0] == '.')
6945 /* .startof. or .sizeof. symbol.
6946 .startof. already has final value. */
6947 if (h
->root
.string
[2] == 'i')
6950 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6951 h
->u
.def
.section
= bfd_abs_section_ptr
;
6956 /* __start or __stop symbol. */
6957 int has_lead
= bfd_get_symbol_leading_char (link_info
.output_bfd
) != 0;
6959 h
->u
.def
.section
= h
->u
.def
.section
->output_section
;
6960 if (h
->root
.string
[4 + has_lead
] == 'o')
6963 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6969 lang_finalize_start_stop (void)
6971 foreach_start_stop (set_start_stop
);
6975 lang_symbol_tweaks (void)
6977 /* Give initial values for __start and __stop symbols, so that ELF
6978 gc_sections will keep sections referenced by these symbols. Must
6979 be done before lang_do_assignments. */
6980 if (config
.build_constructors
)
6981 lang_init_start_stop ();
6983 /* Make __ehdr_start hidden, and set def_regular even though it is
6984 likely undefined at this stage. For lang_check_relocs. */
6985 if (is_elf_hash_table (link_info
.hash
)
6986 && !bfd_link_relocatable (&link_info
))
6988 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*)
6989 bfd_link_hash_lookup (link_info
.hash
, "__ehdr_start",
6990 false, false, true);
6992 /* Only adjust the export class if the symbol was referenced
6993 and not defined, otherwise leave it alone. */
6995 && (h
->root
.type
== bfd_link_hash_new
6996 || h
->root
.type
== bfd_link_hash_undefined
6997 || h
->root
.type
== bfd_link_hash_undefweak
6998 || h
->root
.type
== bfd_link_hash_common
))
7000 const struct elf_backend_data
*bed
;
7001 bed
= get_elf_backend_data (link_info
.output_bfd
);
7002 (*bed
->elf_backend_hide_symbol
) (&link_info
, h
, true);
7003 if (ELF_ST_VISIBILITY (h
->other
) != STV_INTERNAL
)
7004 h
->other
= (h
->other
& ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN
;
7006 h
->root
.linker_def
= 1;
7007 h
->root
.rel_from_abs
= 1;
7015 struct bfd_link_hash_entry
*h
;
7018 if ((bfd_link_relocatable (&link_info
) && !link_info
.gc_sections
)
7019 || bfd_link_dll (&link_info
))
7020 warn
= entry_from_cmdline
;
7024 /* Force the user to specify a root when generating a relocatable with
7025 --gc-sections, unless --gc-keep-exported was also given. */
7026 if (bfd_link_relocatable (&link_info
)
7027 && link_info
.gc_sections
7028 && !link_info
.gc_keep_exported
)
7030 struct bfd_sym_chain
*sym
;
7032 for (sym
= link_info
.gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
7034 h
= bfd_link_hash_lookup (link_info
.hash
, sym
->name
,
7035 false, false, false);
7037 && (h
->type
== bfd_link_hash_defined
7038 || h
->type
== bfd_link_hash_defweak
)
7039 && !bfd_is_const_section (h
->u
.def
.section
))
7043 einfo (_("%F%P: --gc-sections requires a defined symbol root "
7044 "specified by -e or -u\n"));
7047 if (entry_symbol
.name
== NULL
)
7049 /* No entry has been specified. Look for the default entry, but
7050 don't warn if we don't find it. */
7051 entry_symbol
.name
= entry_symbol_default
;
7055 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
7056 false, false, true);
7058 && (h
->type
== bfd_link_hash_defined
7059 || h
->type
== bfd_link_hash_defweak
)
7060 && h
->u
.def
.section
->output_section
!= NULL
)
7064 val
= (h
->u
.def
.value
7065 + bfd_section_vma (h
->u
.def
.section
->output_section
)
7066 + h
->u
.def
.section
->output_offset
);
7067 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
7068 einfo (_("%F%P: %s: can't set start address\n"), entry_symbol
.name
);
7075 /* We couldn't find the entry symbol. Try parsing it as a
7077 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
7080 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
7081 einfo (_("%F%P: can't set start address\n"));
7083 /* BZ 2004952: Only use the start of the entry section for executables. */
7084 else if bfd_link_executable (&link_info
)
7088 /* Can't find the entry symbol, and it's not a number. Use
7089 the first address in the text section. */
7090 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
7094 einfo (_("%P: warning: cannot find entry symbol %s;"
7095 " defaulting to %V\n"),
7097 bfd_section_vma (ts
));
7098 if (!bfd_set_start_address (link_info
.output_bfd
,
7099 bfd_section_vma (ts
)))
7100 einfo (_("%F%P: can't set start address\n"));
7105 einfo (_("%P: warning: cannot find entry symbol %s;"
7106 " not setting start address\n"),
7113 einfo (_("%P: warning: cannot find entry symbol %s;"
7114 " not setting start address\n"),
7120 /* This is a small function used when we want to ignore errors from
7124 ignore_bfd_errors (const char *fmt ATTRIBUTE_UNUSED
,
7125 va_list ap ATTRIBUTE_UNUSED
)
7127 /* Don't do anything. */
7130 /* Check that the architecture of all the input files is compatible
7131 with the output file. Also call the backend to let it do any
7132 other checking that is needed. */
7137 lang_input_statement_type
*file
;
7139 const bfd_arch_info_type
*compatible
;
7141 for (file
= (void *) file_chain
.head
;
7145 #if BFD_SUPPORTS_PLUGINS
7146 /* Don't check format of files claimed by plugin. */
7147 if (file
->flags
.claimed
)
7149 #endif /* BFD_SUPPORTS_PLUGINS */
7150 input_bfd
= file
->the_bfd
;
7152 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
7153 command_line
.accept_unknown_input_arch
);
7155 /* In general it is not possible to perform a relocatable
7156 link between differing object formats when the input
7157 file has relocations, because the relocations in the
7158 input format may not have equivalent representations in
7159 the output format (and besides BFD does not translate
7160 relocs for other link purposes than a final link). */
7161 if (!file
->flags
.just_syms
7162 && (bfd_link_relocatable (&link_info
)
7163 || link_info
.emitrelocations
)
7164 && (compatible
== NULL
7165 || (bfd_get_flavour (input_bfd
)
7166 != bfd_get_flavour (link_info
.output_bfd
)))
7167 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
7169 einfo (_("%F%P: relocatable linking with relocations from"
7170 " format %s (%pB) to format %s (%pB) is not supported\n"),
7171 bfd_get_target (input_bfd
), input_bfd
,
7172 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
7173 /* einfo with %F exits. */
7176 if (compatible
== NULL
)
7178 if (command_line
.warn_mismatch
)
7179 einfo (_("%X%P: %s architecture of input file `%pB'"
7180 " is incompatible with %s output\n"),
7181 bfd_printable_name (input_bfd
), input_bfd
,
7182 bfd_printable_name (link_info
.output_bfd
));
7185 /* If the input bfd has no contents, it shouldn't set the
7186 private data of the output bfd. */
7187 else if (!file
->flags
.just_syms
7188 && ((input_bfd
->flags
& DYNAMIC
) != 0
7189 || bfd_count_sections (input_bfd
) != 0))
7191 bfd_error_handler_type pfn
= NULL
;
7193 /* If we aren't supposed to warn about mismatched input
7194 files, temporarily set the BFD error handler to a
7195 function which will do nothing. We still want to call
7196 bfd_merge_private_bfd_data, since it may set up
7197 information which is needed in the output file. */
7198 if (!command_line
.warn_mismatch
)
7199 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
7200 if (!bfd_merge_private_bfd_data (input_bfd
, &link_info
))
7202 if (command_line
.warn_mismatch
)
7203 einfo (_("%X%P: failed to merge target specific data"
7204 " of file %pB\n"), input_bfd
);
7206 if (!command_line
.warn_mismatch
)
7207 bfd_set_error_handler (pfn
);
7212 /* Look through all the global common symbols and attach them to the
7213 correct section. The -sort-common command line switch may be used
7214 to roughly sort the entries by alignment. */
7219 if (link_info
.inhibit_common_definition
)
7221 if (bfd_link_relocatable (&link_info
)
7222 && !command_line
.force_common_definition
)
7225 if (!config
.sort_common
)
7226 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
7231 if (config
.sort_common
== sort_descending
)
7233 for (power
= 4; power
> 0; power
--)
7234 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7237 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7241 for (power
= 0; power
<= 4; power
++)
7242 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7244 power
= (unsigned int) -1;
7245 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7250 /* Place one common symbol in the correct section. */
7253 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
7255 unsigned int power_of_two
;
7259 if (h
->type
!= bfd_link_hash_common
)
7263 power_of_two
= h
->u
.c
.p
->alignment_power
;
7265 if (config
.sort_common
== sort_descending
7266 && power_of_two
< *(unsigned int *) info
)
7268 else if (config
.sort_common
== sort_ascending
7269 && power_of_two
> *(unsigned int *) info
)
7272 section
= h
->u
.c
.p
->section
;
7273 if (!bfd_define_common_symbol (link_info
.output_bfd
, &link_info
, h
))
7274 einfo (_("%F%P: could not define common symbol `%pT': %E\n"),
7277 if (config
.map_file
!= NULL
)
7279 static bool header_printed
;
7284 if (!header_printed
)
7286 minfo (_("\nAllocating common symbols\n"));
7287 minfo (_("Common symbol size file\n\n"));
7288 header_printed
= true;
7291 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
7292 DMGL_ANSI
| DMGL_PARAMS
);
7295 minfo ("%s", h
->root
.string
);
7296 len
= strlen (h
->root
.string
);
7301 len
= strlen (name
);
7317 if (size
<= 0xffffffff)
7318 sprintf (buf
, "%lx", (unsigned long) size
);
7320 sprintf_vma (buf
, size
);
7330 minfo ("%pB\n", section
->owner
);
7336 /* Handle a single orphan section S, placing the orphan into an appropriate
7337 output section. The effects of the --orphan-handling command line
7338 option are handled here. */
7341 ldlang_place_orphan (asection
*s
)
7343 if (config
.orphan_handling
== orphan_handling_discard
)
7345 lang_output_section_statement_type
*os
;
7346 os
= lang_output_section_statement_lookup (DISCARD_SECTION_NAME
, 0, 1);
7347 if (os
->addr_tree
== NULL
7348 && (bfd_link_relocatable (&link_info
)
7349 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
7350 os
->addr_tree
= exp_intop (0);
7351 lang_add_section (&os
->children
, s
, NULL
, NULL
, os
);
7355 lang_output_section_statement_type
*os
;
7356 const char *name
= s
->name
;
7359 if (config
.orphan_handling
== orphan_handling_error
)
7360 einfo (_("%X%P: error: unplaced orphan section `%pA' from `%pB'\n"),
7363 if (config
.unique_orphan_sections
|| unique_section_p (s
, NULL
))
7364 constraint
= SPECIAL
;
7366 os
= ldemul_place_orphan (s
, name
, constraint
);
7369 os
= lang_output_section_statement_lookup (name
, constraint
, 1);
7370 if (os
->addr_tree
== NULL
7371 && (bfd_link_relocatable (&link_info
)
7372 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
7373 os
->addr_tree
= exp_intop (0);
7374 lang_add_section (&os
->children
, s
, NULL
, NULL
, os
);
7377 if (config
.orphan_handling
== orphan_handling_warn
)
7378 einfo (_("%P: warning: orphan section `%pA' from `%pB' being "
7379 "placed in section `%s'\n"),
7380 s
, s
->owner
, os
->name
);
7384 /* Run through the input files and ensure that every input section has
7385 somewhere to go. If one is found without a destination then create
7386 an input request and place it into the statement tree. */
7389 lang_place_orphans (void)
7391 LANG_FOR_EACH_INPUT_STATEMENT (file
)
7395 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
7397 if (s
->output_section
== NULL
)
7399 /* This section of the file is not attached, root
7400 around for a sensible place for it to go. */
7402 if (file
->flags
.just_syms
)
7403 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
7404 else if (lang_discard_section_p (s
))
7405 s
->output_section
= bfd_abs_section_ptr
;
7406 else if (strcmp (s
->name
, "COMMON") == 0)
7408 /* This is a lonely common section which must have
7409 come from an archive. We attach to the section
7410 with the wildcard. */
7411 if (!bfd_link_relocatable (&link_info
)
7412 || command_line
.force_common_definition
)
7414 if (default_common_section
== NULL
)
7415 default_common_section
7416 = lang_output_section_statement_lookup (".bss", 0, 1);
7417 lang_add_section (&default_common_section
->children
, s
,
7418 NULL
, NULL
, default_common_section
);
7422 ldlang_place_orphan (s
);
7429 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
7431 flagword
*ptr_flags
;
7433 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
7439 /* PR 17900: An exclamation mark in the attributes reverses
7440 the sense of any of the attributes that follow. */
7443 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
7447 *ptr_flags
|= SEC_ALLOC
;
7451 *ptr_flags
|= SEC_READONLY
;
7455 *ptr_flags
|= SEC_DATA
;
7459 *ptr_flags
|= SEC_CODE
;
7464 *ptr_flags
|= SEC_LOAD
;
7468 einfo (_("%F%P: invalid character %c (%d) in flags\n"),
7476 /* Call a function on each real input file. This function will be
7477 called on an archive, but not on the elements. */
7480 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
7482 lang_input_statement_type
*f
;
7484 for (f
= (void *) input_file_chain
.head
;
7486 f
= f
->next_real_file
)
7491 /* Call a function on each real file. The function will be called on
7492 all the elements of an archive which are included in the link, but
7493 will not be called on the archive file itself. */
7496 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
7498 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7506 ldlang_add_file (lang_input_statement_type
*entry
)
7508 lang_statement_append (&file_chain
, entry
, &entry
->next
);
7510 /* The BFD linker needs to have a list of all input BFDs involved in
7512 ASSERT (link_info
.input_bfds_tail
!= &entry
->the_bfd
->link
.next
7513 && entry
->the_bfd
->link
.next
== NULL
);
7514 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
7516 *link_info
.input_bfds_tail
= entry
->the_bfd
;
7517 link_info
.input_bfds_tail
= &entry
->the_bfd
->link
.next
;
7518 bfd_set_usrdata (entry
->the_bfd
, entry
);
7519 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
7521 /* Look through the sections and check for any which should not be
7522 included in the link. We need to do this now, so that we can
7523 notice when the backend linker tries to report multiple
7524 definition errors for symbols which are in sections we aren't
7525 going to link. FIXME: It might be better to entirely ignore
7526 symbols which are defined in sections which are going to be
7527 discarded. This would require modifying the backend linker for
7528 each backend which might set the SEC_LINK_ONCE flag. If we do
7529 this, we should probably handle SEC_EXCLUDE in the same way. */
7531 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
7535 lang_add_output (const char *name
, int from_script
)
7537 /* Make -o on command line override OUTPUT in script. */
7538 if (!had_output_filename
|| !from_script
)
7540 output_filename
= name
;
7541 had_output_filename
= true;
7545 lang_output_section_statement_type
*
7546 lang_enter_output_section_statement (const char *output_section_statement_name
,
7547 etree_type
*address_exp
,
7548 enum section_type sectype
,
7549 etree_type
*sectype_value
,
7551 etree_type
*subalign
,
7554 int align_with_input
)
7556 lang_output_section_statement_type
*os
;
7558 os
= lang_output_section_statement_lookup (output_section_statement_name
,
7560 current_section
= os
;
7562 if (os
->addr_tree
== NULL
)
7564 os
->addr_tree
= address_exp
;
7566 os
->sectype
= sectype
;
7567 if (sectype
== type_section
|| sectype
== typed_readonly_section
)
7568 os
->sectype_value
= sectype_value
;
7569 else if (sectype
== noload_section
)
7570 os
->flags
= SEC_NEVER_LOAD
;
7572 os
->flags
= SEC_NO_FLAGS
;
7573 os
->block_value
= 1;
7575 /* Make next things chain into subchain of this. */
7576 push_stat_ptr (&os
->children
);
7578 os
->align_lma_with_input
= align_with_input
== ALIGN_WITH_INPUT
;
7579 if (os
->align_lma_with_input
&& align
!= NULL
)
7580 einfo (_("%F%P:%pS: error: align with input and explicit align specified\n"),
7583 os
->subsection_alignment
= subalign
;
7584 os
->section_alignment
= align
;
7586 os
->load_base
= ebase
;
7593 lang_output_statement_type
*new_stmt
;
7595 new_stmt
= new_stat (lang_output_statement
, stat_ptr
);
7596 new_stmt
->name
= output_filename
;
7599 /* Reset the current counters in the regions. */
7602 lang_reset_memory_regions (void)
7604 lang_memory_region_type
*p
= lang_memory_region_list
;
7606 lang_output_section_statement_type
*os
;
7608 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
7610 p
->current
= p
->origin
;
7614 for (os
= (void *) lang_os_list
.head
;
7618 os
->processed_vma
= false;
7619 os
->processed_lma
= false;
7622 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
7624 /* Save the last size for possible use by bfd_relax_section. */
7625 o
->rawsize
= o
->size
;
7626 if (!(o
->flags
& SEC_FIXED_SIZE
))
7631 /* Worker for lang_gc_sections_1. */
7634 gc_section_callback (lang_wild_statement_type
*ptr
,
7635 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7637 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7638 void *data ATTRIBUTE_UNUSED
)
7640 /* If the wild pattern was marked KEEP, the member sections
7641 should be as well. */
7642 if (ptr
->keep_sections
)
7643 section
->flags
|= SEC_KEEP
;
7646 /* Iterate over sections marking them against GC. */
7649 lang_gc_sections_1 (lang_statement_union_type
*s
)
7651 for (; s
!= NULL
; s
= s
->header
.next
)
7653 switch (s
->header
.type
)
7655 case lang_wild_statement_enum
:
7656 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
7658 case lang_constructors_statement_enum
:
7659 lang_gc_sections_1 (constructor_list
.head
);
7661 case lang_output_section_statement_enum
:
7662 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
7664 case lang_group_statement_enum
:
7665 lang_gc_sections_1 (s
->group_statement
.children
.head
);
7674 lang_gc_sections (void)
7676 /* Keep all sections so marked in the link script. */
7677 lang_gc_sections_1 (statement_list
.head
);
7679 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
7680 the special case of .stabstr debug info. (See bfd/stabs.c)
7681 Twiddle the flag here, to simplify later linker code. */
7682 if (bfd_link_relocatable (&link_info
))
7684 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7687 #if BFD_SUPPORTS_PLUGINS
7688 if (f
->flags
.claimed
)
7691 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7692 if ((sec
->flags
& SEC_DEBUGGING
) == 0
7693 || strcmp (sec
->name
, ".stabstr") != 0)
7694 sec
->flags
&= ~SEC_EXCLUDE
;
7698 if (link_info
.gc_sections
)
7699 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
7702 /* Worker for lang_find_relro_sections_1. */
7705 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
7706 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7708 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7711 /* Discarded, excluded and ignored sections effectively have zero
7713 if (section
->output_section
!= NULL
7714 && section
->output_section
->owner
== link_info
.output_bfd
7715 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
7716 && !IGNORE_SECTION (section
)
7717 && section
->size
!= 0)
7719 bool *has_relro_section
= (bool *) data
;
7720 *has_relro_section
= true;
7724 /* Iterate over sections for relro sections. */
7727 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
7728 bool *has_relro_section
)
7730 if (*has_relro_section
)
7733 for (; s
!= NULL
; s
= s
->header
.next
)
7735 if (s
== expld
.dataseg
.relro_end_stat
)
7738 switch (s
->header
.type
)
7740 case lang_wild_statement_enum
:
7741 walk_wild (&s
->wild_statement
,
7742 find_relro_section_callback
,
7745 case lang_constructors_statement_enum
:
7746 lang_find_relro_sections_1 (constructor_list
.head
,
7749 case lang_output_section_statement_enum
:
7750 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
7753 case lang_group_statement_enum
:
7754 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
7764 lang_find_relro_sections (void)
7766 bool has_relro_section
= false;
7768 /* Check all sections in the link script. */
7770 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
7771 &has_relro_section
);
7773 if (!has_relro_section
)
7774 link_info
.relro
= false;
7777 /* Relax all sections until bfd_relax_section gives up. */
7780 lang_relax_sections (bool need_layout
)
7782 /* NB: Also enable relaxation to layout sections for DT_RELR. */
7783 if (RELAXATION_ENABLED
|| link_info
.enable_dt_relr
)
7785 /* We may need more than one relaxation pass. */
7786 int i
= link_info
.relax_pass
;
7788 /* The backend can use it to determine the current pass. */
7789 link_info
.relax_pass
= 0;
7793 /* Keep relaxing until bfd_relax_section gives up. */
7796 link_info
.relax_trip
= -1;
7799 link_info
.relax_trip
++;
7801 /* Note: pe-dll.c does something like this also. If you find
7802 you need to change this code, you probably need to change
7803 pe-dll.c also. DJ */
7805 /* Do all the assignments with our current guesses as to
7807 lang_do_assignments (lang_assigning_phase_enum
);
7809 /* We must do this after lang_do_assignments, because it uses
7811 lang_reset_memory_regions ();
7813 /* Perform another relax pass - this time we know where the
7814 globals are, so can make a better guess. */
7815 relax_again
= false;
7816 lang_size_sections (&relax_again
, false);
7818 while (relax_again
);
7820 link_info
.relax_pass
++;
7827 /* Final extra sizing to report errors. */
7828 lang_do_assignments (lang_assigning_phase_enum
);
7829 lang_reset_memory_regions ();
7830 lang_size_sections (NULL
, true);
7834 #if BFD_SUPPORTS_PLUGINS
7835 /* Find the insert point for the plugin's replacement files. We
7836 place them after the first claimed real object file, or if the
7837 first claimed object is an archive member, after the last real
7838 object file immediately preceding the archive. In the event
7839 no objects have been claimed at all, we return the first dummy
7840 object file on the list as the insert point; that works, but
7841 the callee must be careful when relinking the file_chain as it
7842 is not actually on that chain, only the statement_list and the
7843 input_file list; in that case, the replacement files must be
7844 inserted at the head of the file_chain. */
7846 static lang_input_statement_type
*
7847 find_replacements_insert_point (bool *before
)
7849 lang_input_statement_type
*claim1
, *lastobject
;
7850 lastobject
= (void *) input_file_chain
.head
;
7851 for (claim1
= (void *) file_chain
.head
;
7853 claim1
= claim1
->next
)
7855 if (claim1
->flags
.claimed
)
7857 *before
= claim1
->flags
.claim_archive
;
7858 return claim1
->flags
.claim_archive
? lastobject
: claim1
;
7860 /* Update lastobject if this is a real object file. */
7861 if (claim1
->the_bfd
!= NULL
&& claim1
->the_bfd
->my_archive
== NULL
)
7862 lastobject
= claim1
;
7864 /* No files were claimed by the plugin. Choose the last object
7865 file found on the list (maybe the first, dummy entry) as the
7871 /* Find where to insert ADD, an archive element or shared library
7872 added during a rescan. */
7874 static lang_input_statement_type
**
7875 find_rescan_insertion (lang_input_statement_type
*add
)
7877 bfd
*add_bfd
= add
->the_bfd
;
7878 lang_input_statement_type
*f
;
7879 lang_input_statement_type
*last_loaded
= NULL
;
7880 lang_input_statement_type
*before
= NULL
;
7881 lang_input_statement_type
**iter
= NULL
;
7883 if (add_bfd
->my_archive
!= NULL
)
7884 add_bfd
= add_bfd
->my_archive
;
7886 /* First look through the input file chain, to find an object file
7887 before the one we've rescanned. Normal object files always
7888 appear on both the input file chain and the file chain, so this
7889 lets us get quickly to somewhere near the correct place on the
7890 file chain if it is full of archive elements. Archives don't
7891 appear on the file chain, but if an element has been extracted
7892 then their input_statement->next points at it. */
7893 for (f
= (void *) input_file_chain
.head
;
7895 f
= f
->next_real_file
)
7897 if (f
->the_bfd
== add_bfd
)
7899 before
= last_loaded
;
7900 if (f
->next
!= NULL
)
7901 return &f
->next
->next
;
7903 if (f
->the_bfd
!= NULL
&& f
->next
!= NULL
)
7907 for (iter
= before
? &before
->next
: &file_chain
.head
->input_statement
.next
;
7909 iter
= &(*iter
)->next
)
7910 if (!(*iter
)->flags
.claim_archive
7911 && (*iter
)->the_bfd
->my_archive
== NULL
)
7917 /* Insert SRCLIST into DESTLIST after given element by chaining
7918 on FIELD as the next-pointer. (Counterintuitively does not need
7919 a pointer to the actual after-node itself, just its chain field.) */
7922 lang_list_insert_after (lang_statement_list_type
*destlist
,
7923 lang_statement_list_type
*srclist
,
7924 lang_statement_union_type
**field
)
7926 *(srclist
->tail
) = *field
;
7927 *field
= srclist
->head
;
7928 if (destlist
->tail
== field
)
7929 destlist
->tail
= srclist
->tail
;
7932 /* Detach new nodes added to DESTLIST since the time ORIGLIST
7933 was taken as a copy of it and leave them in ORIGLIST. */
7936 lang_list_remove_tail (lang_statement_list_type
*destlist
,
7937 lang_statement_list_type
*origlist
)
7939 union lang_statement_union
**savetail
;
7940 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
7941 ASSERT (origlist
->head
== destlist
->head
);
7942 savetail
= origlist
->tail
;
7943 origlist
->head
= *(savetail
);
7944 origlist
->tail
= destlist
->tail
;
7945 destlist
->tail
= savetail
;
7949 static lang_statement_union_type
**
7950 find_next_input_statement (lang_statement_union_type
**s
)
7952 for ( ; *s
; s
= &(*s
)->header
.next
)
7954 lang_statement_union_type
**t
;
7955 switch ((*s
)->header
.type
)
7957 case lang_input_statement_enum
:
7959 case lang_wild_statement_enum
:
7960 t
= &(*s
)->wild_statement
.children
.head
;
7962 case lang_group_statement_enum
:
7963 t
= &(*s
)->group_statement
.children
.head
;
7965 case lang_output_section_statement_enum
:
7966 t
= &(*s
)->output_section_statement
.children
.head
;
7971 t
= find_next_input_statement (t
);
7977 #endif /* BFD_SUPPORTS_PLUGINS */
7979 /* Add NAME to the list of garbage collection entry points. */
7982 lang_add_gc_name (const char *name
)
7984 struct bfd_sym_chain
*sym
;
7989 sym
= stat_alloc (sizeof (*sym
));
7991 sym
->next
= link_info
.gc_sym_list
;
7993 link_info
.gc_sym_list
= sym
;
7996 /* Check relocations. */
7999 lang_check_relocs (void)
8001 if (link_info
.check_relocs_after_open_input
)
8005 for (abfd
= link_info
.input_bfds
;
8006 abfd
!= (bfd
*) NULL
; abfd
= abfd
->link
.next
)
8007 if (!bfd_link_check_relocs (abfd
, &link_info
))
8009 /* No object output, fail return. */
8010 config
.make_executable
= false;
8011 /* Note: we do not abort the loop, but rather
8012 continue the scan in case there are other
8013 bad relocations to report. */
8018 /* Look through all output sections looking for places where we can
8019 propagate forward the lma region. */
8022 lang_propagate_lma_regions (void)
8024 lang_output_section_statement_type
*os
;
8026 for (os
= (void *) lang_os_list
.head
;
8030 if (os
->prev
!= NULL
8031 && os
->lma_region
== NULL
8032 && os
->load_base
== NULL
8033 && os
->addr_tree
== NULL
8034 && os
->region
== os
->prev
->region
)
8035 os
->lma_region
= os
->prev
->lma_region
;
8042 /* Finalize dynamic list. */
8043 if (link_info
.dynamic_list
)
8044 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
8046 current_target
= default_target
;
8048 /* Open the output file. */
8049 lang_for_each_statement (ldlang_open_output
);
8052 ldemul_create_output_section_statements ();
8054 /* Add to the hash table all undefineds on the command line. */
8055 lang_place_undefineds ();
8057 if (!bfd_section_already_linked_table_init ())
8058 einfo (_("%F%P: can not create hash table: %E\n"));
8060 /* A first pass through the memory regions ensures that if any region
8061 references a symbol for its origin or length then this symbol will be
8062 added to the symbol table. Having these symbols in the symbol table
8063 means that when we call open_input_bfds PROVIDE statements will
8064 trigger to provide any needed symbols. The regions origins and
8065 lengths are not assigned as a result of this call. */
8066 lang_do_memory_regions (false);
8068 /* Create a bfd for each input file. */
8069 current_target
= default_target
;
8070 lang_statement_iteration
++;
8071 open_input_bfds (statement_list
.head
, OPEN_BFD_NORMAL
);
8073 /* Now that open_input_bfds has processed assignments and provide
8074 statements we can give values to symbolic origin/length now. */
8075 lang_do_memory_regions (true);
8077 #if BFD_SUPPORTS_PLUGINS
8078 if (link_info
.lto_plugin_active
)
8080 lang_statement_list_type added
;
8081 lang_statement_list_type files
, inputfiles
;
8083 ldemul_before_plugin_all_symbols_read ();
8085 /* Now all files are read, let the plugin(s) decide if there
8086 are any more to be added to the link before we call the
8087 emulation's after_open hook. We create a private list of
8088 input statements for this purpose, which we will eventually
8089 insert into the global statement list after the first claimed
8092 /* We need to manipulate all three chains in synchrony. */
8094 inputfiles
= input_file_chain
;
8095 if (plugin_call_all_symbols_read ())
8096 einfo (_("%F%P: %s: plugin reported error after all symbols read\n"),
8097 plugin_error_plugin ());
8098 link_info
.lto_all_symbols_read
= true;
8099 /* Open any newly added files, updating the file chains. */
8100 plugin_undefs
= link_info
.hash
->undefs_tail
;
8101 open_input_bfds (*added
.tail
, OPEN_BFD_NORMAL
);
8102 if (plugin_undefs
== link_info
.hash
->undefs_tail
)
8103 plugin_undefs
= NULL
;
8104 /* Restore the global list pointer now they have all been added. */
8105 lang_list_remove_tail (stat_ptr
, &added
);
8106 /* And detach the fresh ends of the file lists. */
8107 lang_list_remove_tail (&file_chain
, &files
);
8108 lang_list_remove_tail (&input_file_chain
, &inputfiles
);
8109 /* Were any new files added? */
8110 if (added
.head
!= NULL
)
8112 /* If so, we will insert them into the statement list immediately
8113 after the first input file that was claimed by the plugin,
8114 unless that file was an archive in which case it is inserted
8115 immediately before. */
8117 lang_statement_union_type
**prev
;
8118 plugin_insert
= find_replacements_insert_point (&before
);
8119 /* If a plugin adds input files without having claimed any, we
8120 don't really have a good idea where to place them. Just putting
8121 them at the start or end of the list is liable to leave them
8122 outside the crtbegin...crtend range. */
8123 ASSERT (plugin_insert
!= NULL
);
8124 /* Splice the new statement list into the old one. */
8125 prev
= &plugin_insert
->header
.next
;
8128 prev
= find_next_input_statement (prev
);
8129 if (*prev
!= (void *) plugin_insert
->next_real_file
)
8131 /* We didn't find the expected input statement.
8132 Fall back to adding after plugin_insert. */
8133 prev
= &plugin_insert
->header
.next
;
8136 lang_list_insert_after (stat_ptr
, &added
, prev
);
8137 /* Likewise for the file chains. */
8138 lang_list_insert_after (&input_file_chain
, &inputfiles
,
8139 (void *) &plugin_insert
->next_real_file
);
8140 /* We must be careful when relinking file_chain; we may need to
8141 insert the new files at the head of the list if the insert
8142 point chosen is the dummy first input file. */
8143 if (plugin_insert
->filename
)
8144 lang_list_insert_after (&file_chain
, &files
,
8145 (void *) &plugin_insert
->next
);
8147 lang_list_insert_after (&file_chain
, &files
, &file_chain
.head
);
8149 /* Rescan archives in case new undefined symbols have appeared. */
8151 lang_statement_iteration
++;
8152 open_input_bfds (statement_list
.head
, OPEN_BFD_RESCAN
);
8153 lang_list_remove_tail (&file_chain
, &files
);
8154 while (files
.head
!= NULL
)
8156 lang_input_statement_type
**insert
;
8157 lang_input_statement_type
**iter
, *temp
;
8160 insert
= find_rescan_insertion (&files
.head
->input_statement
);
8161 /* All elements from an archive can be added at once. */
8162 iter
= &files
.head
->input_statement
.next
;
8163 my_arch
= files
.head
->input_statement
.the_bfd
->my_archive
;
8164 if (my_arch
!= NULL
)
8165 for (; *iter
!= NULL
; iter
= &(*iter
)->next
)
8166 if ((*iter
)->the_bfd
->my_archive
!= my_arch
)
8169 *insert
= &files
.head
->input_statement
;
8170 files
.head
= (lang_statement_union_type
*) *iter
;
8172 if (my_arch
!= NULL
)
8174 lang_input_statement_type
*parent
= bfd_usrdata (my_arch
);
8176 parent
->next
= (lang_input_statement_type
*)
8178 - offsetof (lang_input_statement_type
, next
));
8183 #endif /* BFD_SUPPORTS_PLUGINS */
8185 /* Make sure that nobody has tried to add a symbol to this list
8187 ASSERT (link_info
.gc_sym_list
== NULL
);
8189 link_info
.gc_sym_list
= &entry_symbol
;
8191 if (entry_symbol
.name
== NULL
)
8193 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
8195 /* entry_symbol is normally initialied by a ENTRY definition in the
8196 linker script or the -e command line option. But if neither of
8197 these have been used, the target specific backend may still have
8198 provided an entry symbol via a call to lang_default_entry().
8199 Unfortunately this value will not be processed until lang_end()
8200 is called, long after this function has finished. So detect this
8201 case here and add the target's entry symbol to the list of starting
8202 points for garbage collection resolution. */
8203 lang_add_gc_name (entry_symbol_default
);
8206 lang_add_gc_name (link_info
.init_function
);
8207 lang_add_gc_name (link_info
.fini_function
);
8209 ldemul_after_open ();
8210 if (config
.map_file
!= NULL
)
8211 lang_print_asneeded ();
8215 bfd_section_already_linked_table_free ();
8217 /* Make sure that we're not mixing architectures. We call this
8218 after all the input files have been opened, but before we do any
8219 other processing, so that any operations merge_private_bfd_data
8220 does on the output file will be known during the rest of the
8224 /* Handle .exports instead of a version script if we're told to do so. */
8225 if (command_line
.version_exports_section
)
8226 lang_do_version_exports_section ();
8228 /* Build all sets based on the information gathered from the input
8230 ldctor_build_sets ();
8232 lang_symbol_tweaks ();
8234 /* PR 13683: We must rerun the assignments prior to running garbage
8235 collection in order to make sure that all symbol aliases are resolved. */
8236 lang_do_assignments (lang_mark_phase_enum
);
8237 expld
.phase
= lang_first_phase_enum
;
8239 /* Size up the common data. */
8242 /* Remove unreferenced sections if asked to. */
8243 lang_gc_sections ();
8245 lang_mark_undefineds ();
8247 /* Check relocations. */
8248 lang_check_relocs ();
8250 ldemul_after_check_relocs ();
8252 /* Update wild statements. */
8253 update_wild_statements (statement_list
.head
);
8255 /* Run through the contours of the script and attach input sections
8256 to the correct output sections. */
8257 lang_statement_iteration
++;
8258 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
8260 /* Start at the statement immediately after the special abs_section
8261 output statement, so that it isn't reordered. */
8262 process_insert_statements (&lang_os_list
.head
->header
.next
);
8264 ldemul_before_place_orphans ();
8266 /* Find any sections not attached explicitly and handle them. */
8267 lang_place_orphans ();
8269 if (!bfd_link_relocatable (&link_info
))
8273 /* Merge SEC_MERGE sections. This has to be done after GC of
8274 sections, so that GCed sections are not merged, but before
8275 assigning dynamic symbols, since removing whole input sections
8277 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
8279 /* Look for a text section and set the readonly attribute in it. */
8280 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
8284 if (config
.text_read_only
)
8285 found
->flags
|= SEC_READONLY
;
8287 found
->flags
&= ~SEC_READONLY
;
8291 /* Merge together CTF sections. After this, only the symtab-dependent
8292 function and data object sections need adjustment. */
8295 /* Emit the CTF, iff the emulation doesn't need to do late emission after
8296 examining things laid out late, like the strtab. */
8299 /* Copy forward lma regions for output sections in same lma region. */
8300 lang_propagate_lma_regions ();
8302 /* Defining __start/__stop symbols early for --gc-sections to work
8303 around a glibc build problem can result in these symbols being
8304 defined when they should not be. Fix them now. */
8305 if (config
.build_constructors
)
8306 lang_undef_start_stop ();
8308 /* Define .startof./.sizeof. symbols with preliminary values before
8309 dynamic symbols are created. */
8310 if (!bfd_link_relocatable (&link_info
))
8311 lang_init_startof_sizeof ();
8313 /* Do anything special before sizing sections. This is where ELF
8314 and other back-ends size dynamic sections. */
8315 ldemul_before_allocation ();
8317 /* We must record the program headers before we try to fix the
8318 section positions, since they will affect SIZEOF_HEADERS. */
8319 lang_record_phdrs ();
8321 /* Check relro sections. */
8322 if (link_info
.relro
&& !bfd_link_relocatable (&link_info
))
8323 lang_find_relro_sections ();
8325 /* Size up the sections. */
8326 lang_size_sections (NULL
, !RELAXATION_ENABLED
);
8328 /* See if anything special should be done now we know how big
8329 everything is. This is where relaxation is done. */
8330 ldemul_after_allocation ();
8332 /* Fix any __start, __stop, .startof. or .sizeof. symbols. */
8333 lang_finalize_start_stop ();
8335 /* Do all the assignments again, to report errors. Assignment
8336 statements are processed multiple times, updating symbols; In
8337 open_input_bfds, lang_do_assignments, and lang_size_sections.
8338 Since lang_relax_sections calls lang_do_assignments, symbols are
8339 also updated in ldemul_after_allocation. */
8340 lang_do_assignments (lang_final_phase_enum
);
8344 /* Convert absolute symbols to section relative. */
8345 ldexp_finalize_syms ();
8347 /* Make sure that the section addresses make sense. */
8348 if (command_line
.check_section_addresses
)
8349 lang_check_section_addresses ();
8351 /* Check any required symbols are known. */
8352 ldlang_check_require_defined_symbols ();
8357 /* EXPORTED TO YACC */
8360 lang_add_wild (struct wildcard_spec
*filespec
,
8361 struct wildcard_list
*section_list
,
8364 struct wildcard_list
*curr
, *next
;
8365 lang_wild_statement_type
*new_stmt
;
8367 /* Reverse the list as the parser puts it back to front. */
8368 for (curr
= section_list
, section_list
= NULL
;
8370 section_list
= curr
, curr
= next
)
8373 curr
->next
= section_list
;
8376 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
8378 if (strcmp (filespec
->name
, "*") == 0)
8379 filespec
->name
= NULL
;
8380 else if (!wildcardp (filespec
->name
))
8381 lang_has_input_file
= true;
8384 new_stmt
= new_stat (lang_wild_statement
, stat_ptr
);
8385 new_stmt
->filename
= NULL
;
8386 new_stmt
->filenames_sorted
= false;
8387 new_stmt
->section_flag_list
= NULL
;
8388 new_stmt
->exclude_name_list
= NULL
;
8389 if (filespec
!= NULL
)
8391 new_stmt
->filename
= filespec
->name
;
8392 new_stmt
->filenames_sorted
= filespec
->sorted
== by_name
;
8393 new_stmt
->section_flag_list
= filespec
->section_flag_list
;
8394 new_stmt
->exclude_name_list
= filespec
->exclude_name_list
;
8396 new_stmt
->section_list
= section_list
;
8397 new_stmt
->keep_sections
= keep_sections
;
8398 lang_list_init (&new_stmt
->children
);
8399 analyze_walk_wild_section_handler (new_stmt
);
8403 lang_section_start (const char *name
, etree_type
*address
,
8404 const segment_type
*segment
)
8406 lang_address_statement_type
*ad
;
8408 ad
= new_stat (lang_address_statement
, stat_ptr
);
8409 ad
->section_name
= name
;
8410 ad
->address
= address
;
8411 ad
->segment
= segment
;
8414 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
8415 because of a -e argument on the command line, or zero if this is
8416 called by ENTRY in a linker script. Command line arguments take
8420 lang_add_entry (const char *name
, bool cmdline
)
8422 if (entry_symbol
.name
== NULL
8424 || !entry_from_cmdline
)
8426 entry_symbol
.name
= name
;
8427 entry_from_cmdline
= cmdline
;
8431 /* Set the default start symbol to NAME. .em files should use this,
8432 not lang_add_entry, to override the use of "start" if neither the
8433 linker script nor the command line specifies an entry point. NAME
8434 must be permanently allocated. */
8436 lang_default_entry (const char *name
)
8438 entry_symbol_default
= name
;
8442 lang_add_target (const char *name
)
8444 lang_target_statement_type
*new_stmt
;
8446 new_stmt
= new_stat (lang_target_statement
, stat_ptr
);
8447 new_stmt
->target
= name
;
8451 lang_add_map (const char *name
)
8458 map_option_f
= true;
8466 lang_add_fill (fill_type
*fill
)
8468 lang_fill_statement_type
*new_stmt
;
8470 new_stmt
= new_stat (lang_fill_statement
, stat_ptr
);
8471 new_stmt
->fill
= fill
;
8475 lang_add_data (int type
, union etree_union
*exp
)
8477 lang_data_statement_type
*new_stmt
;
8479 new_stmt
= new_stat (lang_data_statement
, stat_ptr
);
8480 new_stmt
->exp
= exp
;
8481 new_stmt
->type
= type
;
8484 /* Create a new reloc statement. RELOC is the BFD relocation type to
8485 generate. HOWTO is the corresponding howto structure (we could
8486 look this up, but the caller has already done so). SECTION is the
8487 section to generate a reloc against, or NAME is the name of the
8488 symbol to generate a reloc against. Exactly one of SECTION and
8489 NAME must be NULL. ADDEND is an expression for the addend. */
8492 lang_add_reloc (bfd_reloc_code_real_type reloc
,
8493 reloc_howto_type
*howto
,
8496 union etree_union
*addend
)
8498 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
8502 p
->section
= section
;
8504 p
->addend_exp
= addend
;
8506 p
->addend_value
= 0;
8507 p
->output_section
= NULL
;
8508 p
->output_offset
= 0;
8511 lang_assignment_statement_type
*
8512 lang_add_assignment (etree_type
*exp
)
8514 lang_assignment_statement_type
*new_stmt
;
8516 new_stmt
= new_stat (lang_assignment_statement
, stat_ptr
);
8517 new_stmt
->exp
= exp
;
8522 lang_add_attribute (enum statement_enum attribute
)
8524 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
8528 lang_startup (const char *name
)
8530 if (first_file
->filename
!= NULL
)
8532 einfo (_("%F%P: multiple STARTUP files\n"));
8534 first_file
->filename
= name
;
8535 first_file
->local_sym_name
= name
;
8536 first_file
->flags
.real
= true;
8540 lang_float (bool maybe
)
8542 lang_float_flag
= maybe
;
8546 /* Work out the load- and run-time regions from a script statement, and
8547 store them in *LMA_REGION and *REGION respectively.
8549 MEMSPEC is the name of the run-time region, or the value of
8550 DEFAULT_MEMORY_REGION if the statement didn't specify one.
8551 LMA_MEMSPEC is the name of the load-time region, or null if the
8552 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
8553 had an explicit load address.
8555 It is an error to specify both a load region and a load address. */
8558 lang_get_regions (lang_memory_region_type
**region
,
8559 lang_memory_region_type
**lma_region
,
8560 const char *memspec
,
8561 const char *lma_memspec
,
8565 *lma_region
= lang_memory_region_lookup (lma_memspec
, false);
8567 /* If no runtime region or VMA has been specified, but the load region
8568 has been specified, then use the load region for the runtime region
8570 if (lma_memspec
!= NULL
8572 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
8573 *region
= *lma_region
;
8575 *region
= lang_memory_region_lookup (memspec
, false);
8577 if (have_lma
&& lma_memspec
!= 0)
8578 einfo (_("%X%P:%pS: section has both a load address and a load region\n"),
8583 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
8584 lang_output_section_phdr_list
*phdrs
,
8585 const char *lma_memspec
)
8587 lang_get_regions (¤t_section
->region
,
8588 ¤t_section
->lma_region
,
8589 memspec
, lma_memspec
,
8590 current_section
->load_base
!= NULL
,
8591 current_section
->addr_tree
!= NULL
);
8593 current_section
->fill
= fill
;
8594 current_section
->phdrs
= phdrs
;
8598 /* Set the output format type. -oformat overrides scripts. */
8601 lang_add_output_format (const char *format
,
8606 if (output_target
== NULL
|| !from_script
)
8608 if (command_line
.endian
== ENDIAN_BIG
8611 else if (command_line
.endian
== ENDIAN_LITTLE
8615 output_target
= format
;
8620 lang_add_insert (const char *where
, int is_before
)
8622 lang_insert_statement_type
*new_stmt
;
8624 new_stmt
= new_stat (lang_insert_statement
, stat_ptr
);
8625 new_stmt
->where
= where
;
8626 new_stmt
->is_before
= is_before
;
8627 saved_script_handle
= previous_script_handle
;
8630 /* Enter a group. This creates a new lang_group_statement, and sets
8631 stat_ptr to build new statements within the group. */
8634 lang_enter_group (void)
8636 lang_group_statement_type
*g
;
8638 g
= new_stat (lang_group_statement
, stat_ptr
);
8639 lang_list_init (&g
->children
);
8640 push_stat_ptr (&g
->children
);
8643 /* Leave a group. This just resets stat_ptr to start writing to the
8644 regular list of statements again. Note that this will not work if
8645 groups can occur inside anything else which can adjust stat_ptr,
8646 but currently they can't. */
8649 lang_leave_group (void)
8654 /* Add a new program header. This is called for each entry in a PHDRS
8655 command in a linker script. */
8658 lang_new_phdr (const char *name
,
8665 struct lang_phdr
*n
, **pp
;
8668 n
= stat_alloc (sizeof (struct lang_phdr
));
8671 n
->type
= exp_get_vma (type
, 0, "program header type");
8672 n
->filehdr
= filehdr
;
8677 hdrs
= n
->type
== 1 && (phdrs
|| filehdr
);
8679 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
8682 && !((*pp
)->filehdr
|| (*pp
)->phdrs
))
8684 einfo (_("%X%P:%pS: PHDRS and FILEHDR are not supported"
8685 " when prior PT_LOAD headers lack them\n"), NULL
);
8692 /* Record the program header information in the output BFD. FIXME: We
8693 should not be calling an ELF specific function here. */
8696 lang_record_phdrs (void)
8700 lang_output_section_phdr_list
*last
;
8701 struct lang_phdr
*l
;
8702 lang_output_section_statement_type
*os
;
8705 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
8708 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
8715 for (os
= (void *) lang_os_list
.head
;
8719 lang_output_section_phdr_list
*pl
;
8721 if (os
->constraint
< 0)
8729 if (os
->sectype
== noload_section
8730 || os
->bfd_section
== NULL
8731 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
8734 /* Don't add orphans to PT_INTERP header. */
8740 lang_output_section_statement_type
*tmp_os
;
8742 /* If we have not run across a section with a program
8743 header assigned to it yet, then scan forwards to find
8744 one. This prevents inconsistencies in the linker's
8745 behaviour when a script has specified just a single
8746 header and there are sections in that script which are
8747 not assigned to it, and which occur before the first
8748 use of that header. See here for more details:
8749 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
8750 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
8753 last
= tmp_os
->phdrs
;
8757 einfo (_("%F%P: no sections assigned to phdrs\n"));
8762 if (os
->bfd_section
== NULL
)
8765 for (; pl
!= NULL
; pl
= pl
->next
)
8767 if (strcmp (pl
->name
, l
->name
) == 0)
8772 secs
= (asection
**) xrealloc (secs
,
8773 alc
* sizeof (asection
*));
8775 secs
[c
] = os
->bfd_section
;
8782 if (l
->flags
== NULL
)
8785 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
8790 at
= exp_get_vma (l
->at
, 0, "phdr load address");
8792 if (!bfd_record_phdr (link_info
.output_bfd
, l
->type
,
8793 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
8794 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
8795 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
8800 /* Make sure all the phdr assignments succeeded. */
8801 for (os
= (void *) lang_os_list
.head
;
8805 lang_output_section_phdr_list
*pl
;
8807 if (os
->constraint
< 0
8808 || os
->bfd_section
== NULL
)
8811 for (pl
= os
->phdrs
;
8814 if (!pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
8815 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
8816 os
->name
, pl
->name
);
8820 /* Record a list of sections which may not be cross referenced. */
8823 lang_add_nocrossref (lang_nocrossref_type
*l
)
8825 struct lang_nocrossrefs
*n
;
8827 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
8828 n
->next
= nocrossref_list
;
8830 n
->onlyfirst
= false;
8831 nocrossref_list
= n
;
8833 /* Set notice_all so that we get informed about all symbols. */
8834 link_info
.notice_all
= true;
8837 /* Record a section that cannot be referenced from a list of sections. */
8840 lang_add_nocrossref_to (lang_nocrossref_type
*l
)
8842 lang_add_nocrossref (l
);
8843 nocrossref_list
->onlyfirst
= true;
8846 /* Overlay handling. We handle overlays with some static variables. */
8848 /* The overlay virtual address. */
8849 static etree_type
*overlay_vma
;
8850 /* And subsection alignment. */
8851 static etree_type
*overlay_subalign
;
8853 /* An expression for the maximum section size seen so far. */
8854 static etree_type
*overlay_max
;
8856 /* A list of all the sections in this overlay. */
8858 struct overlay_list
{
8859 struct overlay_list
*next
;
8860 lang_output_section_statement_type
*os
;
8863 static struct overlay_list
*overlay_list
;
8865 /* Start handling an overlay. */
8868 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
8870 /* The grammar should prevent nested overlays from occurring. */
8871 ASSERT (overlay_vma
== NULL
8872 && overlay_subalign
== NULL
8873 && overlay_max
== NULL
);
8875 overlay_vma
= vma_expr
;
8876 overlay_subalign
= subalign
;
8879 /* Start a section in an overlay. We handle this by calling
8880 lang_enter_output_section_statement with the correct VMA.
8881 lang_leave_overlay sets up the LMA and memory regions. */
8884 lang_enter_overlay_section (const char *name
)
8886 struct overlay_list
*n
;
8889 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
8890 0, 0, overlay_subalign
, 0, 0, 0);
8892 /* If this is the first section, then base the VMA of future
8893 sections on this one. This will work correctly even if `.' is
8894 used in the addresses. */
8895 if (overlay_list
== NULL
)
8896 overlay_vma
= exp_nameop (ADDR
, name
);
8898 /* Remember the section. */
8899 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
8900 n
->os
= current_section
;
8901 n
->next
= overlay_list
;
8904 size
= exp_nameop (SIZEOF
, name
);
8906 /* Arrange to work out the maximum section end address. */
8907 if (overlay_max
== NULL
)
8910 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
8913 /* Finish a section in an overlay. There isn't any special to do
8917 lang_leave_overlay_section (fill_type
*fill
,
8918 lang_output_section_phdr_list
*phdrs
)
8925 name
= current_section
->name
;
8927 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
8928 region and that no load-time region has been specified. It doesn't
8929 really matter what we say here, since lang_leave_overlay will
8931 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
8933 /* Define the magic symbols. */
8935 clean
= (char *) xmalloc (strlen (name
) + 1);
8937 for (s1
= name
; *s1
!= '\0'; s1
++)
8938 if (ISALNUM (*s1
) || *s1
== '_')
8942 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_start_");
8943 sprintf (buf
, "__load_start_%s", clean
);
8944 lang_add_assignment (exp_provide (buf
,
8945 exp_nameop (LOADADDR
, name
),
8948 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_stop_");
8949 sprintf (buf
, "__load_stop_%s", clean
);
8950 lang_add_assignment (exp_provide (buf
,
8952 exp_nameop (LOADADDR
, name
),
8953 exp_nameop (SIZEOF
, name
)),
8959 /* Finish an overlay. If there are any overlay wide settings, this
8960 looks through all the sections in the overlay and sets them. */
8963 lang_leave_overlay (etree_type
*lma_expr
,
8966 const char *memspec
,
8967 lang_output_section_phdr_list
*phdrs
,
8968 const char *lma_memspec
)
8970 lang_memory_region_type
*region
;
8971 lang_memory_region_type
*lma_region
;
8972 struct overlay_list
*l
;
8973 lang_nocrossref_type
*nocrossref
;
8975 lang_get_regions (®ion
, &lma_region
,
8976 memspec
, lma_memspec
,
8977 lma_expr
!= NULL
, false);
8981 /* After setting the size of the last section, set '.' to end of the
8983 if (overlay_list
!= NULL
)
8985 overlay_list
->os
->update_dot
= 1;
8986 overlay_list
->os
->update_dot_tree
8987 = exp_assign (".", exp_binop ('+', overlay_vma
, overlay_max
), false);
8993 struct overlay_list
*next
;
8995 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
8998 l
->os
->region
= region
;
8999 l
->os
->lma_region
= lma_region
;
9001 /* The first section has the load address specified in the
9002 OVERLAY statement. The rest are worked out from that.
9003 The base address is not needed (and should be null) if
9004 an LMA region was specified. */
9007 l
->os
->load_base
= lma_expr
;
9008 l
->os
->sectype
= first_overlay_section
;
9010 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
9011 l
->os
->phdrs
= phdrs
;
9015 lang_nocrossref_type
*nc
;
9017 nc
= (lang_nocrossref_type
*) xmalloc (sizeof *nc
);
9018 nc
->name
= l
->os
->name
;
9019 nc
->next
= nocrossref
;
9028 if (nocrossref
!= NULL
)
9029 lang_add_nocrossref (nocrossref
);
9032 overlay_list
= NULL
;
9034 overlay_subalign
= NULL
;
9037 /* Version handling. This is only useful for ELF. */
9039 /* If PREV is NULL, return first version pattern matching particular symbol.
9040 If PREV is non-NULL, return first version pattern matching particular
9041 symbol after PREV (previously returned by lang_vers_match). */
9043 static struct bfd_elf_version_expr
*
9044 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
9045 struct bfd_elf_version_expr
*prev
,
9049 const char *cxx_sym
= sym
;
9050 const char *java_sym
= sym
;
9051 struct bfd_elf_version_expr
*expr
= NULL
;
9052 enum demangling_styles curr_style
;
9054 curr_style
= CURRENT_DEMANGLING_STYLE
;
9055 cplus_demangle_set_style (no_demangling
);
9056 c_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_NO_OPTS
);
9059 cplus_demangle_set_style (curr_style
);
9061 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
9063 cxx_sym
= bfd_demangle (link_info
.output_bfd
, sym
,
9064 DMGL_PARAMS
| DMGL_ANSI
);
9068 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
9070 java_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_JAVA
);
9075 if (head
->htab
&& (prev
== NULL
|| prev
->literal
))
9077 struct bfd_elf_version_expr e
;
9079 switch (prev
? prev
->mask
: 0)
9082 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
9085 expr
= (struct bfd_elf_version_expr
*)
9086 htab_find ((htab_t
) head
->htab
, &e
);
9087 while (expr
&& strcmp (expr
->pattern
, c_sym
) == 0)
9088 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
9094 case BFD_ELF_VERSION_C_TYPE
:
9095 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
9097 e
.pattern
= cxx_sym
;
9098 expr
= (struct bfd_elf_version_expr
*)
9099 htab_find ((htab_t
) head
->htab
, &e
);
9100 while (expr
&& strcmp (expr
->pattern
, cxx_sym
) == 0)
9101 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
9107 case BFD_ELF_VERSION_CXX_TYPE
:
9108 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
9110 e
.pattern
= java_sym
;
9111 expr
= (struct bfd_elf_version_expr
*)
9112 htab_find ((htab_t
) head
->htab
, &e
);
9113 while (expr
&& strcmp (expr
->pattern
, java_sym
) == 0)
9114 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
9125 /* Finally, try the wildcards. */
9126 if (prev
== NULL
|| prev
->literal
)
9127 expr
= head
->remaining
;
9130 for (; expr
; expr
= expr
->next
)
9137 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
9140 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
9142 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
9146 if (fnmatch (expr
->pattern
, s
, 0) == 0)
9152 free ((char *) c_sym
);
9154 free ((char *) cxx_sym
);
9155 if (java_sym
!= sym
)
9156 free ((char *) java_sym
);
9160 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
9161 return a pointer to the symbol name with any backslash quotes removed. */
9164 realsymbol (const char *pattern
)
9167 bool changed
= false, backslash
= false;
9168 char *s
, *symbol
= (char *) xmalloc (strlen (pattern
) + 1);
9170 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
9172 /* It is a glob pattern only if there is no preceding
9176 /* Remove the preceding backslash. */
9183 if (*p
== '?' || *p
== '*' || *p
== '[')
9190 backslash
= *p
== '\\';
9206 /* This is called for each variable name or match expression. NEW_NAME is
9207 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
9208 pattern to be matched against symbol names. */
9210 struct bfd_elf_version_expr
*
9211 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
9212 const char *new_name
,
9216 struct bfd_elf_version_expr
*ret
;
9218 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
9222 ret
->literal
= true;
9223 ret
->pattern
= literal_p
? new_name
: realsymbol (new_name
);
9224 if (ret
->pattern
== NULL
)
9226 ret
->pattern
= new_name
;
9227 ret
->literal
= false;
9230 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
9231 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
9232 else if (strcasecmp (lang
, "C++") == 0)
9233 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
9234 else if (strcasecmp (lang
, "Java") == 0)
9235 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
9238 einfo (_("%X%P: unknown language `%s' in version information\n"),
9240 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
9243 return ldemul_new_vers_pattern (ret
);
9246 /* This is called for each set of variable names and match
9249 struct bfd_elf_version_tree
*
9250 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
9251 struct bfd_elf_version_expr
*locals
)
9253 struct bfd_elf_version_tree
*ret
;
9255 ret
= (struct bfd_elf_version_tree
*) xcalloc (1, sizeof *ret
);
9256 ret
->globals
.list
= globals
;
9257 ret
->locals
.list
= locals
;
9258 ret
->match
= lang_vers_match
;
9259 ret
->name_indx
= (unsigned int) -1;
9263 /* This static variable keeps track of version indices. */
9265 static int version_index
;
9268 version_expr_head_hash (const void *p
)
9270 const struct bfd_elf_version_expr
*e
=
9271 (const struct bfd_elf_version_expr
*) p
;
9273 return htab_hash_string (e
->pattern
);
9277 version_expr_head_eq (const void *p1
, const void *p2
)
9279 const struct bfd_elf_version_expr
*e1
=
9280 (const struct bfd_elf_version_expr
*) p1
;
9281 const struct bfd_elf_version_expr
*e2
=
9282 (const struct bfd_elf_version_expr
*) p2
;
9284 return strcmp (e1
->pattern
, e2
->pattern
) == 0;
9288 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
9291 struct bfd_elf_version_expr
*e
, *next
;
9292 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
9294 for (e
= head
->list
; e
; e
= e
->next
)
9298 head
->mask
|= e
->mask
;
9303 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
9304 version_expr_head_eq
, NULL
);
9305 list_loc
= &head
->list
;
9306 remaining_loc
= &head
->remaining
;
9307 for (e
= head
->list
; e
; e
= next
)
9313 remaining_loc
= &e
->next
;
9317 void **loc
= htab_find_slot ((htab_t
) head
->htab
, e
, INSERT
);
9321 struct bfd_elf_version_expr
*e1
, *last
;
9323 e1
= (struct bfd_elf_version_expr
*) *loc
;
9327 if (e1
->mask
== e
->mask
)
9335 while (e1
&& strcmp (e1
->pattern
, e
->pattern
) == 0);
9339 /* This is a duplicate. */
9340 /* FIXME: Memory leak. Sometimes pattern is not
9341 xmalloced alone, but in larger chunk of memory. */
9342 /* free (e->pattern); */
9347 e
->next
= last
->next
;
9355 list_loc
= &e
->next
;
9359 *remaining_loc
= NULL
;
9360 *list_loc
= head
->remaining
;
9363 head
->remaining
= head
->list
;
9366 /* This is called when we know the name and dependencies of the
9370 lang_register_vers_node (const char *name
,
9371 struct bfd_elf_version_tree
*version
,
9372 struct bfd_elf_version_deps
*deps
)
9374 struct bfd_elf_version_tree
*t
, **pp
;
9375 struct bfd_elf_version_expr
*e1
;
9380 if (link_info
.version_info
!= NULL
9381 && (name
[0] == '\0' || link_info
.version_info
->name
[0] == '\0'))
9383 einfo (_("%X%P: anonymous version tag cannot be combined"
9384 " with other version tags\n"));
9389 /* Make sure this node has a unique name. */
9390 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9391 if (strcmp (t
->name
, name
) == 0)
9392 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
9394 lang_finalize_version_expr_head (&version
->globals
);
9395 lang_finalize_version_expr_head (&version
->locals
);
9397 /* Check the global and local match names, and make sure there
9398 aren't any duplicates. */
9400 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
9402 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9404 struct bfd_elf_version_expr
*e2
;
9406 if (t
->locals
.htab
&& e1
->literal
)
9408 e2
= (struct bfd_elf_version_expr
*)
9409 htab_find ((htab_t
) t
->locals
.htab
, e1
);
9410 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
9412 if (e1
->mask
== e2
->mask
)
9413 einfo (_("%X%P: duplicate expression `%s'"
9414 " in version information\n"), e1
->pattern
);
9418 else if (!e1
->literal
)
9419 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
9420 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
9421 && e1
->mask
== e2
->mask
)
9422 einfo (_("%X%P: duplicate expression `%s'"
9423 " in version information\n"), e1
->pattern
);
9427 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
9429 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9431 struct bfd_elf_version_expr
*e2
;
9433 if (t
->globals
.htab
&& e1
->literal
)
9435 e2
= (struct bfd_elf_version_expr
*)
9436 htab_find ((htab_t
) t
->globals
.htab
, e1
);
9437 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
9439 if (e1
->mask
== e2
->mask
)
9440 einfo (_("%X%P: duplicate expression `%s'"
9441 " in version information\n"),
9446 else if (!e1
->literal
)
9447 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
9448 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
9449 && e1
->mask
== e2
->mask
)
9450 einfo (_("%X%P: duplicate expression `%s'"
9451 " in version information\n"), e1
->pattern
);
9455 version
->deps
= deps
;
9456 version
->name
= name
;
9457 if (name
[0] != '\0')
9460 version
->vernum
= version_index
;
9463 version
->vernum
= 0;
9465 for (pp
= &link_info
.version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
9470 /* This is called when we see a version dependency. */
9472 struct bfd_elf_version_deps
*
9473 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
9475 struct bfd_elf_version_deps
*ret
;
9476 struct bfd_elf_version_tree
*t
;
9478 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
9481 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9483 if (strcmp (t
->name
, name
) == 0)
9485 ret
->version_needed
= t
;
9490 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
9492 ret
->version_needed
= NULL
;
9497 lang_do_version_exports_section (void)
9499 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
9501 LANG_FOR_EACH_INPUT_STATEMENT (is
)
9503 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
9511 contents
= (char *) xmalloc (len
);
9512 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
9513 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
9516 while (p
< contents
+ len
)
9518 greg
= lang_new_vers_pattern (greg
, p
, NULL
, false);
9519 p
= strchr (p
, '\0') + 1;
9522 /* Do not free the contents, as we used them creating the regex. */
9524 /* Do not include this section in the link. */
9525 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
9528 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, false);
9529 lang_register_vers_node (command_line
.version_exports_section
,
9530 lang_new_vers_node (greg
, lreg
), NULL
);
9533 /* Evaluate LENGTH and ORIGIN parts of MEMORY spec. This is initially
9534 called with UPDATE_REGIONS_P set to FALSE, in this case no errors are
9535 thrown, however, references to symbols in the origin and length fields
9536 will be pushed into the symbol table, this allows PROVIDE statements to
9537 then provide these symbols. This function is called a second time with
9538 UPDATE_REGIONS_P set to TRUE, this time the we update the actual region
9539 data structures, and throw errors if missing symbols are encountered. */
9542 lang_do_memory_regions (bool update_regions_p
)
9544 lang_memory_region_type
*r
= lang_memory_region_list
;
9546 for (; r
!= NULL
; r
= r
->next
)
9550 exp_fold_tree_no_dot (r
->origin_exp
);
9551 if (update_regions_p
)
9553 if (expld
.result
.valid_p
)
9555 r
->origin
= expld
.result
.value
;
9556 r
->current
= r
->origin
;
9559 einfo (_("%P: invalid origin for memory region %s\n"),
9565 exp_fold_tree_no_dot (r
->length_exp
);
9566 if (update_regions_p
)
9568 if (expld
.result
.valid_p
)
9569 r
->length
= expld
.result
.value
;
9571 einfo (_("%P: invalid length for memory region %s\n"),
9579 lang_add_unique (const char *name
)
9581 struct unique_sections
*ent
;
9583 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
9584 if (strcmp (ent
->name
, name
) == 0)
9587 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
9588 ent
->name
= xstrdup (name
);
9589 ent
->next
= unique_section_list
;
9590 unique_section_list
= ent
;
9593 /* Append the list of dynamic symbols to the existing one. */
9596 lang_append_dynamic_list (struct bfd_elf_dynamic_list
**list_p
,
9597 struct bfd_elf_version_expr
*dynamic
)
9601 struct bfd_elf_version_expr
*tail
;
9602 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
9604 tail
->next
= (*list_p
)->head
.list
;
9605 (*list_p
)->head
.list
= dynamic
;
9609 struct bfd_elf_dynamic_list
*d
;
9611 d
= (struct bfd_elf_dynamic_list
*) xcalloc (1, sizeof *d
);
9612 d
->head
.list
= dynamic
;
9613 d
->match
= lang_vers_match
;
9618 /* Append the list of C++ typeinfo dynamic symbols to the existing
9622 lang_append_dynamic_list_cpp_typeinfo (void)
9624 const char *symbols
[] =
9626 "typeinfo name for*",
9629 struct bfd_elf_version_expr
*dynamic
= NULL
;
9632 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9633 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9636 lang_append_dynamic_list (&link_info
.dynamic_list
, dynamic
);
9639 /* Append the list of C++ operator new and delete dynamic symbols to the
9643 lang_append_dynamic_list_cpp_new (void)
9645 const char *symbols
[] =
9650 struct bfd_elf_version_expr
*dynamic
= NULL
;
9653 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9654 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9657 lang_append_dynamic_list (&link_info
.dynamic_list
, dynamic
);
9660 /* Scan a space and/or comma separated string of features. */
9663 lang_ld_feature (char *str
)
9671 while (*p
== ',' || ISSPACE (*p
))
9676 while (*q
&& *q
!= ',' && !ISSPACE (*q
))
9680 if (strcasecmp (p
, "SANE_EXPR") == 0)
9681 config
.sane_expr
= true;
9683 einfo (_("%X%P: unknown feature `%s'\n"), p
);
9689 /* Pretty print memory amount. */
9692 lang_print_memory_size (bfd_vma sz
)
9694 if ((sz
& 0x3fffffff) == 0)
9695 printf ("%10" BFD_VMA_FMT
"u GB", sz
>> 30);
9696 else if ((sz
& 0xfffff) == 0)
9697 printf ("%10" BFD_VMA_FMT
"u MB", sz
>> 20);
9698 else if ((sz
& 0x3ff) == 0)
9699 printf ("%10" BFD_VMA_FMT
"u KB", sz
>> 10);
9701 printf (" %10" BFD_VMA_FMT
"u B", sz
);
9704 /* Implement --print-memory-usage: disply per region memory usage. */
9707 lang_print_memory_usage (void)
9709 lang_memory_region_type
*r
;
9711 printf ("Memory region Used Size Region Size %%age Used\n");
9712 for (r
= lang_memory_region_list
; r
->next
!= NULL
; r
= r
->next
)
9714 bfd_vma used_length
= r
->current
- r
->origin
;
9716 printf ("%16s: ",r
->name_list
.name
);
9717 lang_print_memory_size (used_length
);
9718 lang_print_memory_size ((bfd_vma
) r
->length
);
9722 double percent
= used_length
* 100.0 / r
->length
;
9723 printf (" %6.2f%%", percent
);