1 /* Linker command language support.
2 Copyright (C) 1991-2021 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 (secname
, address
, normal_section
,
1895 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
:
2639 case noalloc_section
:
2640 flags
&= ~SEC_ALLOC
;
2642 case readonly_section
:
2643 flags
|= SEC_READONLY
;
2645 case noload_section
:
2647 flags
|= SEC_NEVER_LOAD
;
2648 /* Unfortunately GNU ld has managed to evolve two different
2649 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2650 alloc, no contents section. All others get a noload, noalloc
2652 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
2653 flags
&= ~SEC_HAS_CONTENTS
;
2655 flags
&= ~SEC_ALLOC
;
2659 if (output
->bfd_section
== NULL
)
2660 init_os (output
, flags
);
2662 /* If SEC_READONLY is not set in the input section, then clear
2663 it from the output section. */
2664 output
->bfd_section
->flags
&= flags
| ~SEC_READONLY
;
2666 if (output
->bfd_section
->linker_has_input
)
2668 /* Only set SEC_READONLY flag on the first input section. */
2669 flags
&= ~ SEC_READONLY
;
2671 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2672 if ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2673 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2674 || ((flags
& SEC_MERGE
) != 0
2675 && output
->bfd_section
->entsize
!= section
->entsize
))
2677 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2678 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2681 output
->bfd_section
->flags
|= flags
;
2683 if (!output
->bfd_section
->linker_has_input
)
2685 output
->bfd_section
->linker_has_input
= 1;
2686 /* This must happen after flags have been updated. The output
2687 section may have been created before we saw its first input
2688 section, eg. for a data statement. */
2689 bfd_init_private_section_data (section
->owner
, section
,
2690 link_info
.output_bfd
,
2691 output
->bfd_section
,
2693 if ((flags
& SEC_MERGE
) != 0)
2694 output
->bfd_section
->entsize
= section
->entsize
;
2697 if ((flags
& SEC_TIC54X_BLOCK
) != 0
2698 && bfd_get_arch (section
->owner
) == bfd_arch_tic54x
)
2700 /* FIXME: This value should really be obtained from the bfd... */
2701 output
->block_value
= 128;
2704 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2705 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2707 section
->output_section
= output
->bfd_section
;
2709 if (!map_head_is_link_order
)
2711 asection
*s
= output
->bfd_section
->map_tail
.s
;
2712 output
->bfd_section
->map_tail
.s
= section
;
2713 section
->map_head
.s
= NULL
;
2714 section
->map_tail
.s
= s
;
2716 s
->map_head
.s
= section
;
2718 output
->bfd_section
->map_head
.s
= section
;
2721 /* Add a section reference to the list. */
2722 new_section
= new_stat (lang_input_section
, ptr
);
2723 new_section
->section
= section
;
2724 new_section
->pattern
= pattern
;
2727 /* Handle wildcard sorting. This returns the lang_input_section which
2728 should follow the one we are going to create for SECTION and FILE,
2729 based on the sorting requirements of WILD. It returns NULL if the
2730 new section should just go at the end of the current list. */
2732 static lang_statement_union_type
*
2733 wild_sort (lang_wild_statement_type
*wild
,
2734 struct wildcard_list
*sec
,
2735 lang_input_statement_type
*file
,
2738 lang_statement_union_type
*l
;
2740 if (!wild
->filenames_sorted
2741 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
2744 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
2746 lang_input_section_type
*ls
;
2748 if (l
->header
.type
!= lang_input_section_enum
)
2750 ls
= &l
->input_section
;
2752 /* Sorting by filename takes precedence over sorting by section
2755 if (wild
->filenames_sorted
)
2757 const char *fn
, *ln
;
2761 /* The PE support for the .idata section as generated by
2762 dlltool assumes that files will be sorted by the name of
2763 the archive and then the name of the file within the
2766 if (file
->the_bfd
!= NULL
2767 && file
->the_bfd
->my_archive
!= NULL
)
2769 fn
= bfd_get_filename (file
->the_bfd
->my_archive
);
2774 fn
= file
->filename
;
2778 if (ls
->section
->owner
->my_archive
!= NULL
)
2780 ln
= bfd_get_filename (ls
->section
->owner
->my_archive
);
2785 ln
= bfd_get_filename (ls
->section
->owner
);
2789 i
= filename_cmp (fn
, ln
);
2798 fn
= file
->filename
;
2800 ln
= bfd_get_filename (ls
->section
->owner
);
2802 i
= filename_cmp (fn
, ln
);
2810 /* Here either the files are not sorted by name, or we are
2811 looking at the sections for this file. */
2814 && sec
->spec
.sorted
!= none
2815 && sec
->spec
.sorted
!= by_none
)
2816 if (compare_section (sec
->spec
.sorted
, section
, ls
->section
) < 0)
2823 /* Expand a wild statement for a particular FILE. SECTION may be
2824 NULL, in which case it is a wild card. */
2827 output_section_callback (lang_wild_statement_type
*ptr
,
2828 struct wildcard_list
*sec
,
2830 lang_input_statement_type
*file
,
2833 lang_statement_union_type
*before
;
2834 lang_output_section_statement_type
*os
;
2836 os
= (lang_output_section_statement_type
*) output
;
2838 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2839 if (unique_section_p (section
, os
))
2842 before
= wild_sort (ptr
, sec
, file
, section
);
2844 /* Here BEFORE points to the lang_input_section which
2845 should follow the one we are about to add. If BEFORE
2846 is NULL, then the section should just go at the end
2847 of the current list. */
2850 lang_add_section (&ptr
->children
, section
, ptr
->section_list
,
2851 ptr
->section_flag_list
, os
);
2854 lang_statement_list_type list
;
2855 lang_statement_union_type
**pp
;
2857 lang_list_init (&list
);
2858 lang_add_section (&list
, section
, ptr
->section_list
,
2859 ptr
->section_flag_list
, os
);
2861 /* If we are discarding the section, LIST.HEAD will
2863 if (list
.head
!= NULL
)
2865 ASSERT (list
.head
->header
.next
== NULL
);
2867 for (pp
= &ptr
->children
.head
;
2869 pp
= &(*pp
)->header
.next
)
2870 ASSERT (*pp
!= NULL
);
2872 list
.head
->header
.next
= *pp
;
2878 /* Check if all sections in a wild statement for a particular FILE
2882 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2883 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2885 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2888 lang_output_section_statement_type
*os
;
2890 os
= (lang_output_section_statement_type
*) output
;
2892 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2893 if (unique_section_p (section
, os
))
2896 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2897 os
->all_input_readonly
= false;
2900 /* This is passed a file name which must have been seen already and
2901 added to the statement tree. We will see if it has been opened
2902 already and had its symbols read. If not then we'll read it. */
2904 static lang_input_statement_type
*
2905 lookup_name (const char *name
)
2907 lang_input_statement_type
*search
;
2909 for (search
= (void *) input_file_chain
.head
;
2911 search
= search
->next_real_file
)
2913 /* Use the local_sym_name as the name of the file that has
2914 already been loaded as filename might have been transformed
2915 via the search directory lookup mechanism. */
2916 const char *filename
= search
->local_sym_name
;
2918 if (filename
!= NULL
2919 && filename_cmp (filename
, name
) == 0)
2925 /* Arrange to splice the input statement added by new_afile into
2926 statement_list after the current input_file_chain tail.
2927 We know input_file_chain is not an empty list, and that
2928 lookup_name was called via open_input_bfds. Later calls to
2929 lookup_name should always match an existing input_statement. */
2930 lang_statement_union_type
**tail
= stat_ptr
->tail
;
2931 lang_statement_union_type
**after
2932 = (void *) ((char *) input_file_chain
.tail
2933 - offsetof (lang_input_statement_type
, next_real_file
)
2934 + offsetof (lang_input_statement_type
, header
.next
));
2935 lang_statement_union_type
*rest
= *after
;
2936 stat_ptr
->tail
= after
;
2937 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2938 default_target
, NULL
);
2939 *stat_ptr
->tail
= rest
;
2941 stat_ptr
->tail
= tail
;
2944 /* If we have already added this file, or this file is not real
2945 don't add this file. */
2946 if (search
->flags
.loaded
|| !search
->flags
.real
)
2949 if (!load_symbols (search
, NULL
))
2955 /* Save LIST as a list of libraries whose symbols should not be exported. */
2960 struct excluded_lib
*next
;
2962 static struct excluded_lib
*excluded_libs
;
2965 add_excluded_libs (const char *list
)
2967 const char *p
= list
, *end
;
2971 struct excluded_lib
*entry
;
2972 end
= strpbrk (p
, ",:");
2974 end
= p
+ strlen (p
);
2975 entry
= (struct excluded_lib
*) xmalloc (sizeof (*entry
));
2976 entry
->next
= excluded_libs
;
2977 entry
->name
= (char *) xmalloc (end
- p
+ 1);
2978 memcpy (entry
->name
, p
, end
- p
);
2979 entry
->name
[end
- p
] = '\0';
2980 excluded_libs
= entry
;
2988 check_excluded_libs (bfd
*abfd
)
2990 struct excluded_lib
*lib
= excluded_libs
;
2994 int len
= strlen (lib
->name
);
2995 const char *filename
= lbasename (bfd_get_filename (abfd
));
2997 if (strcmp (lib
->name
, "ALL") == 0)
2999 abfd
->no_export
= true;
3003 if (filename_ncmp (lib
->name
, filename
, len
) == 0
3004 && (filename
[len
] == '\0'
3005 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
3006 && filename
[len
+ 2] == '\0')))
3008 abfd
->no_export
= true;
3016 /* Get the symbols for an input file. */
3019 load_symbols (lang_input_statement_type
*entry
,
3020 lang_statement_list_type
*place
)
3024 if (entry
->flags
.loaded
)
3027 ldfile_open_file (entry
);
3029 /* Do not process further if the file was missing. */
3030 if (entry
->flags
.missing_file
)
3033 if (trace_files
|| verbose
)
3034 info_msg ("%pI\n", entry
);
3036 if (!bfd_check_format (entry
->the_bfd
, bfd_archive
)
3037 && !bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
3040 struct lang_input_statement_flags save_flags
;
3043 err
= bfd_get_error ();
3045 /* See if the emulation has some special knowledge. */
3046 if (ldemul_unrecognized_file (entry
))
3049 if (err
== bfd_error_file_ambiguously_recognized
)
3053 einfo (_("%P: %pB: file not recognized: %E;"
3054 " matching formats:"), entry
->the_bfd
);
3055 for (p
= matching
; *p
!= NULL
; p
++)
3059 else if (err
!= bfd_error_file_not_recognized
3061 einfo (_("%F%P: %pB: file not recognized: %E\n"), entry
->the_bfd
);
3063 bfd_close (entry
->the_bfd
);
3064 entry
->the_bfd
= NULL
;
3066 /* Try to interpret the file as a linker script. */
3067 save_flags
= input_flags
;
3068 ldfile_open_command_file (entry
->filename
);
3070 push_stat_ptr (place
);
3071 input_flags
.add_DT_NEEDED_for_regular
3072 = entry
->flags
.add_DT_NEEDED_for_regular
;
3073 input_flags
.add_DT_NEEDED_for_dynamic
3074 = entry
->flags
.add_DT_NEEDED_for_dynamic
;
3075 input_flags
.whole_archive
= entry
->flags
.whole_archive
;
3076 input_flags
.dynamic
= entry
->flags
.dynamic
;
3078 ldfile_assumed_script
= true;
3079 parser_input
= input_script
;
3080 current_input_file
= entry
->filename
;
3082 current_input_file
= NULL
;
3083 ldfile_assumed_script
= false;
3085 /* missing_file is sticky. sysrooted will already have been
3086 restored when seeing EOF in yyparse, but no harm to restore
3088 save_flags
.missing_file
|= input_flags
.missing_file
;
3089 input_flags
= save_flags
;
3093 entry
->flags
.loaded
= true;
3098 if (ldemul_recognized_file (entry
))
3101 /* We don't call ldlang_add_file for an archive. Instead, the
3102 add_symbols entry point will call ldlang_add_file, via the
3103 add_archive_element callback, for each element of the archive
3105 switch (bfd_get_format (entry
->the_bfd
))
3111 if (!entry
->flags
.reload
)
3112 ldlang_add_file (entry
);
3116 check_excluded_libs (entry
->the_bfd
);
3118 bfd_set_usrdata (entry
->the_bfd
, entry
);
3119 if (entry
->flags
.whole_archive
)
3127 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
3132 if (!bfd_check_format (member
, bfd_object
))
3134 einfo (_("%F%P: %pB: member %pB in archive is not an object\n"),
3135 entry
->the_bfd
, member
);
3140 if (!(*link_info
.callbacks
3141 ->add_archive_element
) (&link_info
, member
,
3142 "--whole-archive", &subsbfd
))
3145 /* Potentially, the add_archive_element hook may have set a
3146 substitute BFD for us. */
3147 if (!bfd_link_add_symbols (subsbfd
, &link_info
))
3149 einfo (_("%F%P: %pB: error adding symbols: %E\n"), member
);
3154 entry
->flags
.loaded
= loaded
;
3160 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
3161 entry
->flags
.loaded
= true;
3163 einfo (_("%F%P: %pB: error adding symbols: %E\n"), entry
->the_bfd
);
3165 return entry
->flags
.loaded
;
3168 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
3169 may be NULL, indicating that it is a wildcard. Separate
3170 lang_input_section statements are created for each part of the
3171 expansion; they are added after the wild statement S. OUTPUT is
3172 the output section. */
3175 wild (lang_wild_statement_type
*s
,
3176 const char *target ATTRIBUTE_UNUSED
,
3177 lang_output_section_statement_type
*output
)
3179 struct wildcard_list
*sec
;
3181 if (s
->handler_data
[0]
3182 && s
->handler_data
[0]->spec
.sorted
== by_name
3183 && !s
->filenames_sorted
)
3185 lang_section_bst_type
*tree
;
3187 walk_wild (s
, output_section_callback_fast
, output
);
3192 output_section_callback_tree_to_list (s
, tree
, output
);
3197 walk_wild (s
, output_section_callback
, output
);
3199 if (default_common_section
== NULL
)
3200 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
3201 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
3203 /* Remember the section that common is going to in case we
3204 later get something which doesn't know where to put it. */
3205 default_common_section
= output
;
3210 /* Return TRUE iff target is the sought target. */
3213 get_target (const bfd_target
*target
, void *data
)
3215 const char *sought
= (const char *) data
;
3217 return strcmp (target
->name
, sought
) == 0;
3220 /* Like strcpy() but convert to lower case as well. */
3223 stricpy (char *dest
, const char *src
)
3227 while ((c
= *src
++) != 0)
3228 *dest
++ = TOLOWER (c
);
3233 /* Remove the first occurrence of needle (if any) in haystack
3237 strcut (char *haystack
, const char *needle
)
3239 haystack
= strstr (haystack
, needle
);
3245 for (src
= haystack
+ strlen (needle
); *src
;)
3246 *haystack
++ = *src
++;
3252 /* Compare two target format name strings.
3253 Return a value indicating how "similar" they are. */
3256 name_compare (const char *first
, const char *second
)
3262 copy1
= (char *) xmalloc (strlen (first
) + 1);
3263 copy2
= (char *) xmalloc (strlen (second
) + 1);
3265 /* Convert the names to lower case. */
3266 stricpy (copy1
, first
);
3267 stricpy (copy2
, second
);
3269 /* Remove size and endian strings from the name. */
3270 strcut (copy1
, "big");
3271 strcut (copy1
, "little");
3272 strcut (copy2
, "big");
3273 strcut (copy2
, "little");
3275 /* Return a value based on how many characters match,
3276 starting from the beginning. If both strings are
3277 the same then return 10 * their length. */
3278 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
3279 if (copy1
[result
] == 0)
3291 /* Set by closest_target_match() below. */
3292 static const bfd_target
*winner
;
3294 /* Scan all the valid bfd targets looking for one that has the endianness
3295 requirement that was specified on the command line, and is the nearest
3296 match to the original output target. */
3299 closest_target_match (const bfd_target
*target
, void *data
)
3301 const bfd_target
*original
= (const bfd_target
*) data
;
3303 if (command_line
.endian
== ENDIAN_BIG
3304 && target
->byteorder
!= BFD_ENDIAN_BIG
)
3307 if (command_line
.endian
== ENDIAN_LITTLE
3308 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
3311 /* Must be the same flavour. */
3312 if (target
->flavour
!= original
->flavour
)
3315 /* Ignore generic big and little endian elf vectors. */
3316 if (strcmp (target
->name
, "elf32-big") == 0
3317 || strcmp (target
->name
, "elf64-big") == 0
3318 || strcmp (target
->name
, "elf32-little") == 0
3319 || strcmp (target
->name
, "elf64-little") == 0)
3322 /* If we have not found a potential winner yet, then record this one. */
3329 /* Oh dear, we now have two potential candidates for a successful match.
3330 Compare their names and choose the better one. */
3331 if (name_compare (target
->name
, original
->name
)
3332 > name_compare (winner
->name
, original
->name
))
3335 /* Keep on searching until wqe have checked them all. */
3339 /* Return the BFD target format of the first input file. */
3342 get_first_input_target (void)
3344 const char *target
= NULL
;
3346 LANG_FOR_EACH_INPUT_STATEMENT (s
)
3348 if (s
->header
.type
== lang_input_statement_enum
3351 ldfile_open_file (s
);
3353 if (s
->the_bfd
!= NULL
3354 && bfd_check_format (s
->the_bfd
, bfd_object
))
3356 target
= bfd_get_target (s
->the_bfd
);
3368 lang_get_output_target (void)
3372 /* Has the user told us which output format to use? */
3373 if (output_target
!= NULL
)
3374 return output_target
;
3376 /* No - has the current target been set to something other than
3378 if (current_target
!= default_target
&& current_target
!= NULL
)
3379 return current_target
;
3381 /* No - can we determine the format of the first input file? */
3382 target
= get_first_input_target ();
3386 /* Failed - use the default output target. */
3387 return default_target
;
3390 /* Open the output file. */
3393 open_output (const char *name
)
3395 output_target
= lang_get_output_target ();
3397 /* Has the user requested a particular endianness on the command
3399 if (command_line
.endian
!= ENDIAN_UNSET
)
3401 /* Get the chosen target. */
3402 const bfd_target
*target
3403 = bfd_iterate_over_targets (get_target
, (void *) output_target
);
3405 /* If the target is not supported, we cannot do anything. */
3408 enum bfd_endian desired_endian
;
3410 if (command_line
.endian
== ENDIAN_BIG
)
3411 desired_endian
= BFD_ENDIAN_BIG
;
3413 desired_endian
= BFD_ENDIAN_LITTLE
;
3415 /* See if the target has the wrong endianness. This should
3416 not happen if the linker script has provided big and
3417 little endian alternatives, but some scrips don't do
3419 if (target
->byteorder
!= desired_endian
)
3421 /* If it does, then see if the target provides
3422 an alternative with the correct endianness. */
3423 if (target
->alternative_target
!= NULL
3424 && (target
->alternative_target
->byteorder
== desired_endian
))
3425 output_target
= target
->alternative_target
->name
;
3428 /* Try to find a target as similar as possible to
3429 the default target, but which has the desired
3430 endian characteristic. */
3431 bfd_iterate_over_targets (closest_target_match
,
3434 /* Oh dear - we could not find any targets that
3435 satisfy our requirements. */
3437 einfo (_("%P: warning: could not find any targets"
3438 " that match endianness requirement\n"));
3440 output_target
= winner
->name
;
3446 link_info
.output_bfd
= bfd_openw (name
, output_target
);
3448 if (link_info
.output_bfd
== NULL
)
3450 if (bfd_get_error () == bfd_error_invalid_target
)
3451 einfo (_("%F%P: target %s not found\n"), output_target
);
3453 einfo (_("%F%P: cannot open output file %s: %E\n"), name
);
3456 delete_output_file_on_failure
= true;
3458 if (!bfd_set_format (link_info
.output_bfd
, bfd_object
))
3459 einfo (_("%F%P: %s: can not make object file: %E\n"), name
);
3460 if (!bfd_set_arch_mach (link_info
.output_bfd
,
3461 ldfile_output_architecture
,
3462 ldfile_output_machine
))
3463 einfo (_("%F%P: %s: can not set architecture: %E\n"), name
);
3465 link_info
.hash
= bfd_link_hash_table_create (link_info
.output_bfd
);
3466 if (link_info
.hash
== NULL
)
3467 einfo (_("%F%P: can not create hash table: %E\n"));
3469 bfd_set_gp_size (link_info
.output_bfd
, g_switch_value
);
3473 ldlang_open_output (lang_statement_union_type
*statement
)
3475 switch (statement
->header
.type
)
3477 case lang_output_statement_enum
:
3478 ASSERT (link_info
.output_bfd
== NULL
);
3479 open_output (statement
->output_statement
.name
);
3480 ldemul_set_output_arch ();
3481 if (config
.magic_demand_paged
3482 && !bfd_link_relocatable (&link_info
))
3483 link_info
.output_bfd
->flags
|= D_PAGED
;
3485 link_info
.output_bfd
->flags
&= ~D_PAGED
;
3486 if (config
.text_read_only
)
3487 link_info
.output_bfd
->flags
|= WP_TEXT
;
3489 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
3490 if (link_info
.traditional_format
)
3491 link_info
.output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
3493 link_info
.output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
3496 case lang_target_statement_enum
:
3497 current_target
= statement
->target_statement
.target
;
3505 init_opb (asection
*s
)
3510 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
3512 && (s
->flags
& SEC_ELF_OCTETS
) != 0)
3515 x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3516 ldfile_output_machine
);
3518 while ((x
& 1) == 0)
3526 /* Open all the input files. */
3530 OPEN_BFD_NORMAL
= 0,
3534 #if BFD_SUPPORTS_PLUGINS
3535 static lang_input_statement_type
*plugin_insert
= NULL
;
3536 static struct bfd_link_hash_entry
*plugin_undefs
= NULL
;
3540 open_input_bfds (lang_statement_union_type
*s
, enum open_bfd_mode mode
)
3542 for (; s
!= NULL
; s
= s
->header
.next
)
3544 switch (s
->header
.type
)
3546 case lang_constructors_statement_enum
:
3547 open_input_bfds (constructor_list
.head
, mode
);
3549 case lang_output_section_statement_enum
:
3550 open_input_bfds (s
->output_section_statement
.children
.head
, mode
);
3552 case lang_wild_statement_enum
:
3553 /* Maybe we should load the file's symbols. */
3554 if ((mode
& OPEN_BFD_RESCAN
) == 0
3555 && s
->wild_statement
.filename
3556 && !wildcardp (s
->wild_statement
.filename
)
3557 && !archive_path (s
->wild_statement
.filename
))
3558 lookup_name (s
->wild_statement
.filename
);
3559 open_input_bfds (s
->wild_statement
.children
.head
, mode
);
3561 case lang_group_statement_enum
:
3563 struct bfd_link_hash_entry
*undefs
;
3564 #if BFD_SUPPORTS_PLUGINS
3565 lang_input_statement_type
*plugin_insert_save
;
3568 /* We must continually search the entries in the group
3569 until no new symbols are added to the list of undefined
3574 #if BFD_SUPPORTS_PLUGINS
3575 plugin_insert_save
= plugin_insert
;
3577 undefs
= link_info
.hash
->undefs_tail
;
3578 open_input_bfds (s
->group_statement
.children
.head
,
3579 mode
| OPEN_BFD_FORCE
);
3581 while (undefs
!= link_info
.hash
->undefs_tail
3582 #if BFD_SUPPORTS_PLUGINS
3583 /* Objects inserted by a plugin, which are loaded
3584 before we hit this loop, may have added new
3586 || (plugin_insert
!= plugin_insert_save
&& plugin_undefs
)
3591 case lang_target_statement_enum
:
3592 current_target
= s
->target_statement
.target
;
3594 case lang_input_statement_enum
:
3595 if (s
->input_statement
.flags
.real
)
3597 lang_statement_union_type
**os_tail
;
3598 lang_statement_list_type add
;
3601 s
->input_statement
.target
= current_target
;
3603 /* If we are being called from within a group, and this
3604 is an archive which has already been searched, then
3605 force it to be researched unless the whole archive
3606 has been loaded already. Do the same for a rescan.
3607 Likewise reload --as-needed shared libs. */
3608 if (mode
!= OPEN_BFD_NORMAL
3609 #if BFD_SUPPORTS_PLUGINS
3610 && ((mode
& OPEN_BFD_RESCAN
) == 0
3611 || plugin_insert
== NULL
)
3613 && s
->input_statement
.flags
.loaded
3614 && (abfd
= s
->input_statement
.the_bfd
) != NULL
3615 && ((bfd_get_format (abfd
) == bfd_archive
3616 && !s
->input_statement
.flags
.whole_archive
)
3617 || (bfd_get_format (abfd
) == bfd_object
3618 && ((abfd
->flags
) & DYNAMIC
) != 0
3619 && s
->input_statement
.flags
.add_DT_NEEDED_for_regular
3620 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3621 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)))
3623 s
->input_statement
.flags
.loaded
= false;
3624 s
->input_statement
.flags
.reload
= true;
3627 os_tail
= lang_os_list
.tail
;
3628 lang_list_init (&add
);
3630 if (!load_symbols (&s
->input_statement
, &add
))
3631 config
.make_executable
= false;
3633 if (add
.head
!= NULL
)
3635 /* If this was a script with output sections then
3636 tack any added statements on to the end of the
3637 list. This avoids having to reorder the output
3638 section statement list. Very likely the user
3639 forgot -T, and whatever we do here will not meet
3640 naive user expectations. */
3641 if (os_tail
!= lang_os_list
.tail
)
3643 einfo (_("%P: warning: %s contains output sections;"
3644 " did you forget -T?\n"),
3645 s
->input_statement
.filename
);
3646 *stat_ptr
->tail
= add
.head
;
3647 stat_ptr
->tail
= add
.tail
;
3651 *add
.tail
= s
->header
.next
;
3652 s
->header
.next
= add
.head
;
3656 #if BFD_SUPPORTS_PLUGINS
3657 /* If we have found the point at which a plugin added new
3658 files, clear plugin_insert to enable archive rescan. */
3659 if (&s
->input_statement
== plugin_insert
)
3660 plugin_insert
= NULL
;
3663 case lang_assignment_statement_enum
:
3664 if (s
->assignment_statement
.exp
->type
.node_class
!= etree_assert
)
3665 exp_fold_tree_no_dot (s
->assignment_statement
.exp
);
3672 /* Exit if any of the files were missing. */
3673 if (input_flags
.missing_file
)
3677 #ifdef ENABLE_LIBCTF
3678 /* Emit CTF errors and warnings. fp can be NULL to report errors/warnings
3679 that happened specifically at CTF open time. */
3681 lang_ctf_errs_warnings (ctf_dict_t
*fp
)
3683 ctf_next_t
*i
= NULL
;
3688 while ((text
= ctf_errwarning_next (fp
, &i
, &is_warning
, &err
)) != NULL
)
3690 einfo (_("%s: %s\n"), is_warning
? _("CTF warning"): _("CTF error"),
3694 if (err
!= ECTF_NEXT_END
)
3696 einfo (_("CTF error: cannot get CTF errors: `%s'\n"),
3700 /* `err' returns errors from the error/warning iterator in particular.
3701 These never assert. But if we have an fp, that could have recorded
3702 an assertion failure: assert if it has done so. */
3703 ASSERT (!fp
|| ctf_errno (fp
) != ECTF_INTERNAL
);
3706 /* Open the CTF sections in the input files with libctf: if any were opened,
3707 create a fake input file that we'll write the merged CTF data to later
3711 ldlang_open_ctf (void)
3716 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3720 /* Incoming files from the compiler have a single ctf_dict_t in them
3721 (which is presented to us by the libctf API in a ctf_archive_t
3722 wrapper): files derived from a previous relocatable link have a CTF
3723 archive containing possibly many CTF files. */
3725 if ((file
->the_ctf
= ctf_bfdopen (file
->the_bfd
, &err
)) == NULL
)
3727 if (err
!= ECTF_NOCTFDATA
)
3729 lang_ctf_errs_warnings (NULL
);
3730 einfo (_("%P: warning: CTF section in %pB not loaded; "
3731 "its types will be discarded: %s\n"), file
->the_bfd
,
3737 /* Prevent the contents of this section from being written, while
3738 requiring the section itself to be duplicated in the output, but only
3740 /* This section must exist if ctf_bfdopen() succeeded. */
3741 sect
= bfd_get_section_by_name (file
->the_bfd
, ".ctf");
3743 sect
->flags
|= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
| SEC_LINKER_CREATED
;
3746 sect
->flags
|= SEC_EXCLUDE
;
3756 if ((ctf_output
= ctf_create (&err
)) != NULL
)
3759 einfo (_("%P: warning: CTF output not created: `%s'\n"),
3762 LANG_FOR_EACH_INPUT_STATEMENT (errfile
)
3763 ctf_close (errfile
->the_ctf
);
3766 /* Merge together CTF sections. After this, only the symtab-dependent
3767 function and data object sections need adjustment. */
3770 lang_merge_ctf (void)
3772 asection
*output_sect
;
3778 output_sect
= bfd_get_section_by_name (link_info
.output_bfd
, ".ctf");
3780 /* If the section was discarded, don't waste time merging. */
3781 if (output_sect
== NULL
)
3783 ctf_dict_close (ctf_output
);
3786 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3788 ctf_close (file
->the_ctf
);
3789 file
->the_ctf
= NULL
;
3794 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3799 /* Takes ownership of file->the_ctf. */
3800 if (ctf_link_add_ctf (ctf_output
, file
->the_ctf
, file
->filename
) < 0)
3802 einfo (_("%P: warning: CTF section in %pB cannot be linked: `%s'\n"),
3803 file
->the_bfd
, ctf_errmsg (ctf_errno (ctf_output
)));
3804 ctf_close (file
->the_ctf
);
3805 file
->the_ctf
= NULL
;
3810 if (!config
.ctf_share_duplicated
)
3811 flags
= CTF_LINK_SHARE_UNCONFLICTED
;
3813 flags
= CTF_LINK_SHARE_DUPLICATED
;
3814 if (!config
.ctf_variables
)
3815 flags
|= CTF_LINK_OMIT_VARIABLES_SECTION
;
3816 if (bfd_link_relocatable (&link_info
))
3817 flags
|= CTF_LINK_NO_FILTER_REPORTED_SYMS
;
3819 if (ctf_link (ctf_output
, flags
) < 0)
3821 lang_ctf_errs_warnings (ctf_output
);
3822 einfo (_("%P: warning: CTF linking failed; "
3823 "output will have no CTF section: %s\n"),
3824 ctf_errmsg (ctf_errno (ctf_output
)));
3827 output_sect
->size
= 0;
3828 output_sect
->flags
|= SEC_EXCLUDE
;
3831 /* Output any lingering errors that didn't come from ctf_link. */
3832 lang_ctf_errs_warnings (ctf_output
);
3835 /* Let the emulation acquire strings from the dynamic strtab to help it optimize
3836 the CTF, if supported. */
3839 ldlang_ctf_acquire_strings (struct elf_strtab_hash
*dynstrtab
)
3841 ldemul_acquire_strings_for_ctf (ctf_output
, dynstrtab
);
3844 /* Inform the emulation about the addition of a new dynamic symbol, in BFD
3846 void ldlang_ctf_new_dynsym (int symidx
, struct elf_internal_sym
*sym
)
3848 ldemul_new_dynsym_for_ctf (ctf_output
, symidx
, sym
);
3851 /* Write out the CTF section. Called early, if the emulation isn't going to
3852 need to dedup against the strtab and symtab, then possibly called from the
3853 target linker code if the dedup has happened. */
3855 lang_write_ctf (int late
)
3858 asection
*output_sect
;
3865 /* Emit CTF late if this emulation says it can do so. */
3866 if (ldemul_emit_ctf_early ())
3871 if (!ldemul_emit_ctf_early ())
3875 /* Inform the emulation that all the symbols that will be received have
3878 ldemul_new_dynsym_for_ctf (ctf_output
, 0, NULL
);
3882 output_sect
= bfd_get_section_by_name (link_info
.output_bfd
, ".ctf");
3885 output_sect
->contents
= ctf_link_write (ctf_output
, &output_size
,
3886 CTF_COMPRESSION_THRESHOLD
);
3887 output_sect
->size
= output_size
;
3888 output_sect
->flags
|= SEC_IN_MEMORY
| SEC_KEEP
;
3890 lang_ctf_errs_warnings (ctf_output
);
3891 if (!output_sect
->contents
)
3893 einfo (_("%P: warning: CTF section emission failed; "
3894 "output will have no CTF section: %s\n"),
3895 ctf_errmsg (ctf_errno (ctf_output
)));
3896 output_sect
->size
= 0;
3897 output_sect
->flags
|= SEC_EXCLUDE
;
3901 /* This also closes every CTF input file used in the link. */
3902 ctf_dict_close (ctf_output
);
3905 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3906 file
->the_ctf
= NULL
;
3909 /* Write out the CTF section late, if the emulation needs that. */
3912 ldlang_write_ctf_late (void)
3914 /* Trigger a "late call", if the emulation needs one. */
3920 ldlang_open_ctf (void)
3922 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3926 /* If built without CTF, warn and delete all CTF sections from the output.
3927 (The alternative would be to simply concatenate them, which does not
3928 yield a valid CTF section.) */
3930 if ((sect
= bfd_get_section_by_name (file
->the_bfd
, ".ctf")) != NULL
)
3932 einfo (_("%P: warning: CTF section in %pB not linkable: "
3933 "%P was built without support for CTF\n"), file
->the_bfd
);
3935 sect
->flags
|= SEC_EXCLUDE
;
3940 static void lang_merge_ctf (void) {}
3942 ldlang_ctf_acquire_strings (struct elf_strtab_hash
*dynstrtab
3943 ATTRIBUTE_UNUSED
) {}
3945 ldlang_ctf_new_dynsym (int symidx ATTRIBUTE_UNUSED
,
3946 struct elf_internal_sym
*sym ATTRIBUTE_UNUSED
) {}
3947 static void lang_write_ctf (int late ATTRIBUTE_UNUSED
) {}
3948 void ldlang_write_ctf_late (void) {}
3951 /* Add the supplied name to the symbol table as an undefined reference.
3952 This is a two step process as the symbol table doesn't even exist at
3953 the time the ld command line is processed. First we put the name
3954 on a list, then, once the output file has been opened, transfer the
3955 name to the symbol table. */
3957 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3959 #define ldlang_undef_chain_list_head entry_symbol.next
3962 ldlang_add_undef (const char *const name
, bool cmdline ATTRIBUTE_UNUSED
)
3964 ldlang_undef_chain_list_type
*new_undef
;
3966 new_undef
= stat_alloc (sizeof (*new_undef
));
3967 new_undef
->next
= ldlang_undef_chain_list_head
;
3968 ldlang_undef_chain_list_head
= new_undef
;
3970 new_undef
->name
= xstrdup (name
);
3972 if (link_info
.output_bfd
!= NULL
)
3973 insert_undefined (new_undef
->name
);
3976 /* Insert NAME as undefined in the symbol table. */
3979 insert_undefined (const char *name
)
3981 struct bfd_link_hash_entry
*h
;
3983 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, false, true);
3985 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
3986 if (h
->type
== bfd_link_hash_new
)
3988 h
->type
= bfd_link_hash_undefined
;
3989 h
->u
.undef
.abfd
= NULL
;
3990 h
->non_ir_ref_regular
= true;
3991 bfd_link_add_undef (link_info
.hash
, h
);
3995 /* Run through the list of undefineds created above and place them
3996 into the linker hash table as undefined symbols belonging to the
4000 lang_place_undefineds (void)
4002 ldlang_undef_chain_list_type
*ptr
;
4004 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
4005 insert_undefined (ptr
->name
);
4008 /* Mark -u symbols against garbage collection. */
4011 lang_mark_undefineds (void)
4013 ldlang_undef_chain_list_type
*ptr
;
4015 if (is_elf_hash_table (link_info
.hash
))
4016 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
4018 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*)
4019 bfd_link_hash_lookup (link_info
.hash
, ptr
->name
, false, false, true);
4025 /* Structure used to build the list of symbols that the user has required
4028 struct require_defined_symbol
4031 struct require_defined_symbol
*next
;
4034 /* The list of symbols that the user has required be defined. */
4036 static struct require_defined_symbol
*require_defined_symbol_list
;
4038 /* Add a new symbol NAME to the list of symbols that are required to be
4042 ldlang_add_require_defined (const char *const name
)
4044 struct require_defined_symbol
*ptr
;
4046 ldlang_add_undef (name
, true);
4047 ptr
= stat_alloc (sizeof (*ptr
));
4048 ptr
->next
= require_defined_symbol_list
;
4049 ptr
->name
= strdup (name
);
4050 require_defined_symbol_list
= ptr
;
4053 /* Check that all symbols the user required to be defined, are defined,
4054 raise an error if we find a symbol that is not defined. */
4057 ldlang_check_require_defined_symbols (void)
4059 struct require_defined_symbol
*ptr
;
4061 for (ptr
= require_defined_symbol_list
; ptr
!= NULL
; ptr
= ptr
->next
)
4063 struct bfd_link_hash_entry
*h
;
4065 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
,
4066 false, false, true);
4068 || (h
->type
!= bfd_link_hash_defined
4069 && h
->type
!= bfd_link_hash_defweak
))
4070 einfo(_("%X%P: required symbol `%s' not defined\n"), ptr
->name
);
4074 /* Check for all readonly or some readwrite sections. */
4077 check_input_sections
4078 (lang_statement_union_type
*s
,
4079 lang_output_section_statement_type
*output_section_statement
)
4081 for (; s
!= NULL
; s
= s
->header
.next
)
4083 switch (s
->header
.type
)
4085 case lang_wild_statement_enum
:
4086 walk_wild (&s
->wild_statement
, check_section_callback
,
4087 output_section_statement
);
4088 if (!output_section_statement
->all_input_readonly
)
4091 case lang_constructors_statement_enum
:
4092 check_input_sections (constructor_list
.head
,
4093 output_section_statement
);
4094 if (!output_section_statement
->all_input_readonly
)
4097 case lang_group_statement_enum
:
4098 check_input_sections (s
->group_statement
.children
.head
,
4099 output_section_statement
);
4100 if (!output_section_statement
->all_input_readonly
)
4109 /* Update wildcard statements if needed. */
4112 update_wild_statements (lang_statement_union_type
*s
)
4114 struct wildcard_list
*sec
;
4116 switch (sort_section
)
4126 for (; s
!= NULL
; s
= s
->header
.next
)
4128 switch (s
->header
.type
)
4133 case lang_wild_statement_enum
:
4134 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
4136 /* Don't sort .init/.fini sections. */
4137 if (strcmp (sec
->spec
.name
, ".init") != 0
4138 && strcmp (sec
->spec
.name
, ".fini") != 0)
4139 switch (sec
->spec
.sorted
)
4142 sec
->spec
.sorted
= sort_section
;
4145 if (sort_section
== by_alignment
)
4146 sec
->spec
.sorted
= by_name_alignment
;
4149 if (sort_section
== by_name
)
4150 sec
->spec
.sorted
= by_alignment_name
;
4157 case lang_constructors_statement_enum
:
4158 update_wild_statements (constructor_list
.head
);
4161 case lang_output_section_statement_enum
:
4162 update_wild_statements
4163 (s
->output_section_statement
.children
.head
);
4166 case lang_group_statement_enum
:
4167 update_wild_statements (s
->group_statement
.children
.head
);
4175 /* Open input files and attach to output sections. */
4178 map_input_to_output_sections
4179 (lang_statement_union_type
*s
, const char *target
,
4180 lang_output_section_statement_type
*os
)
4182 for (; s
!= NULL
; s
= s
->header
.next
)
4184 lang_output_section_statement_type
*tos
;
4187 switch (s
->header
.type
)
4189 case lang_wild_statement_enum
:
4190 wild (&s
->wild_statement
, target
, os
);
4192 case lang_constructors_statement_enum
:
4193 map_input_to_output_sections (constructor_list
.head
,
4197 case lang_output_section_statement_enum
:
4198 tos
= &s
->output_section_statement
;
4199 if (tos
->constraint
== ONLY_IF_RW
4200 || tos
->constraint
== ONLY_IF_RO
)
4202 tos
->all_input_readonly
= true;
4203 check_input_sections (tos
->children
.head
, tos
);
4204 if (tos
->all_input_readonly
!= (tos
->constraint
== ONLY_IF_RO
))
4205 tos
->constraint
= -1;
4207 if (tos
->constraint
>= 0)
4208 map_input_to_output_sections (tos
->children
.head
,
4212 case lang_output_statement_enum
:
4214 case lang_target_statement_enum
:
4215 target
= s
->target_statement
.target
;
4217 case lang_group_statement_enum
:
4218 map_input_to_output_sections (s
->group_statement
.children
.head
,
4222 case lang_data_statement_enum
:
4223 /* Make sure that any sections mentioned in the expression
4225 exp_init_os (s
->data_statement
.exp
);
4226 /* The output section gets CONTENTS, ALLOC and LOAD, but
4227 these may be overridden by the script. */
4228 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
;
4229 switch (os
->sectype
)
4231 case normal_section
:
4232 case overlay_section
:
4233 case first_overlay_section
:
4235 case noalloc_section
:
4236 flags
= SEC_HAS_CONTENTS
;
4238 case readonly_section
:
4239 flags
|= SEC_READONLY
;
4241 case noload_section
:
4242 if (bfd_get_flavour (link_info
.output_bfd
)
4243 == bfd_target_elf_flavour
)
4244 flags
= SEC_NEVER_LOAD
| SEC_ALLOC
;
4246 flags
= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
;
4249 if (os
->bfd_section
== NULL
)
4250 init_os (os
, flags
| SEC_READONLY
);
4252 os
->bfd_section
->flags
|= flags
;
4254 case lang_input_section_enum
:
4256 case lang_fill_statement_enum
:
4257 case lang_object_symbols_statement_enum
:
4258 case lang_reloc_statement_enum
:
4259 case lang_padding_statement_enum
:
4260 case lang_input_statement_enum
:
4261 if (os
!= NULL
&& os
->bfd_section
== NULL
)
4264 case lang_assignment_statement_enum
:
4265 if (os
!= NULL
&& os
->bfd_section
== NULL
)
4268 /* Make sure that any sections mentioned in the assignment
4270 exp_init_os (s
->assignment_statement
.exp
);
4272 case lang_address_statement_enum
:
4273 /* Mark the specified section with the supplied address.
4274 If this section was actually a segment marker, then the
4275 directive is ignored if the linker script explicitly
4276 processed the segment marker. Originally, the linker
4277 treated segment directives (like -Ttext on the
4278 command-line) as section directives. We honor the
4279 section directive semantics for backwards compatibility;
4280 linker scripts that do not specifically check for
4281 SEGMENT_START automatically get the old semantics. */
4282 if (!s
->address_statement
.segment
4283 || !s
->address_statement
.segment
->used
)
4285 const char *name
= s
->address_statement
.section_name
;
4287 /* Create the output section statement here so that
4288 orphans with a set address will be placed after other
4289 script sections. If we let the orphan placement code
4290 place them in amongst other sections then the address
4291 will affect following script sections, which is
4292 likely to surprise naive users. */
4293 tos
= lang_output_section_statement_lookup (name
, 0, 1);
4294 tos
->addr_tree
= s
->address_statement
.address
;
4295 if (tos
->bfd_section
== NULL
)
4299 case lang_insert_statement_enum
:
4305 /* An insert statement snips out all the linker statements from the
4306 start of the list and places them after the output section
4307 statement specified by the insert. This operation is complicated
4308 by the fact that we keep a doubly linked list of output section
4309 statements as well as the singly linked list of all statements.
4310 FIXME someday: Twiddling with the list not only moves statements
4311 from the user's script but also input and group statements that are
4312 built from command line object files and --start-group. We only
4313 get away with this because the list pointers used by file_chain
4314 and input_file_chain are not reordered, and processing via
4315 statement_list after this point mostly ignores input statements.
4316 One exception is the map file, where LOAD and START GROUP/END GROUP
4317 can end up looking odd. */
4320 process_insert_statements (lang_statement_union_type
**start
)
4322 lang_statement_union_type
**s
;
4323 lang_output_section_statement_type
*first_os
= NULL
;
4324 lang_output_section_statement_type
*last_os
= NULL
;
4325 lang_output_section_statement_type
*os
;
4330 if ((*s
)->header
.type
== lang_output_section_statement_enum
)
4332 /* Keep pointers to the first and last output section
4333 statement in the sequence we may be about to move. */
4334 os
= &(*s
)->output_section_statement
;
4336 ASSERT (last_os
== NULL
|| last_os
->next
== os
);
4339 /* Set constraint negative so that lang_output_section_find
4340 won't match this output section statement. At this
4341 stage in linking constraint has values in the range
4342 [-1, ONLY_IN_RW]. */
4343 last_os
->constraint
= -2 - last_os
->constraint
;
4344 if (first_os
== NULL
)
4347 else if ((*s
)->header
.type
== lang_group_statement_enum
)
4349 /* A user might put -T between --start-group and
4350 --end-group. One way this odd construct might arise is
4351 from a wrapper around ld to change library search
4352 behaviour. For example:
4354 exec real_ld --start-group "$@" --end-group
4355 This isn't completely unreasonable so go looking inside a
4356 group statement for insert statements. */
4357 process_insert_statements (&(*s
)->group_statement
.children
.head
);
4359 else if ((*s
)->header
.type
== lang_insert_statement_enum
)
4361 lang_insert_statement_type
*i
= &(*s
)->insert_statement
;
4362 lang_output_section_statement_type
*where
;
4363 lang_statement_union_type
**ptr
;
4364 lang_statement_union_type
*first
;
4366 if (link_info
.non_contiguous_regions
)
4368 einfo (_("warning: INSERT statement in linker script is "
4369 "incompatible with --enable-non-contiguous-regions.\n"));
4372 where
= lang_output_section_find (i
->where
);
4373 if (where
!= NULL
&& i
->is_before
)
4376 where
= where
->prev
;
4377 while (where
!= NULL
&& where
->constraint
< 0);
4381 einfo (_("%F%P: %s not found for insert\n"), i
->where
);
4385 /* Deal with reordering the output section statement list. */
4386 if (last_os
!= NULL
)
4388 asection
*first_sec
, *last_sec
;
4389 struct lang_output_section_statement_struct
**next
;
4391 /* Snip out the output sections we are moving. */
4392 first_os
->prev
->next
= last_os
->next
;
4393 if (last_os
->next
== NULL
)
4395 next
= &first_os
->prev
->next
;
4396 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4399 last_os
->next
->prev
= first_os
->prev
;
4400 /* Add them in at the new position. */
4401 last_os
->next
= where
->next
;
4402 if (where
->next
== NULL
)
4404 next
= &last_os
->next
;
4405 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4408 where
->next
->prev
= last_os
;
4409 first_os
->prev
= where
;
4410 where
->next
= first_os
;
4412 /* Move the bfd sections in the same way. */
4415 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4417 os
->constraint
= -2 - os
->constraint
;
4418 if (os
->bfd_section
!= NULL
4419 && os
->bfd_section
->owner
!= NULL
)
4421 last_sec
= os
->bfd_section
;
4422 if (first_sec
== NULL
)
4423 first_sec
= last_sec
;
4428 if (last_sec
!= NULL
)
4430 asection
*sec
= where
->bfd_section
;
4432 sec
= output_prev_sec_find (where
);
4434 /* The place we want to insert must come after the
4435 sections we are moving. So if we find no
4436 section or if the section is the same as our
4437 last section, then no move is needed. */
4438 if (sec
!= NULL
&& sec
!= last_sec
)
4440 /* Trim them off. */
4441 if (first_sec
->prev
!= NULL
)
4442 first_sec
->prev
->next
= last_sec
->next
;
4444 link_info
.output_bfd
->sections
= last_sec
->next
;
4445 if (last_sec
->next
!= NULL
)
4446 last_sec
->next
->prev
= first_sec
->prev
;
4448 link_info
.output_bfd
->section_last
= first_sec
->prev
;
4450 last_sec
->next
= sec
->next
;
4451 if (sec
->next
!= NULL
)
4452 sec
->next
->prev
= last_sec
;
4454 link_info
.output_bfd
->section_last
= last_sec
;
4455 first_sec
->prev
= sec
;
4456 sec
->next
= first_sec
;
4464 ptr
= insert_os_after (where
);
4465 /* Snip everything from the start of the list, up to and
4466 including the insert statement we are currently processing. */
4468 *start
= (*s
)->header
.next
;
4469 /* Add them back where they belong, minus the insert. */
4472 statement_list
.tail
= s
;
4477 s
= &(*s
)->header
.next
;
4480 /* Undo constraint twiddling. */
4481 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4483 os
->constraint
= -2 - os
->constraint
;
4489 /* An output section might have been removed after its statement was
4490 added. For example, ldemul_before_allocation can remove dynamic
4491 sections if they turn out to be not needed. Clean them up here. */
4494 strip_excluded_output_sections (void)
4496 lang_output_section_statement_type
*os
;
4498 /* Run lang_size_sections (if not already done). */
4499 if (expld
.phase
!= lang_mark_phase_enum
)
4501 expld
.phase
= lang_mark_phase_enum
;
4502 expld
.dataseg
.phase
= exp_seg_none
;
4503 one_lang_size_sections_pass (NULL
, false);
4504 lang_reset_memory_regions ();
4507 for (os
= (void *) lang_os_list
.head
;
4511 asection
*output_section
;
4514 if (os
->constraint
< 0)
4517 output_section
= os
->bfd_section
;
4518 if (output_section
== NULL
)
4521 exclude
= (output_section
->rawsize
== 0
4522 && (output_section
->flags
& SEC_KEEP
) == 0
4523 && !bfd_section_removed_from_list (link_info
.output_bfd
,
4526 /* Some sections have not yet been sized, notably .gnu.version,
4527 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
4528 input sections, so don't drop output sections that have such
4529 input sections unless they are also marked SEC_EXCLUDE. */
4530 if (exclude
&& output_section
->map_head
.s
!= NULL
)
4534 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
4535 if ((s
->flags
& SEC_EXCLUDE
) == 0
4536 && ((s
->flags
& SEC_LINKER_CREATED
) != 0
4537 || link_info
.emitrelocations
))
4546 /* We don't set bfd_section to NULL since bfd_section of the
4547 removed output section statement may still be used. */
4548 if (!os
->update_dot
)
4550 output_section
->flags
|= SEC_EXCLUDE
;
4551 bfd_section_list_remove (link_info
.output_bfd
, output_section
);
4552 link_info
.output_bfd
->section_count
--;
4557 /* Called from ldwrite to clear out asection.map_head and
4558 asection.map_tail for use as link_orders in ldwrite. */
4561 lang_clear_os_map (void)
4563 lang_output_section_statement_type
*os
;
4565 if (map_head_is_link_order
)
4568 for (os
= (void *) lang_os_list
.head
;
4572 asection
*output_section
;
4574 if (os
->constraint
< 0)
4577 output_section
= os
->bfd_section
;
4578 if (output_section
== NULL
)
4581 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
4582 output_section
->map_head
.link_order
= NULL
;
4583 output_section
->map_tail
.link_order
= NULL
;
4586 /* Stop future calls to lang_add_section from messing with map_head
4587 and map_tail link_order fields. */
4588 map_head_is_link_order
= true;
4592 print_output_section_statement
4593 (lang_output_section_statement_type
*output_section_statement
)
4595 asection
*section
= output_section_statement
->bfd_section
;
4598 if (output_section_statement
!= abs_output_section
)
4600 minfo ("\n%s", output_section_statement
->name
);
4602 if (section
!= NULL
)
4604 print_dot
= section
->vma
;
4606 len
= strlen (output_section_statement
->name
);
4607 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4612 while (len
< SECTION_NAME_MAP_LENGTH
)
4618 minfo ("0x%V %W", section
->vma
, TO_ADDR (section
->size
));
4620 if (section
->vma
!= section
->lma
)
4621 minfo (_(" load address 0x%V"), section
->lma
);
4623 if (output_section_statement
->update_dot_tree
!= NULL
)
4624 exp_fold_tree (output_section_statement
->update_dot_tree
,
4625 bfd_abs_section_ptr
, &print_dot
);
4631 print_statement_list (output_section_statement
->children
.head
,
4632 output_section_statement
);
4636 print_assignment (lang_assignment_statement_type
*assignment
,
4637 lang_output_section_statement_type
*output_section
)
4644 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4647 if (assignment
->exp
->type
.node_class
== etree_assert
)
4650 tree
= assignment
->exp
->assert_s
.child
;
4654 const char *dst
= assignment
->exp
->assign
.dst
;
4656 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
4657 tree
= assignment
->exp
;
4660 osec
= output_section
->bfd_section
;
4662 osec
= bfd_abs_section_ptr
;
4664 if (assignment
->exp
->type
.node_class
!= etree_provide
)
4665 exp_fold_tree (tree
, osec
, &print_dot
);
4667 expld
.result
.valid_p
= false;
4669 if (expld
.result
.valid_p
)
4673 if (assignment
->exp
->type
.node_class
== etree_assert
4675 || expld
.assign_name
!= NULL
)
4677 value
= expld
.result
.value
;
4679 if (expld
.result
.section
!= NULL
)
4680 value
+= expld
.result
.section
->vma
;
4682 minfo ("0x%V", value
);
4688 struct bfd_link_hash_entry
*h
;
4690 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
4691 false, false, true);
4693 && (h
->type
== bfd_link_hash_defined
4694 || h
->type
== bfd_link_hash_defweak
))
4696 value
= h
->u
.def
.value
;
4697 value
+= h
->u
.def
.section
->output_section
->vma
;
4698 value
+= h
->u
.def
.section
->output_offset
;
4700 minfo ("[0x%V]", value
);
4703 minfo ("[unresolved]");
4708 if (assignment
->exp
->type
.node_class
== etree_provide
)
4709 minfo ("[!provide]");
4716 expld
.assign_name
= NULL
;
4719 exp_print_tree (assignment
->exp
);
4724 print_input_statement (lang_input_statement_type
*statm
)
4726 if (statm
->filename
!= NULL
)
4727 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
4730 /* Print all symbols defined in a particular section. This is called
4731 via bfd_link_hash_traverse, or by print_all_symbols. */
4734 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
4736 asection
*sec
= (asection
*) ptr
;
4738 if ((hash_entry
->type
== bfd_link_hash_defined
4739 || hash_entry
->type
== bfd_link_hash_defweak
)
4740 && sec
== hash_entry
->u
.def
.section
)
4744 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4747 (hash_entry
->u
.def
.value
4748 + hash_entry
->u
.def
.section
->output_offset
4749 + hash_entry
->u
.def
.section
->output_section
->vma
));
4751 minfo (" %pT\n", hash_entry
->root
.string
);
4758 hash_entry_addr_cmp (const void *a
, const void *b
)
4760 const struct bfd_link_hash_entry
*l
= *(const struct bfd_link_hash_entry
**)a
;
4761 const struct bfd_link_hash_entry
*r
= *(const struct bfd_link_hash_entry
**)b
;
4763 if (l
->u
.def
.value
< r
->u
.def
.value
)
4765 else if (l
->u
.def
.value
> r
->u
.def
.value
)
4772 print_all_symbols (asection
*sec
)
4774 input_section_userdata_type
*ud
= bfd_section_userdata (sec
);
4775 struct map_symbol_def
*def
;
4776 struct bfd_link_hash_entry
**entries
;
4782 *ud
->map_symbol_def_tail
= 0;
4784 /* Sort the symbols by address. */
4785 entries
= (struct bfd_link_hash_entry
**)
4786 obstack_alloc (&map_obstack
,
4787 ud
->map_symbol_def_count
* sizeof (*entries
));
4789 for (i
= 0, def
= ud
->map_symbol_def_head
; def
; def
= def
->next
, i
++)
4790 entries
[i
] = def
->entry
;
4792 qsort (entries
, ud
->map_symbol_def_count
, sizeof (*entries
),
4793 hash_entry_addr_cmp
);
4795 /* Print the symbols. */
4796 for (i
= 0; i
< ud
->map_symbol_def_count
; i
++)
4797 ldemul_print_symbol (entries
[i
], sec
);
4799 obstack_free (&map_obstack
, entries
);
4802 /* Print information about an input section to the map file. */
4805 print_input_section (asection
*i
, bool is_discarded
)
4807 bfd_size_type size
= i
->size
;
4814 minfo ("%s", i
->name
);
4816 len
= 1 + strlen (i
->name
);
4817 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4822 while (len
< SECTION_NAME_MAP_LENGTH
)
4828 if (i
->output_section
!= NULL
4829 && i
->output_section
->owner
== link_info
.output_bfd
)
4830 addr
= i
->output_section
->vma
+ i
->output_offset
;
4838 minfo ("0x%V %W %pB\n", addr
, TO_ADDR (size
), i
->owner
);
4840 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
4842 len
= SECTION_NAME_MAP_LENGTH
+ 3;
4854 minfo (_("%W (size before relaxing)\n"), TO_ADDR (i
->rawsize
));
4857 if (i
->output_section
!= NULL
4858 && i
->output_section
->owner
== link_info
.output_bfd
)
4860 if (link_info
.reduce_memory_overheads
)
4861 bfd_link_hash_traverse (link_info
.hash
, ldemul_print_symbol
, i
);
4863 print_all_symbols (i
);
4865 /* Update print_dot, but make sure that we do not move it
4866 backwards - this could happen if we have overlays and a
4867 later overlay is shorter than an earier one. */
4868 if (addr
+ TO_ADDR (size
) > print_dot
)
4869 print_dot
= addr
+ TO_ADDR (size
);
4874 print_fill_statement (lang_fill_statement_type
*fill
)
4878 fputs (" FILL mask 0x", config
.map_file
);
4879 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
4880 fprintf (config
.map_file
, "%02x", *p
);
4881 fputs ("\n", config
.map_file
);
4885 print_data_statement (lang_data_statement_type
*data
)
4892 init_opb (data
->output_section
);
4893 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4896 addr
= data
->output_offset
;
4897 if (data
->output_section
!= NULL
)
4898 addr
+= data
->output_section
->vma
;
4926 if (size
< TO_SIZE ((unsigned) 1))
4927 size
= TO_SIZE ((unsigned) 1);
4928 minfo ("0x%V %W %s 0x%v", addr
, TO_ADDR (size
), name
, data
->value
);
4930 if (data
->exp
->type
.node_class
!= etree_value
)
4933 exp_print_tree (data
->exp
);
4938 print_dot
= addr
+ TO_ADDR (size
);
4941 /* Print an address statement. These are generated by options like
4945 print_address_statement (lang_address_statement_type
*address
)
4947 minfo (_("Address of section %s set to "), address
->section_name
);
4948 exp_print_tree (address
->address
);
4952 /* Print a reloc statement. */
4955 print_reloc_statement (lang_reloc_statement_type
*reloc
)
4961 init_opb (reloc
->output_section
);
4962 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4965 addr
= reloc
->output_offset
;
4966 if (reloc
->output_section
!= NULL
)
4967 addr
+= reloc
->output_section
->vma
;
4969 size
= bfd_get_reloc_size (reloc
->howto
);
4971 minfo ("0x%V %W RELOC %s ", addr
, TO_ADDR (size
), reloc
->howto
->name
);
4973 if (reloc
->name
!= NULL
)
4974 minfo ("%s+", reloc
->name
);
4976 minfo ("%s+", reloc
->section
->name
);
4978 exp_print_tree (reloc
->addend_exp
);
4982 print_dot
= addr
+ TO_ADDR (size
);
4986 print_padding_statement (lang_padding_statement_type
*s
)
4991 init_opb (s
->output_section
);
4994 len
= sizeof " *fill*" - 1;
4995 while (len
< SECTION_NAME_MAP_LENGTH
)
5001 addr
= s
->output_offset
;
5002 if (s
->output_section
!= NULL
)
5003 addr
+= s
->output_section
->vma
;
5004 minfo ("0x%V %W ", addr
, TO_ADDR (s
->size
));
5006 if (s
->fill
->size
!= 0)
5010 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
5011 fprintf (config
.map_file
, "%02x", *p
);
5016 print_dot
= addr
+ TO_ADDR (s
->size
);
5020 print_wild_statement (lang_wild_statement_type
*w
,
5021 lang_output_section_statement_type
*os
)
5023 struct wildcard_list
*sec
;
5027 if (w
->exclude_name_list
)
5030 minfo ("EXCLUDE_FILE(%s", w
->exclude_name_list
->name
);
5031 for (tmp
= w
->exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
5032 minfo (" %s", tmp
->name
);
5036 if (w
->filenames_sorted
)
5037 minfo ("SORT_BY_NAME(");
5038 if (w
->filename
!= NULL
)
5039 minfo ("%s", w
->filename
);
5042 if (w
->filenames_sorted
)
5046 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
5048 int closing_paren
= 0;
5050 switch (sec
->spec
.sorted
)
5056 minfo ("SORT_BY_NAME(");
5061 minfo ("SORT_BY_ALIGNMENT(");
5065 case by_name_alignment
:
5066 minfo ("SORT_BY_NAME(SORT_BY_ALIGNMENT(");
5070 case by_alignment_name
:
5071 minfo ("SORT_BY_ALIGNMENT(SORT_BY_NAME(");
5076 minfo ("SORT_NONE(");
5080 case by_init_priority
:
5081 minfo ("SORT_BY_INIT_PRIORITY(");
5086 if (sec
->spec
.exclude_name_list
!= NULL
)
5089 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
5090 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
5091 minfo (" %s", tmp
->name
);
5094 if (sec
->spec
.name
!= NULL
)
5095 minfo ("%s", sec
->spec
.name
);
5098 for (;closing_paren
> 0; closing_paren
--)
5107 print_statement_list (w
->children
.head
, os
);
5110 /* Print a group statement. */
5113 print_group (lang_group_statement_type
*s
,
5114 lang_output_section_statement_type
*os
)
5116 fprintf (config
.map_file
, "START GROUP\n");
5117 print_statement_list (s
->children
.head
, os
);
5118 fprintf (config
.map_file
, "END GROUP\n");
5121 /* Print the list of statements in S.
5122 This can be called for any statement type. */
5125 print_statement_list (lang_statement_union_type
*s
,
5126 lang_output_section_statement_type
*os
)
5130 print_statement (s
, os
);
5135 /* Print the first statement in statement list S.
5136 This can be called for any statement type. */
5139 print_statement (lang_statement_union_type
*s
,
5140 lang_output_section_statement_type
*os
)
5142 switch (s
->header
.type
)
5145 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
5148 case lang_constructors_statement_enum
:
5149 if (constructor_list
.head
!= NULL
)
5151 if (constructors_sorted
)
5152 minfo (" SORT (CONSTRUCTORS)\n");
5154 minfo (" CONSTRUCTORS\n");
5155 print_statement_list (constructor_list
.head
, os
);
5158 case lang_wild_statement_enum
:
5159 print_wild_statement (&s
->wild_statement
, os
);
5161 case lang_address_statement_enum
:
5162 print_address_statement (&s
->address_statement
);
5164 case lang_object_symbols_statement_enum
:
5165 minfo (" CREATE_OBJECT_SYMBOLS\n");
5167 case lang_fill_statement_enum
:
5168 print_fill_statement (&s
->fill_statement
);
5170 case lang_data_statement_enum
:
5171 print_data_statement (&s
->data_statement
);
5173 case lang_reloc_statement_enum
:
5174 print_reloc_statement (&s
->reloc_statement
);
5176 case lang_input_section_enum
:
5177 print_input_section (s
->input_section
.section
, false);
5179 case lang_padding_statement_enum
:
5180 print_padding_statement (&s
->padding_statement
);
5182 case lang_output_section_statement_enum
:
5183 print_output_section_statement (&s
->output_section_statement
);
5185 case lang_assignment_statement_enum
:
5186 print_assignment (&s
->assignment_statement
, os
);
5188 case lang_target_statement_enum
:
5189 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
5191 case lang_output_statement_enum
:
5192 minfo ("OUTPUT(%s", s
->output_statement
.name
);
5193 if (output_target
!= NULL
)
5194 minfo (" %s", output_target
);
5197 case lang_input_statement_enum
:
5198 print_input_statement (&s
->input_statement
);
5200 case lang_group_statement_enum
:
5201 print_group (&s
->group_statement
, os
);
5203 case lang_insert_statement_enum
:
5204 minfo ("INSERT %s %s\n",
5205 s
->insert_statement
.is_before
? "BEFORE" : "AFTER",
5206 s
->insert_statement
.where
);
5212 print_statements (void)
5214 print_statement_list (statement_list
.head
, abs_output_section
);
5217 /* Print the first N statements in statement list S to STDERR.
5218 If N == 0, nothing is printed.
5219 If N < 0, the entire list is printed.
5220 Intended to be called from GDB. */
5223 dprint_statement (lang_statement_union_type
*s
, int n
)
5225 FILE *map_save
= config
.map_file
;
5227 config
.map_file
= stderr
;
5230 print_statement_list (s
, abs_output_section
);
5233 while (s
&& --n
>= 0)
5235 print_statement (s
, abs_output_section
);
5240 config
.map_file
= map_save
;
5244 insert_pad (lang_statement_union_type
**ptr
,
5246 bfd_size_type alignment_needed
,
5247 asection
*output_section
,
5250 static fill_type zero_fill
;
5251 lang_statement_union_type
*pad
= NULL
;
5253 if (ptr
!= &statement_list
.head
)
5254 pad
= ((lang_statement_union_type
*)
5255 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
5257 && pad
->header
.type
== lang_padding_statement_enum
5258 && pad
->padding_statement
.output_section
== output_section
)
5260 /* Use the existing pad statement. */
5262 else if ((pad
= *ptr
) != NULL
5263 && pad
->header
.type
== lang_padding_statement_enum
5264 && pad
->padding_statement
.output_section
== output_section
)
5266 /* Use the existing pad statement. */
5270 /* Make a new padding statement, linked into existing chain. */
5271 pad
= stat_alloc (sizeof (lang_padding_statement_type
));
5272 pad
->header
.next
= *ptr
;
5274 pad
->header
.type
= lang_padding_statement_enum
;
5275 pad
->padding_statement
.output_section
= output_section
;
5278 pad
->padding_statement
.fill
= fill
;
5280 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
5281 pad
->padding_statement
.size
= alignment_needed
;
5282 if (!(output_section
->flags
& SEC_FIXED_SIZE
))
5283 output_section
->size
= TO_SIZE (dot
+ TO_ADDR (alignment_needed
)
5284 - output_section
->vma
);
5287 /* Work out how much this section will move the dot point. */
5291 (lang_statement_union_type
**this_ptr
,
5292 lang_output_section_statement_type
*output_section_statement
,
5297 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
5298 asection
*i
= is
->section
;
5299 asection
*o
= output_section_statement
->bfd_section
;
5302 if (link_info
.non_contiguous_regions
)
5304 /* If the input section I has already been successfully assigned
5305 to an output section other than O, don't bother with it and
5306 let the caller remove it from the list. Keep processing in
5307 case we have already handled O, because the repeated passes
5308 have reinitialized its size. */
5309 if (i
->already_assigned
&& i
->already_assigned
!= o
)
5316 if (i
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
5317 i
->output_offset
= i
->vma
- o
->vma
;
5318 else if (((i
->flags
& SEC_EXCLUDE
) != 0)
5319 || output_section_statement
->ignored
)
5320 i
->output_offset
= dot
- o
->vma
;
5323 bfd_size_type alignment_needed
;
5325 /* Align this section first to the input sections requirement,
5326 then to the output section's requirement. If this alignment
5327 is greater than any seen before, then record it too. Perform
5328 the alignment by inserting a magic 'padding' statement. */
5330 if (output_section_statement
->subsection_alignment
!= NULL
)
5332 = exp_get_power (output_section_statement
->subsection_alignment
,
5333 "subsection alignment");
5335 if (o
->alignment_power
< i
->alignment_power
)
5336 o
->alignment_power
= i
->alignment_power
;
5338 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
5340 if (alignment_needed
!= 0)
5342 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
5343 dot
+= alignment_needed
;
5346 if (link_info
.non_contiguous_regions
)
5348 /* If I would overflow O, let the caller remove I from the
5350 if (output_section_statement
->region
)
5352 bfd_vma end
= output_section_statement
->region
->origin
5353 + output_section_statement
->region
->length
;
5355 if (dot
+ TO_ADDR (i
->size
) > end
)
5357 if (i
->flags
& SEC_LINKER_CREATED
)
5358 einfo (_("%F%P: Output section '%s' not large enough for the "
5359 "linker-created stubs section '%s'.\n"),
5360 i
->output_section
->name
, i
->name
);
5362 if (i
->rawsize
&& i
->rawsize
!= i
->size
)
5363 einfo (_("%F%P: Relaxation not supported with "
5364 "--enable-non-contiguous-regions (section '%s' "
5365 "would overflow '%s' after it changed size).\n"),
5366 i
->name
, i
->output_section
->name
);
5370 i
->output_section
= NULL
;
5376 /* Remember where in the output section this input section goes. */
5377 i
->output_offset
= dot
- o
->vma
;
5379 /* Mark how big the output section must be to contain this now. */
5380 dot
+= TO_ADDR (i
->size
);
5381 if (!(o
->flags
& SEC_FIXED_SIZE
))
5382 o
->size
= TO_SIZE (dot
- o
->vma
);
5384 if (link_info
.non_contiguous_regions
)
5386 /* Record that I was successfully assigned to O, and update
5387 its actual output section too. */
5388 i
->already_assigned
= o
;
5389 i
->output_section
= o
;
5403 sort_sections_by_lma (const void *arg1
, const void *arg2
)
5405 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
5406 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
5408 if (sec1
->lma
< sec2
->lma
)
5410 else if (sec1
->lma
> sec2
->lma
)
5412 else if (sec1
->id
< sec2
->id
)
5414 else if (sec1
->id
> sec2
->id
)
5421 sort_sections_by_vma (const void *arg1
, const void *arg2
)
5423 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
5424 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
5426 if (sec1
->vma
< sec2
->vma
)
5428 else if (sec1
->vma
> sec2
->vma
)
5430 else if (sec1
->id
< sec2
->id
)
5432 else if (sec1
->id
> sec2
->id
)
5438 #define IS_TBSS(s) \
5439 ((s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == SEC_THREAD_LOCAL)
5441 #define IGNORE_SECTION(s) \
5442 ((s->flags & SEC_ALLOC) == 0 || IS_TBSS (s))
5444 /* Check to see if any allocated sections overlap with other allocated
5445 sections. This can happen if a linker script specifies the output
5446 section addresses of the two sections. Also check whether any memory
5447 region has overflowed. */
5450 lang_check_section_addresses (void)
5453 struct check_sec
*sections
;
5458 bfd_vma p_start
= 0;
5460 lang_memory_region_type
*m
;
5463 /* Detect address space overflow on allocated sections. */
5464 addr_mask
= ((bfd_vma
) 1 <<
5465 (bfd_arch_bits_per_address (link_info
.output_bfd
) - 1)) - 1;
5466 addr_mask
= (addr_mask
<< 1) + 1;
5467 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5468 if ((s
->flags
& SEC_ALLOC
) != 0)
5470 s_end
= (s
->vma
+ s
->size
) & addr_mask
;
5471 if (s_end
!= 0 && s_end
< (s
->vma
& addr_mask
))
5472 einfo (_("%X%P: section %s VMA wraps around address space\n"),
5476 s_end
= (s
->lma
+ s
->size
) & addr_mask
;
5477 if (s_end
!= 0 && s_end
< (s
->lma
& addr_mask
))
5478 einfo (_("%X%P: section %s LMA wraps around address space\n"),
5483 if (bfd_count_sections (link_info
.output_bfd
) <= 1)
5486 count
= bfd_count_sections (link_info
.output_bfd
);
5487 sections
= XNEWVEC (struct check_sec
, count
);
5489 /* Scan all sections in the output list. */
5491 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5493 if (IGNORE_SECTION (s
)
5497 sections
[count
].sec
= s
;
5498 sections
[count
].warned
= false;
5508 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_lma
);
5510 /* First check section LMAs. There should be no overlap of LMAs on
5511 loadable sections, even with overlays. */
5512 for (p
= NULL
, i
= 0; i
< count
; i
++)
5514 s
= sections
[i
].sec
;
5516 if ((s
->flags
& SEC_LOAD
) != 0)
5519 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5521 /* Look for an overlap. We have sorted sections by lma, so
5522 we know that s_start >= p_start. Besides the obvious
5523 case of overlap when the current section starts before
5524 the previous one ends, we also must have overlap if the
5525 previous section wraps around the address space. */
5527 && (s_start
<= p_end
5528 || p_end
< p_start
))
5530 einfo (_("%X%P: section %s LMA [%V,%V]"
5531 " overlaps section %s LMA [%V,%V]\n"),
5532 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5533 sections
[i
].warned
= true;
5541 /* If any non-zero size allocated section (excluding tbss) starts at
5542 exactly the same VMA as another such section, then we have
5543 overlays. Overlays generated by the OVERLAY keyword will have
5544 this property. It is possible to intentionally generate overlays
5545 that fail this test, but it would be unusual. */
5546 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_vma
);
5548 p_start
= sections
[0].sec
->vma
;
5549 for (i
= 1; i
< count
; i
++)
5551 s_start
= sections
[i
].sec
->vma
;
5552 if (p_start
== s_start
)
5560 /* Now check section VMAs if no overlays were detected. */
5563 for (p
= NULL
, i
= 0; i
< count
; i
++)
5565 s
= sections
[i
].sec
;
5568 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5571 && !sections
[i
].warned
5572 && (s_start
<= p_end
5573 || p_end
< p_start
))
5574 einfo (_("%X%P: section %s VMA [%V,%V]"
5575 " overlaps section %s VMA [%V,%V]\n"),
5576 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5585 /* If any memory region has overflowed, report by how much.
5586 We do not issue this diagnostic for regions that had sections
5587 explicitly placed outside their bounds; os_region_check's
5588 diagnostics are adequate for that case.
5590 FIXME: It is conceivable that m->current - (m->origin + m->length)
5591 might overflow a 32-bit integer. There is, alas, no way to print
5592 a bfd_vma quantity in decimal. */
5593 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
5594 if (m
->had_full_message
)
5596 unsigned long over
= m
->current
- (m
->origin
+ m
->length
);
5597 einfo (ngettext ("%X%P: region `%s' overflowed by %lu byte\n",
5598 "%X%P: region `%s' overflowed by %lu bytes\n",
5600 m
->name_list
.name
, over
);
5604 /* Make sure the new address is within the region. We explicitly permit the
5605 current address to be at the exact end of the region when the address is
5606 non-zero, in case the region is at the end of addressable memory and the
5607 calculation wraps around. */
5610 os_region_check (lang_output_section_statement_type
*os
,
5611 lang_memory_region_type
*region
,
5615 if ((region
->current
< region
->origin
5616 || (region
->current
- region
->origin
> region
->length
))
5617 && ((region
->current
!= region
->origin
+ region
->length
)
5622 einfo (_("%X%P: address 0x%v of %pB section `%s'"
5623 " is not within region `%s'\n"),
5625 os
->bfd_section
->owner
,
5626 os
->bfd_section
->name
,
5627 region
->name_list
.name
);
5629 else if (!region
->had_full_message
)
5631 region
->had_full_message
= true;
5633 einfo (_("%X%P: %pB section `%s' will not fit in region `%s'\n"),
5634 os
->bfd_section
->owner
,
5635 os
->bfd_section
->name
,
5636 region
->name_list
.name
);
5642 ldlang_check_relro_region (lang_statement_union_type
*s
,
5643 seg_align_type
*seg
)
5645 if (seg
->relro
== exp_seg_relro_start
)
5647 if (!seg
->relro_start_stat
)
5648 seg
->relro_start_stat
= s
;
5651 ASSERT (seg
->relro_start_stat
== s
);
5654 else if (seg
->relro
== exp_seg_relro_end
)
5656 if (!seg
->relro_end_stat
)
5657 seg
->relro_end_stat
= s
;
5660 ASSERT (seg
->relro_end_stat
== s
);
5665 /* Set the sizes for all the output sections. */
5668 lang_size_sections_1
5669 (lang_statement_union_type
**prev
,
5670 lang_output_section_statement_type
*output_section_statement
,
5676 lang_statement_union_type
*s
;
5677 lang_statement_union_type
*prev_s
= NULL
;
5678 bool removed_prev_s
= false;
5680 /* Size up the sections from their constituent parts. */
5681 for (s
= *prev
; s
!= NULL
; prev_s
= s
, s
= s
->header
.next
)
5683 bool removed
= false;
5685 switch (s
->header
.type
)
5687 case lang_output_section_statement_enum
:
5689 bfd_vma newdot
, after
, dotdelta
;
5690 lang_output_section_statement_type
*os
;
5691 lang_memory_region_type
*r
;
5692 int section_alignment
= 0;
5694 os
= &s
->output_section_statement
;
5695 init_opb (os
->bfd_section
);
5696 if (os
->constraint
== -1)
5699 /* FIXME: We shouldn't need to zero section vmas for ld -r
5700 here, in lang_insert_orphan, or in the default linker scripts.
5701 This is covering for coff backend linker bugs. See PR6945. */
5702 if (os
->addr_tree
== NULL
5703 && bfd_link_relocatable (&link_info
)
5704 && (bfd_get_flavour (link_info
.output_bfd
)
5705 == bfd_target_coff_flavour
))
5706 os
->addr_tree
= exp_intop (0);
5707 if (os
->addr_tree
!= NULL
)
5709 os
->processed_vma
= false;
5710 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
5712 if (expld
.result
.valid_p
)
5714 dot
= expld
.result
.value
;
5715 if (expld
.result
.section
!= NULL
)
5716 dot
+= expld
.result
.section
->vma
;
5718 else if (expld
.phase
!= lang_mark_phase_enum
)
5719 einfo (_("%F%P:%pS: non constant or forward reference"
5720 " address expression for section %s\n"),
5721 os
->addr_tree
, os
->name
);
5724 if (os
->bfd_section
== NULL
)
5725 /* This section was removed or never actually created. */
5728 /* If this is a COFF shared library section, use the size and
5729 address from the input section. FIXME: This is COFF
5730 specific; it would be cleaner if there were some other way
5731 to do this, but nothing simple comes to mind. */
5732 if (((bfd_get_flavour (link_info
.output_bfd
)
5733 == bfd_target_ecoff_flavour
)
5734 || (bfd_get_flavour (link_info
.output_bfd
)
5735 == bfd_target_coff_flavour
))
5736 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
5740 if (os
->children
.head
== NULL
5741 || os
->children
.head
->header
.next
!= NULL
5742 || (os
->children
.head
->header
.type
5743 != lang_input_section_enum
))
5744 einfo (_("%X%P: internal error on COFF shared library"
5745 " section %s\n"), os
->name
);
5747 input
= os
->children
.head
->input_section
.section
;
5748 bfd_set_section_vma (os
->bfd_section
,
5749 bfd_section_vma (input
));
5750 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5751 os
->bfd_section
->size
= input
->size
;
5757 if (bfd_is_abs_section (os
->bfd_section
))
5759 /* No matter what happens, an abs section starts at zero. */
5760 ASSERT (os
->bfd_section
->vma
== 0);
5764 if (os
->addr_tree
== NULL
)
5766 /* No address specified for this section, get one
5767 from the region specification. */
5768 if (os
->region
== NULL
5769 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
5770 && os
->region
->name_list
.name
[0] == '*'
5771 && strcmp (os
->region
->name_list
.name
,
5772 DEFAULT_MEMORY_REGION
) == 0))
5774 os
->region
= lang_memory_default (os
->bfd_section
);
5777 /* If a loadable section is using the default memory
5778 region, and some non default memory regions were
5779 defined, issue an error message. */
5781 && !IGNORE_SECTION (os
->bfd_section
)
5782 && !bfd_link_relocatable (&link_info
)
5784 && strcmp (os
->region
->name_list
.name
,
5785 DEFAULT_MEMORY_REGION
) == 0
5786 && lang_memory_region_list
!= NULL
5787 && (strcmp (lang_memory_region_list
->name_list
.name
,
5788 DEFAULT_MEMORY_REGION
) != 0
5789 || lang_memory_region_list
->next
!= NULL
)
5790 && lang_sizing_iteration
== 1)
5792 /* By default this is an error rather than just a
5793 warning because if we allocate the section to the
5794 default memory region we can end up creating an
5795 excessively large binary, or even seg faulting when
5796 attempting to perform a negative seek. See
5797 sources.redhat.com/ml/binutils/2003-04/msg00423.html
5798 for an example of this. This behaviour can be
5799 overridden by the using the --no-check-sections
5801 if (command_line
.check_section_addresses
)
5802 einfo (_("%F%P: error: no memory region specified"
5803 " for loadable section `%s'\n"),
5804 bfd_section_name (os
->bfd_section
));
5806 einfo (_("%P: warning: no memory region specified"
5807 " for loadable section `%s'\n"),
5808 bfd_section_name (os
->bfd_section
));
5811 newdot
= os
->region
->current
;
5812 section_alignment
= os
->bfd_section
->alignment_power
;
5815 section_alignment
= exp_get_power (os
->section_alignment
,
5816 "section alignment");
5818 /* Align to what the section needs. */
5819 if (section_alignment
> 0)
5821 bfd_vma savedot
= newdot
;
5824 newdot
= align_power (newdot
, section_alignment
);
5825 dotdelta
= newdot
- savedot
;
5827 if (lang_sizing_iteration
== 1)
5829 else if (lang_sizing_iteration
> 1)
5831 /* Only report adjustments that would change
5832 alignment from what we have already reported. */
5833 diff
= newdot
- os
->bfd_section
->vma
;
5834 if (!(diff
& (((bfd_vma
) 1 << section_alignment
) - 1)))
5838 && (config
.warn_section_align
5839 || os
->addr_tree
!= NULL
))
5840 einfo (_("%P: warning: "
5841 "start of section %s changed by %ld\n"),
5842 os
->name
, (long) diff
);
5845 bfd_set_section_vma (os
->bfd_section
, newdot
);
5847 os
->bfd_section
->output_offset
= 0;
5850 lang_size_sections_1 (&os
->children
.head
, os
,
5851 os
->fill
, newdot
, relax
, check_regions
);
5853 os
->processed_vma
= true;
5855 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5856 /* Except for some special linker created sections,
5857 no output section should change from zero size
5858 after strip_excluded_output_sections. A non-zero
5859 size on an ignored section indicates that some
5860 input section was not sized early enough. */
5861 ASSERT (os
->bfd_section
->size
== 0);
5864 dot
= os
->bfd_section
->vma
;
5866 /* Put the section within the requested block size, or
5867 align at the block boundary. */
5869 + TO_ADDR (os
->bfd_section
->size
)
5870 + os
->block_value
- 1)
5871 & - (bfd_vma
) os
->block_value
);
5873 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5874 os
->bfd_section
->size
= TO_SIZE (after
5875 - os
->bfd_section
->vma
);
5878 /* Set section lma. */
5881 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, false);
5885 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
5886 os
->bfd_section
->lma
= lma
;
5888 else if (os
->lma_region
!= NULL
)
5890 bfd_vma lma
= os
->lma_region
->current
;
5892 if (os
->align_lma_with_input
)
5896 /* When LMA_REGION is the same as REGION, align the LMA
5897 as we did for the VMA, possibly including alignment
5898 from the bfd section. If a different region, then
5899 only align according to the value in the output
5901 if (os
->lma_region
!= os
->region
)
5902 section_alignment
= exp_get_power (os
->section_alignment
,
5903 "section alignment");
5904 if (section_alignment
> 0)
5905 lma
= align_power (lma
, section_alignment
);
5907 os
->bfd_section
->lma
= lma
;
5909 else if (r
->last_os
!= NULL
5910 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5915 last
= r
->last_os
->output_section_statement
.bfd_section
;
5917 /* A backwards move of dot should be accompanied by
5918 an explicit assignment to the section LMA (ie.
5919 os->load_base set) because backwards moves can
5920 create overlapping LMAs. */
5922 && os
->bfd_section
->size
!= 0
5923 && dot
+ TO_ADDR (os
->bfd_section
->size
) <= last
->vma
)
5925 /* If dot moved backwards then leave lma equal to
5926 vma. This is the old default lma, which might
5927 just happen to work when the backwards move is
5928 sufficiently large. Nag if this changes anything,
5929 so people can fix their linker scripts. */
5931 if (last
->vma
!= last
->lma
)
5932 einfo (_("%P: warning: dot moved backwards "
5933 "before `%s'\n"), os
->name
);
5937 /* If this is an overlay, set the current lma to that
5938 at the end of the previous section. */
5939 if (os
->sectype
== overlay_section
)
5940 lma
= last
->lma
+ TO_ADDR (last
->size
);
5942 /* Otherwise, keep the same lma to vma relationship
5943 as the previous section. */
5945 lma
= os
->bfd_section
->vma
+ last
->lma
- last
->vma
;
5947 if (section_alignment
> 0)
5948 lma
= align_power (lma
, section_alignment
);
5949 os
->bfd_section
->lma
= lma
;
5952 os
->processed_lma
= true;
5954 /* Keep track of normal sections using the default
5955 lma region. We use this to set the lma for
5956 following sections. Overlays or other linker
5957 script assignment to lma might mean that the
5958 default lma == vma is incorrect.
5959 To avoid warnings about dot moving backwards when using
5960 -Ttext, don't start tracking sections until we find one
5961 of non-zero size or with lma set differently to vma.
5962 Do this tracking before we short-cut the loop so that we
5963 track changes for the case where the section size is zero,
5964 but the lma is set differently to the vma. This is
5965 important, if an orphan section is placed after an
5966 otherwise empty output section that has an explicit lma
5967 set, we want that lma reflected in the orphans lma. */
5968 if (((!IGNORE_SECTION (os
->bfd_section
)
5969 && (os
->bfd_section
->size
!= 0
5970 || (r
->last_os
== NULL
5971 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
5972 || (r
->last_os
!= NULL
5973 && dot
>= (r
->last_os
->output_section_statement
5974 .bfd_section
->vma
))))
5975 || os
->sectype
== first_overlay_section
)
5976 && os
->lma_region
== NULL
5977 && !bfd_link_relocatable (&link_info
))
5980 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5983 /* .tbss sections effectively have zero size. */
5984 if (!IS_TBSS (os
->bfd_section
)
5985 || bfd_link_relocatable (&link_info
))
5986 dotdelta
= TO_ADDR (os
->bfd_section
->size
);
5991 if (os
->update_dot_tree
!= 0)
5992 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5994 /* Update dot in the region ?
5995 We only do this if the section is going to be allocated,
5996 since unallocated sections do not contribute to the region's
5997 overall size in memory. */
5998 if (os
->region
!= NULL
5999 && (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)))
6001 os
->region
->current
= dot
;
6004 /* Make sure the new address is within the region. */
6005 os_region_check (os
, os
->region
, os
->addr_tree
,
6006 os
->bfd_section
->vma
);
6008 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
6009 && ((os
->bfd_section
->flags
& SEC_LOAD
)
6010 || os
->align_lma_with_input
))
6012 os
->lma_region
->current
= os
->bfd_section
->lma
+ dotdelta
;
6015 os_region_check (os
, os
->lma_region
, NULL
,
6016 os
->bfd_section
->lma
);
6022 case lang_constructors_statement_enum
:
6023 dot
= lang_size_sections_1 (&constructor_list
.head
,
6024 output_section_statement
,
6025 fill
, dot
, relax
, check_regions
);
6028 case lang_data_statement_enum
:
6030 unsigned int size
= 0;
6032 s
->data_statement
.output_offset
=
6033 dot
- output_section_statement
->bfd_section
->vma
;
6034 s
->data_statement
.output_section
=
6035 output_section_statement
->bfd_section
;
6037 /* We might refer to provided symbols in the expression, and
6038 need to mark them as needed. */
6039 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
6041 switch (s
->data_statement
.type
)
6059 if (size
< TO_SIZE ((unsigned) 1))
6060 size
= TO_SIZE ((unsigned) 1);
6061 dot
+= TO_ADDR (size
);
6062 if (!(output_section_statement
->bfd_section
->flags
6064 output_section_statement
->bfd_section
->size
6065 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
6070 case lang_reloc_statement_enum
:
6074 s
->reloc_statement
.output_offset
=
6075 dot
- output_section_statement
->bfd_section
->vma
;
6076 s
->reloc_statement
.output_section
=
6077 output_section_statement
->bfd_section
;
6078 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
6079 dot
+= TO_ADDR (size
);
6080 if (!(output_section_statement
->bfd_section
->flags
6082 output_section_statement
->bfd_section
->size
6083 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
6087 case lang_wild_statement_enum
:
6088 dot
= lang_size_sections_1 (&s
->wild_statement
.children
.head
,
6089 output_section_statement
,
6090 fill
, dot
, relax
, check_regions
);
6093 case lang_object_symbols_statement_enum
:
6094 link_info
.create_object_symbols_section
6095 = output_section_statement
->bfd_section
;
6096 output_section_statement
->bfd_section
->flags
|= SEC_KEEP
;
6099 case lang_output_statement_enum
:
6100 case lang_target_statement_enum
:
6103 case lang_input_section_enum
:
6107 i
= s
->input_section
.section
;
6112 if (!bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
6113 einfo (_("%F%P: can't relax section: %E\n"));
6117 dot
= size_input_section (prev
, output_section_statement
,
6118 fill
, &removed
, dot
);
6122 case lang_input_statement_enum
:
6125 case lang_fill_statement_enum
:
6126 s
->fill_statement
.output_section
=
6127 output_section_statement
->bfd_section
;
6129 fill
= s
->fill_statement
.fill
;
6132 case lang_assignment_statement_enum
:
6134 bfd_vma newdot
= dot
;
6135 etree_type
*tree
= s
->assignment_statement
.exp
;
6137 expld
.dataseg
.relro
= exp_seg_relro_none
;
6139 exp_fold_tree (tree
,
6140 output_section_statement
->bfd_section
,
6143 ldlang_check_relro_region (s
, &expld
.dataseg
);
6145 expld
.dataseg
.relro
= exp_seg_relro_none
;
6147 /* This symbol may be relative to this section. */
6148 if ((tree
->type
.node_class
== etree_provided
6149 || tree
->type
.node_class
== etree_assign
)
6150 && (tree
->assign
.dst
[0] != '.'
6151 || tree
->assign
.dst
[1] != '\0'))
6152 output_section_statement
->update_dot
= 1;
6154 if (!output_section_statement
->ignored
)
6156 if (output_section_statement
== abs_output_section
)
6158 /* If we don't have an output section, then just adjust
6159 the default memory address. */
6160 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
6161 false)->current
= newdot
;
6163 else if (newdot
!= dot
)
6165 /* Insert a pad after this statement. We can't
6166 put the pad before when relaxing, in case the
6167 assignment references dot. */
6168 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
6169 output_section_statement
->bfd_section
, dot
);
6171 /* Don't neuter the pad below when relaxing. */
6174 /* If dot is advanced, this implies that the section
6175 should have space allocated to it, unless the
6176 user has explicitly stated that the section
6177 should not be allocated. */
6178 if (output_section_statement
->sectype
!= noalloc_section
6179 && (output_section_statement
->sectype
!= noload_section
6180 || (bfd_get_flavour (link_info
.output_bfd
)
6181 == bfd_target_elf_flavour
)))
6182 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
6189 case lang_padding_statement_enum
:
6190 /* If this is the first time lang_size_sections is called,
6191 we won't have any padding statements. If this is the
6192 second or later passes when relaxing, we should allow
6193 padding to shrink. If padding is needed on this pass, it
6194 will be added back in. */
6195 s
->padding_statement
.size
= 0;
6197 /* Make sure output_offset is valid. If relaxation shrinks
6198 the section and this pad isn't needed, it's possible to
6199 have output_offset larger than the final size of the
6200 section. bfd_set_section_contents will complain even for
6201 a pad size of zero. */
6202 s
->padding_statement
.output_offset
6203 = dot
- output_section_statement
->bfd_section
->vma
;
6206 case lang_group_statement_enum
:
6207 dot
= lang_size_sections_1 (&s
->group_statement
.children
.head
,
6208 output_section_statement
,
6209 fill
, dot
, relax
, check_regions
);
6212 case lang_insert_statement_enum
:
6215 /* We can only get here when relaxing is turned on. */
6216 case lang_address_statement_enum
:
6224 /* If an input section doesn't fit in the current output
6225 section, remove it from the list. Handle the case where we
6226 have to remove an input_section statement here: there is a
6227 special case to remove the first element of the list. */
6228 if (link_info
.non_contiguous_regions
&& removed
)
6230 /* If we removed the first element during the previous
6231 iteration, override the loop assignment of prev_s. */
6237 /* If there was a real previous input section, just skip
6239 prev_s
->header
.next
=s
->header
.next
;
6241 removed_prev_s
= false;
6245 /* Remove the first input section of the list. */
6246 *prev
= s
->header
.next
;
6247 removed_prev_s
= true;
6250 /* Move to next element, unless we removed the head of the
6252 if (!removed_prev_s
)
6253 prev
= &s
->header
.next
;
6257 prev
= &s
->header
.next
;
6258 removed_prev_s
= false;
6264 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
6265 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
6266 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
6267 segments. We are allowed an opportunity to override this decision. */
6270 ldlang_override_segment_assignment (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6271 bfd
*abfd ATTRIBUTE_UNUSED
,
6272 asection
*current_section
,
6273 asection
*previous_section
,
6276 lang_output_section_statement_type
*cur
;
6277 lang_output_section_statement_type
*prev
;
6279 /* The checks below are only necessary when the BFD library has decided
6280 that the two sections ought to be placed into the same segment. */
6284 /* Paranoia checks. */
6285 if (current_section
== NULL
|| previous_section
== NULL
)
6288 /* If this flag is set, the target never wants code and non-code
6289 sections comingled in the same segment. */
6290 if (config
.separate_code
6291 && ((current_section
->flags
^ previous_section
->flags
) & SEC_CODE
))
6294 /* Find the memory regions associated with the two sections.
6295 We call lang_output_section_find() here rather than scanning the list
6296 of output sections looking for a matching section pointer because if
6297 we have a large number of sections then a hash lookup is faster. */
6298 cur
= lang_output_section_find (current_section
->name
);
6299 prev
= lang_output_section_find (previous_section
->name
);
6301 /* More paranoia. */
6302 if (cur
== NULL
|| prev
== NULL
)
6305 /* If the regions are different then force the sections to live in
6306 different segments. See the email thread starting at the following
6307 URL for the reasons why this is necessary:
6308 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
6309 return cur
->region
!= prev
->region
;
6313 one_lang_size_sections_pass (bool *relax
, bool check_regions
)
6315 lang_statement_iteration
++;
6316 if (expld
.phase
!= lang_mark_phase_enum
)
6317 lang_sizing_iteration
++;
6318 lang_size_sections_1 (&statement_list
.head
, abs_output_section
,
6319 0, 0, relax
, check_regions
);
6323 lang_size_segment (seg_align_type
*seg
)
6325 /* If XXX_SEGMENT_ALIGN XXX_SEGMENT_END pair was seen, check whether
6326 a page could be saved in the data segment. */
6327 bfd_vma first
, last
;
6329 first
= -seg
->base
& (seg
->pagesize
- 1);
6330 last
= seg
->end
& (seg
->pagesize
- 1);
6332 && ((seg
->base
& ~(seg
->pagesize
- 1))
6333 != (seg
->end
& ~(seg
->pagesize
- 1)))
6334 && first
+ last
<= seg
->pagesize
)
6336 seg
->phase
= exp_seg_adjust
;
6340 seg
->phase
= exp_seg_done
;
6345 lang_size_relro_segment_1 (seg_align_type
*seg
)
6347 bfd_vma relro_end
, desired_end
;
6350 /* Compute the expected PT_GNU_RELRO/PT_LOAD segment end. */
6351 relro_end
= ((seg
->relro_end
+ seg
->pagesize
- 1)
6352 & ~(seg
->pagesize
- 1));
6354 /* Adjust by the offset arg of XXX_SEGMENT_RELRO_END. */
6355 desired_end
= relro_end
- seg
->relro_offset
;
6357 /* For sections in the relro segment.. */
6358 for (sec
= link_info
.output_bfd
->section_last
; sec
; sec
= sec
->prev
)
6359 if ((sec
->flags
& SEC_ALLOC
) != 0
6360 && sec
->vma
>= seg
->base
6361 && sec
->vma
< seg
->relro_end
- seg
->relro_offset
)
6363 /* Where do we want to put this section so that it ends as
6365 bfd_vma start
, end
, bump
;
6367 end
= start
= sec
->vma
;
6369 end
+= TO_ADDR (sec
->size
);
6370 bump
= desired_end
- end
;
6371 /* We'd like to increase START by BUMP, but we must heed
6372 alignment so the increase might be less than optimum. */
6374 start
&= ~(((bfd_vma
) 1 << sec
->alignment_power
) - 1);
6375 /* This is now the desired end for the previous section. */
6376 desired_end
= start
;
6379 seg
->phase
= exp_seg_relro_adjust
;
6380 ASSERT (desired_end
>= seg
->base
);
6381 seg
->base
= desired_end
;
6386 lang_size_relro_segment (bool *relax
, bool check_regions
)
6388 bool do_reset
= false;
6390 bfd_vma data_initial_base
, data_relro_end
;
6392 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
6394 do_data_relro
= true;
6395 data_initial_base
= expld
.dataseg
.base
;
6396 data_relro_end
= lang_size_relro_segment_1 (&expld
.dataseg
);
6400 do_data_relro
= false;
6401 data_initial_base
= data_relro_end
= 0;
6406 lang_reset_memory_regions ();
6407 one_lang_size_sections_pass (relax
, check_regions
);
6409 /* Assignments to dot, or to output section address in a user
6410 script have increased padding over the original. Revert. */
6411 if (do_data_relro
&& expld
.dataseg
.relro_end
> data_relro_end
)
6413 expld
.dataseg
.base
= data_initial_base
;;
6418 if (!do_data_relro
&& lang_size_segment (&expld
.dataseg
))
6425 lang_size_sections (bool *relax
, bool check_regions
)
6427 expld
.phase
= lang_allocating_phase_enum
;
6428 expld
.dataseg
.phase
= exp_seg_none
;
6430 one_lang_size_sections_pass (relax
, check_regions
);
6432 if (expld
.dataseg
.phase
!= exp_seg_end_seen
)
6433 expld
.dataseg
.phase
= exp_seg_done
;
6435 if (expld
.dataseg
.phase
== exp_seg_end_seen
)
6438 = lang_size_relro_segment (relax
, check_regions
);
6442 lang_reset_memory_regions ();
6443 one_lang_size_sections_pass (relax
, check_regions
);
6446 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
6448 link_info
.relro_start
= expld
.dataseg
.base
;
6449 link_info
.relro_end
= expld
.dataseg
.relro_end
;
6454 static lang_output_section_statement_type
*current_section
;
6455 static lang_assignment_statement_type
*current_assign
;
6456 static bool prefer_next_section
;
6458 /* Worker function for lang_do_assignments. Recursiveness goes here. */
6461 lang_do_assignments_1 (lang_statement_union_type
*s
,
6462 lang_output_section_statement_type
*current_os
,
6467 for (; s
!= NULL
; s
= s
->header
.next
)
6469 switch (s
->header
.type
)
6471 case lang_constructors_statement_enum
:
6472 dot
= lang_do_assignments_1 (constructor_list
.head
,
6473 current_os
, fill
, dot
, found_end
);
6476 case lang_output_section_statement_enum
:
6478 lang_output_section_statement_type
*os
;
6481 os
= &(s
->output_section_statement
);
6482 os
->after_end
= *found_end
;
6483 init_opb (os
->bfd_section
);
6484 if (os
->bfd_section
!= NULL
&& !os
->ignored
)
6486 if ((os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
6488 current_section
= os
;
6489 prefer_next_section
= false;
6491 dot
= os
->bfd_section
->vma
;
6493 newdot
= lang_do_assignments_1 (os
->children
.head
,
6494 os
, os
->fill
, dot
, found_end
);
6497 if (os
->bfd_section
!= NULL
)
6499 /* .tbss sections effectively have zero size. */
6500 if (!IS_TBSS (os
->bfd_section
)
6501 || bfd_link_relocatable (&link_info
))
6502 dot
+= TO_ADDR (os
->bfd_section
->size
);
6504 if (os
->update_dot_tree
!= NULL
)
6505 exp_fold_tree (os
->update_dot_tree
,
6506 bfd_abs_section_ptr
, &dot
);
6514 case lang_wild_statement_enum
:
6516 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
6517 current_os
, fill
, dot
, found_end
);
6520 case lang_object_symbols_statement_enum
:
6521 case lang_output_statement_enum
:
6522 case lang_target_statement_enum
:
6525 case lang_data_statement_enum
:
6526 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
6527 if (expld
.result
.valid_p
)
6529 s
->data_statement
.value
= expld
.result
.value
;
6530 if (expld
.result
.section
!= NULL
)
6531 s
->data_statement
.value
+= expld
.result
.section
->vma
;
6533 else if (expld
.phase
== lang_final_phase_enum
)
6534 einfo (_("%F%P: invalid data statement\n"));
6537 switch (s
->data_statement
.type
)
6555 if (size
< TO_SIZE ((unsigned) 1))
6556 size
= TO_SIZE ((unsigned) 1);
6557 dot
+= TO_ADDR (size
);
6561 case lang_reloc_statement_enum
:
6562 exp_fold_tree (s
->reloc_statement
.addend_exp
,
6563 bfd_abs_section_ptr
, &dot
);
6564 if (expld
.result
.valid_p
)
6565 s
->reloc_statement
.addend_value
= expld
.result
.value
;
6566 else if (expld
.phase
== lang_final_phase_enum
)
6567 einfo (_("%F%P: invalid reloc statement\n"));
6568 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
6571 case lang_input_section_enum
:
6573 asection
*in
= s
->input_section
.section
;
6575 if ((in
->flags
& SEC_EXCLUDE
) == 0)
6576 dot
+= TO_ADDR (in
->size
);
6580 case lang_input_statement_enum
:
6583 case lang_fill_statement_enum
:
6584 fill
= s
->fill_statement
.fill
;
6587 case lang_assignment_statement_enum
:
6588 current_assign
= &s
->assignment_statement
;
6589 if (current_assign
->exp
->type
.node_class
!= etree_assert
)
6591 const char *p
= current_assign
->exp
->assign
.dst
;
6593 if (current_os
== abs_output_section
&& p
[0] == '.' && p
[1] == 0)
6594 prefer_next_section
= true;
6598 if (strcmp (p
, "end") == 0)
6601 exp_fold_tree (s
->assignment_statement
.exp
,
6602 (current_os
->bfd_section
!= NULL
6603 ? current_os
->bfd_section
: bfd_und_section_ptr
),
6607 case lang_padding_statement_enum
:
6608 dot
+= TO_ADDR (s
->padding_statement
.size
);
6611 case lang_group_statement_enum
:
6612 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
6613 current_os
, fill
, dot
, found_end
);
6616 case lang_insert_statement_enum
:
6619 case lang_address_statement_enum
:
6631 lang_do_assignments (lang_phase_type phase
)
6633 bool found_end
= false;
6635 current_section
= NULL
;
6636 prefer_next_section
= false;
6637 expld
.phase
= phase
;
6638 lang_statement_iteration
++;
6639 lang_do_assignments_1 (statement_list
.head
,
6640 abs_output_section
, NULL
, 0, &found_end
);
6643 /* For an assignment statement outside of an output section statement,
6644 choose the best of neighbouring output sections to use for values
6648 section_for_dot (void)
6652 /* Assignments belong to the previous output section, unless there
6653 has been an assignment to "dot", in which case following
6654 assignments belong to the next output section. (The assumption
6655 is that an assignment to "dot" is setting up the address for the
6656 next output section.) Except that past the assignment to "_end"
6657 we always associate with the previous section. This exception is
6658 for targets like SH that define an alloc .stack or other
6659 weirdness after non-alloc sections. */
6660 if (current_section
== NULL
|| prefer_next_section
)
6662 lang_statement_union_type
*stmt
;
6663 lang_output_section_statement_type
*os
;
6665 for (stmt
= (lang_statement_union_type
*) current_assign
;
6667 stmt
= stmt
->header
.next
)
6668 if (stmt
->header
.type
== lang_output_section_statement_enum
)
6671 os
= &stmt
->output_section_statement
;
6674 && (os
->bfd_section
== NULL
6675 || (os
->bfd_section
->flags
& SEC_EXCLUDE
) != 0
6676 || bfd_section_removed_from_list (link_info
.output_bfd
,
6680 if (current_section
== NULL
|| os
== NULL
|| !os
->after_end
)
6683 s
= os
->bfd_section
;
6685 s
= link_info
.output_bfd
->section_last
;
6687 && ((s
->flags
& SEC_ALLOC
) == 0
6688 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6693 return bfd_abs_section_ptr
;
6697 s
= current_section
->bfd_section
;
6699 /* The section may have been stripped. */
6701 && ((s
->flags
& SEC_EXCLUDE
) != 0
6702 || (s
->flags
& SEC_ALLOC
) == 0
6703 || (s
->flags
& SEC_THREAD_LOCAL
) != 0
6704 || bfd_section_removed_from_list (link_info
.output_bfd
, s
)))
6707 s
= link_info
.output_bfd
->sections
;
6709 && ((s
->flags
& SEC_ALLOC
) == 0
6710 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6715 return bfd_abs_section_ptr
;
6718 /* Array of __start/__stop/.startof./.sizeof/ symbols. */
6720 static struct bfd_link_hash_entry
**start_stop_syms
;
6721 static size_t start_stop_count
= 0;
6722 static size_t start_stop_alloc
= 0;
6724 /* Give start/stop SYMBOL for SEC a preliminary definition, and add it
6725 to start_stop_syms. */
6728 lang_define_start_stop (const char *symbol
, asection
*sec
)
6730 struct bfd_link_hash_entry
*h
;
6732 h
= bfd_define_start_stop (link_info
.output_bfd
, &link_info
, symbol
, sec
);
6735 if (start_stop_count
== start_stop_alloc
)
6737 start_stop_alloc
= 2 * start_stop_alloc
+ 10;
6739 = xrealloc (start_stop_syms
,
6740 start_stop_alloc
* sizeof (*start_stop_syms
));
6742 start_stop_syms
[start_stop_count
++] = h
;
6746 /* Check for input sections whose names match references to
6747 __start_SECNAME or __stop_SECNAME symbols. Give the symbols
6748 preliminary definitions. */
6751 lang_init_start_stop (void)
6755 char leading_char
= bfd_get_symbol_leading_char (link_info
.output_bfd
);
6757 for (abfd
= link_info
.input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6758 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6761 const char *secname
= s
->name
;
6763 for (ps
= secname
; *ps
!= '\0'; ps
++)
6764 if (!ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
6768 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6770 symbol
[0] = leading_char
;
6771 sprintf (symbol
+ (leading_char
!= 0), "__start_%s", secname
);
6772 lang_define_start_stop (symbol
, s
);
6774 symbol
[1] = leading_char
;
6775 memcpy (symbol
+ 1 + (leading_char
!= 0), "__stop", 6);
6776 lang_define_start_stop (symbol
+ 1, s
);
6783 /* Iterate over start_stop_syms. */
6786 foreach_start_stop (void (*func
) (struct bfd_link_hash_entry
*))
6790 for (i
= 0; i
< start_stop_count
; ++i
)
6791 func (start_stop_syms
[i
]);
6794 /* __start and __stop symbols are only supposed to be defined by the
6795 linker for orphan sections, but we now extend that to sections that
6796 map to an output section of the same name. The symbols were
6797 defined early for --gc-sections, before we mapped input to output
6798 sections, so undo those that don't satisfy this rule. */
6801 undef_start_stop (struct bfd_link_hash_entry
*h
)
6803 if (h
->ldscript_def
)
6806 if (h
->u
.def
.section
->output_section
== NULL
6807 || h
->u
.def
.section
->output_section
->owner
!= link_info
.output_bfd
6808 || strcmp (h
->u
.def
.section
->name
,
6809 h
->u
.def
.section
->output_section
->name
) != 0)
6811 asection
*sec
= bfd_get_section_by_name (link_info
.output_bfd
,
6812 h
->u
.def
.section
->name
);
6815 /* When there are more than one input sections with the same
6816 section name, SECNAME, linker picks the first one to define
6817 __start_SECNAME and __stop_SECNAME symbols. When the first
6818 input section is removed by comdat group, we need to check
6819 if there is still an output section with section name
6822 for (i
= sec
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
6823 if (strcmp (h
->u
.def
.section
->name
, i
->name
) == 0)
6825 h
->u
.def
.section
= i
;
6829 h
->type
= bfd_link_hash_undefined
;
6830 h
->u
.undef
.abfd
= NULL
;
6831 if (is_elf_hash_table (link_info
.hash
))
6833 const struct elf_backend_data
*bed
;
6834 struct elf_link_hash_entry
*eh
= (struct elf_link_hash_entry
*) h
;
6835 unsigned int was_forced
= eh
->forced_local
;
6837 bed
= get_elf_backend_data (link_info
.output_bfd
);
6838 (*bed
->elf_backend_hide_symbol
) (&link_info
, eh
, true);
6839 if (!eh
->ref_regular_nonweak
)
6840 h
->type
= bfd_link_hash_undefweak
;
6841 eh
->def_regular
= 0;
6842 eh
->forced_local
= was_forced
;
6848 lang_undef_start_stop (void)
6850 foreach_start_stop (undef_start_stop
);
6853 /* Check for output sections whose names match references to
6854 .startof.SECNAME or .sizeof.SECNAME symbols. Give the symbols
6855 preliminary definitions. */
6858 lang_init_startof_sizeof (void)
6862 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6864 const char *secname
= s
->name
;
6865 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6867 sprintf (symbol
, ".startof.%s", secname
);
6868 lang_define_start_stop (symbol
, s
);
6870 memcpy (symbol
+ 1, ".size", 5);
6871 lang_define_start_stop (symbol
+ 1, s
);
6876 /* Set .startof., .sizeof., __start and __stop symbols final values. */
6879 set_start_stop (struct bfd_link_hash_entry
*h
)
6882 || h
->type
!= bfd_link_hash_defined
)
6885 if (h
->root
.string
[0] == '.')
6887 /* .startof. or .sizeof. symbol.
6888 .startof. already has final value. */
6889 if (h
->root
.string
[2] == 'i')
6892 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6893 h
->u
.def
.section
= bfd_abs_section_ptr
;
6898 /* __start or __stop symbol. */
6899 int has_lead
= bfd_get_symbol_leading_char (link_info
.output_bfd
) != 0;
6901 h
->u
.def
.section
= h
->u
.def
.section
->output_section
;
6902 if (h
->root
.string
[4 + has_lead
] == 'o')
6905 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6911 lang_finalize_start_stop (void)
6913 foreach_start_stop (set_start_stop
);
6919 struct bfd_link_hash_entry
*h
;
6922 if ((bfd_link_relocatable (&link_info
) && !link_info
.gc_sections
)
6923 || bfd_link_dll (&link_info
))
6924 warn
= entry_from_cmdline
;
6928 /* Force the user to specify a root when generating a relocatable with
6929 --gc-sections, unless --gc-keep-exported was also given. */
6930 if (bfd_link_relocatable (&link_info
)
6931 && link_info
.gc_sections
6932 && !link_info
.gc_keep_exported
)
6934 struct bfd_sym_chain
*sym
;
6936 for (sym
= link_info
.gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
6938 h
= bfd_link_hash_lookup (link_info
.hash
, sym
->name
,
6939 false, false, false);
6941 && (h
->type
== bfd_link_hash_defined
6942 || h
->type
== bfd_link_hash_defweak
)
6943 && !bfd_is_const_section (h
->u
.def
.section
))
6947 einfo (_("%F%P: --gc-sections requires a defined symbol root "
6948 "specified by -e or -u\n"));
6951 if (entry_symbol
.name
== NULL
)
6953 /* No entry has been specified. Look for the default entry, but
6954 don't warn if we don't find it. */
6955 entry_symbol
.name
= entry_symbol_default
;
6959 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
6960 false, false, true);
6962 && (h
->type
== bfd_link_hash_defined
6963 || h
->type
== bfd_link_hash_defweak
)
6964 && h
->u
.def
.section
->output_section
!= NULL
)
6968 val
= (h
->u
.def
.value
6969 + bfd_section_vma (h
->u
.def
.section
->output_section
)
6970 + h
->u
.def
.section
->output_offset
);
6971 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6972 einfo (_("%F%P: %s: can't set start address\n"), entry_symbol
.name
);
6979 /* We couldn't find the entry symbol. Try parsing it as a
6981 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
6984 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6985 einfo (_("%F%P: can't set start address\n"));
6991 /* Can't find the entry symbol, and it's not a number. Use
6992 the first address in the text section. */
6993 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
6997 einfo (_("%P: warning: cannot find entry symbol %s;"
6998 " defaulting to %V\n"),
7000 bfd_section_vma (ts
));
7001 if (!bfd_set_start_address (link_info
.output_bfd
,
7002 bfd_section_vma (ts
)))
7003 einfo (_("%F%P: can't set start address\n"));
7008 einfo (_("%P: warning: cannot find entry symbol %s;"
7009 " not setting start address\n"),
7016 /* This is a small function used when we want to ignore errors from
7020 ignore_bfd_errors (const char *fmt ATTRIBUTE_UNUSED
,
7021 va_list ap ATTRIBUTE_UNUSED
)
7023 /* Don't do anything. */
7026 /* Check that the architecture of all the input files is compatible
7027 with the output file. Also call the backend to let it do any
7028 other checking that is needed. */
7033 lang_input_statement_type
*file
;
7035 const bfd_arch_info_type
*compatible
;
7037 for (file
= (void *) file_chain
.head
;
7041 #if BFD_SUPPORTS_PLUGINS
7042 /* Don't check format of files claimed by plugin. */
7043 if (file
->flags
.claimed
)
7045 #endif /* BFD_SUPPORTS_PLUGINS */
7046 input_bfd
= file
->the_bfd
;
7048 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
7049 command_line
.accept_unknown_input_arch
);
7051 /* In general it is not possible to perform a relocatable
7052 link between differing object formats when the input
7053 file has relocations, because the relocations in the
7054 input format may not have equivalent representations in
7055 the output format (and besides BFD does not translate
7056 relocs for other link purposes than a final link). */
7057 if (!file
->flags
.just_syms
7058 && (bfd_link_relocatable (&link_info
)
7059 || link_info
.emitrelocations
)
7060 && (compatible
== NULL
7061 || (bfd_get_flavour (input_bfd
)
7062 != bfd_get_flavour (link_info
.output_bfd
)))
7063 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
7065 einfo (_("%F%P: relocatable linking with relocations from"
7066 " format %s (%pB) to format %s (%pB) is not supported\n"),
7067 bfd_get_target (input_bfd
), input_bfd
,
7068 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
7069 /* einfo with %F exits. */
7072 if (compatible
== NULL
)
7074 if (command_line
.warn_mismatch
)
7075 einfo (_("%X%P: %s architecture of input file `%pB'"
7076 " is incompatible with %s output\n"),
7077 bfd_printable_name (input_bfd
), input_bfd
,
7078 bfd_printable_name (link_info
.output_bfd
));
7081 /* If the input bfd has no contents, it shouldn't set the
7082 private data of the output bfd. */
7083 else if (!file
->flags
.just_syms
7084 && ((input_bfd
->flags
& DYNAMIC
) != 0
7085 || bfd_count_sections (input_bfd
) != 0))
7087 bfd_error_handler_type pfn
= NULL
;
7089 /* If we aren't supposed to warn about mismatched input
7090 files, temporarily set the BFD error handler to a
7091 function which will do nothing. We still want to call
7092 bfd_merge_private_bfd_data, since it may set up
7093 information which is needed in the output file. */
7094 if (!command_line
.warn_mismatch
)
7095 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
7096 if (!bfd_merge_private_bfd_data (input_bfd
, &link_info
))
7098 if (command_line
.warn_mismatch
)
7099 einfo (_("%X%P: failed to merge target specific data"
7100 " of file %pB\n"), input_bfd
);
7102 if (!command_line
.warn_mismatch
)
7103 bfd_set_error_handler (pfn
);
7108 /* Look through all the global common symbols and attach them to the
7109 correct section. The -sort-common command line switch may be used
7110 to roughly sort the entries by alignment. */
7115 if (link_info
.inhibit_common_definition
)
7117 if (bfd_link_relocatable (&link_info
)
7118 && !command_line
.force_common_definition
)
7121 if (!config
.sort_common
)
7122 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
7127 if (config
.sort_common
== sort_descending
)
7129 for (power
= 4; power
> 0; power
--)
7130 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7133 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7137 for (power
= 0; power
<= 4; power
++)
7138 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7140 power
= (unsigned int) -1;
7141 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7146 /* Place one common symbol in the correct section. */
7149 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
7151 unsigned int power_of_two
;
7155 if (h
->type
!= bfd_link_hash_common
)
7159 power_of_two
= h
->u
.c
.p
->alignment_power
;
7161 if (config
.sort_common
== sort_descending
7162 && power_of_two
< *(unsigned int *) info
)
7164 else if (config
.sort_common
== sort_ascending
7165 && power_of_two
> *(unsigned int *) info
)
7168 section
= h
->u
.c
.p
->section
;
7169 if (!bfd_define_common_symbol (link_info
.output_bfd
, &link_info
, h
))
7170 einfo (_("%F%P: could not define common symbol `%pT': %E\n"),
7173 if (config
.map_file
!= NULL
)
7175 static bool header_printed
;
7180 if (!header_printed
)
7182 minfo (_("\nAllocating common symbols\n"));
7183 minfo (_("Common symbol size file\n\n"));
7184 header_printed
= true;
7187 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
7188 DMGL_ANSI
| DMGL_PARAMS
);
7191 minfo ("%s", h
->root
.string
);
7192 len
= strlen (h
->root
.string
);
7197 len
= strlen (name
);
7213 if (size
<= 0xffffffff)
7214 sprintf (buf
, "%lx", (unsigned long) size
);
7216 sprintf_vma (buf
, size
);
7226 minfo ("%pB\n", section
->owner
);
7232 /* Handle a single orphan section S, placing the orphan into an appropriate
7233 output section. The effects of the --orphan-handling command line
7234 option are handled here. */
7237 ldlang_place_orphan (asection
*s
)
7239 if (config
.orphan_handling
== orphan_handling_discard
)
7241 lang_output_section_statement_type
*os
;
7242 os
= lang_output_section_statement_lookup (DISCARD_SECTION_NAME
, 0, 1);
7243 if (os
->addr_tree
== NULL
7244 && (bfd_link_relocatable (&link_info
)
7245 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
7246 os
->addr_tree
= exp_intop (0);
7247 lang_add_section (&os
->children
, s
, NULL
, NULL
, os
);
7251 lang_output_section_statement_type
*os
;
7252 const char *name
= s
->name
;
7255 if (config
.orphan_handling
== orphan_handling_error
)
7256 einfo (_("%X%P: error: unplaced orphan section `%pA' from `%pB'\n"),
7259 if (config
.unique_orphan_sections
|| unique_section_p (s
, NULL
))
7260 constraint
= SPECIAL
;
7262 os
= ldemul_place_orphan (s
, name
, constraint
);
7265 os
= lang_output_section_statement_lookup (name
, constraint
, 1);
7266 if (os
->addr_tree
== NULL
7267 && (bfd_link_relocatable (&link_info
)
7268 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
7269 os
->addr_tree
= exp_intop (0);
7270 lang_add_section (&os
->children
, s
, NULL
, NULL
, os
);
7273 if (config
.orphan_handling
== orphan_handling_warn
)
7274 einfo (_("%P: warning: orphan section `%pA' from `%pB' being "
7275 "placed in section `%s'\n"),
7276 s
, s
->owner
, os
->name
);
7280 /* Run through the input files and ensure that every input section has
7281 somewhere to go. If one is found without a destination then create
7282 an input request and place it into the statement tree. */
7285 lang_place_orphans (void)
7287 LANG_FOR_EACH_INPUT_STATEMENT (file
)
7291 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
7293 if (s
->output_section
== NULL
)
7295 /* This section of the file is not attached, root
7296 around for a sensible place for it to go. */
7298 if (file
->flags
.just_syms
)
7299 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
7300 else if (lang_discard_section_p (s
))
7301 s
->output_section
= bfd_abs_section_ptr
;
7302 else if (strcmp (s
->name
, "COMMON") == 0)
7304 /* This is a lonely common section which must have
7305 come from an archive. We attach to the section
7306 with the wildcard. */
7307 if (!bfd_link_relocatable (&link_info
)
7308 || command_line
.force_common_definition
)
7310 if (default_common_section
== NULL
)
7311 default_common_section
7312 = lang_output_section_statement_lookup (".bss", 0, 1);
7313 lang_add_section (&default_common_section
->children
, s
,
7314 NULL
, NULL
, default_common_section
);
7318 ldlang_place_orphan (s
);
7325 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
7327 flagword
*ptr_flags
;
7329 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
7335 /* PR 17900: An exclamation mark in the attributes reverses
7336 the sense of any of the attributes that follow. */
7339 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
7343 *ptr_flags
|= SEC_ALLOC
;
7347 *ptr_flags
|= SEC_READONLY
;
7351 *ptr_flags
|= SEC_DATA
;
7355 *ptr_flags
|= SEC_CODE
;
7360 *ptr_flags
|= SEC_LOAD
;
7364 einfo (_("%F%P: invalid character %c (%d) in flags\n"),
7372 /* Call a function on each real input file. This function will be
7373 called on an archive, but not on the elements. */
7376 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
7378 lang_input_statement_type
*f
;
7380 for (f
= (void *) input_file_chain
.head
;
7382 f
= f
->next_real_file
)
7387 /* Call a function on each real file. The function will be called on
7388 all the elements of an archive which are included in the link, but
7389 will not be called on the archive file itself. */
7392 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
7394 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7402 ldlang_add_file (lang_input_statement_type
*entry
)
7404 lang_statement_append (&file_chain
, entry
, &entry
->next
);
7406 /* The BFD linker needs to have a list of all input BFDs involved in
7408 ASSERT (link_info
.input_bfds_tail
!= &entry
->the_bfd
->link
.next
7409 && entry
->the_bfd
->link
.next
== NULL
);
7410 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
7412 *link_info
.input_bfds_tail
= entry
->the_bfd
;
7413 link_info
.input_bfds_tail
= &entry
->the_bfd
->link
.next
;
7414 bfd_set_usrdata (entry
->the_bfd
, entry
);
7415 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
7417 /* Look through the sections and check for any which should not be
7418 included in the link. We need to do this now, so that we can
7419 notice when the backend linker tries to report multiple
7420 definition errors for symbols which are in sections we aren't
7421 going to link. FIXME: It might be better to entirely ignore
7422 symbols which are defined in sections which are going to be
7423 discarded. This would require modifying the backend linker for
7424 each backend which might set the SEC_LINK_ONCE flag. If we do
7425 this, we should probably handle SEC_EXCLUDE in the same way. */
7427 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
7431 lang_add_output (const char *name
, int from_script
)
7433 /* Make -o on command line override OUTPUT in script. */
7434 if (!had_output_filename
|| !from_script
)
7436 output_filename
= name
;
7437 had_output_filename
= true;
7441 lang_output_section_statement_type
*
7442 lang_enter_output_section_statement (const char *output_section_statement_name
,
7443 etree_type
*address_exp
,
7444 enum section_type sectype
,
7446 etree_type
*subalign
,
7449 int align_with_input
)
7451 lang_output_section_statement_type
*os
;
7453 os
= lang_output_section_statement_lookup (output_section_statement_name
,
7455 current_section
= os
;
7457 if (os
->addr_tree
== NULL
)
7459 os
->addr_tree
= address_exp
;
7461 os
->sectype
= sectype
;
7462 if (sectype
!= noload_section
)
7463 os
->flags
= SEC_NO_FLAGS
;
7465 os
->flags
= SEC_NEVER_LOAD
;
7466 os
->block_value
= 1;
7468 /* Make next things chain into subchain of this. */
7469 push_stat_ptr (&os
->children
);
7471 os
->align_lma_with_input
= align_with_input
== ALIGN_WITH_INPUT
;
7472 if (os
->align_lma_with_input
&& align
!= NULL
)
7473 einfo (_("%F%P:%pS: error: align with input and explicit align specified\n"),
7476 os
->subsection_alignment
= subalign
;
7477 os
->section_alignment
= align
;
7479 os
->load_base
= ebase
;
7486 lang_output_statement_type
*new_stmt
;
7488 new_stmt
= new_stat (lang_output_statement
, stat_ptr
);
7489 new_stmt
->name
= output_filename
;
7492 /* Reset the current counters in the regions. */
7495 lang_reset_memory_regions (void)
7497 lang_memory_region_type
*p
= lang_memory_region_list
;
7499 lang_output_section_statement_type
*os
;
7501 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
7503 p
->current
= p
->origin
;
7507 for (os
= (void *) lang_os_list
.head
;
7511 os
->processed_vma
= false;
7512 os
->processed_lma
= false;
7515 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
7517 /* Save the last size for possible use by bfd_relax_section. */
7518 o
->rawsize
= o
->size
;
7519 if (!(o
->flags
& SEC_FIXED_SIZE
))
7524 /* Worker for lang_gc_sections_1. */
7527 gc_section_callback (lang_wild_statement_type
*ptr
,
7528 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7530 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7531 void *data ATTRIBUTE_UNUSED
)
7533 /* If the wild pattern was marked KEEP, the member sections
7534 should be as well. */
7535 if (ptr
->keep_sections
)
7536 section
->flags
|= SEC_KEEP
;
7539 /* Iterate over sections marking them against GC. */
7542 lang_gc_sections_1 (lang_statement_union_type
*s
)
7544 for (; s
!= NULL
; s
= s
->header
.next
)
7546 switch (s
->header
.type
)
7548 case lang_wild_statement_enum
:
7549 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
7551 case lang_constructors_statement_enum
:
7552 lang_gc_sections_1 (constructor_list
.head
);
7554 case lang_output_section_statement_enum
:
7555 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
7557 case lang_group_statement_enum
:
7558 lang_gc_sections_1 (s
->group_statement
.children
.head
);
7567 lang_gc_sections (void)
7569 /* Keep all sections so marked in the link script. */
7570 lang_gc_sections_1 (statement_list
.head
);
7572 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
7573 the special case of .stabstr debug info. (See bfd/stabs.c)
7574 Twiddle the flag here, to simplify later linker code. */
7575 if (bfd_link_relocatable (&link_info
))
7577 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7580 #if BFD_SUPPORTS_PLUGINS
7581 if (f
->flags
.claimed
)
7584 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7585 if ((sec
->flags
& SEC_DEBUGGING
) == 0
7586 || strcmp (sec
->name
, ".stabstr") != 0)
7587 sec
->flags
&= ~SEC_EXCLUDE
;
7591 if (link_info
.gc_sections
)
7592 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
7595 /* Worker for lang_find_relro_sections_1. */
7598 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
7599 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7601 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7604 /* Discarded, excluded and ignored sections effectively have zero
7606 if (section
->output_section
!= NULL
7607 && section
->output_section
->owner
== link_info
.output_bfd
7608 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
7609 && !IGNORE_SECTION (section
)
7610 && section
->size
!= 0)
7612 bool *has_relro_section
= (bool *) data
;
7613 *has_relro_section
= true;
7617 /* Iterate over sections for relro sections. */
7620 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
7621 seg_align_type
*seg
,
7622 bool *has_relro_section
)
7624 if (*has_relro_section
)
7627 for (; s
!= NULL
; s
= s
->header
.next
)
7629 if (s
== seg
->relro_end_stat
)
7632 switch (s
->header
.type
)
7634 case lang_wild_statement_enum
:
7635 walk_wild (&s
->wild_statement
,
7636 find_relro_section_callback
,
7639 case lang_constructors_statement_enum
:
7640 lang_find_relro_sections_1 (constructor_list
.head
,
7641 seg
, has_relro_section
);
7643 case lang_output_section_statement_enum
:
7644 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
7645 seg
, has_relro_section
);
7647 case lang_group_statement_enum
:
7648 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
7649 seg
, has_relro_section
);
7658 lang_find_relro_sections (void)
7660 bool has_relro_section
= false;
7662 /* Check all sections in the link script. */
7664 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
7665 &expld
.dataseg
, &has_relro_section
);
7667 if (!has_relro_section
)
7668 link_info
.relro
= false;
7671 /* Relax all sections until bfd_relax_section gives up. */
7674 lang_relax_sections (bool need_layout
)
7676 if (RELAXATION_ENABLED
)
7678 /* We may need more than one relaxation pass. */
7679 int i
= link_info
.relax_pass
;
7681 /* The backend can use it to determine the current pass. */
7682 link_info
.relax_pass
= 0;
7686 /* Keep relaxing until bfd_relax_section gives up. */
7689 link_info
.relax_trip
= -1;
7692 link_info
.relax_trip
++;
7694 /* Note: pe-dll.c does something like this also. If you find
7695 you need to change this code, you probably need to change
7696 pe-dll.c also. DJ */
7698 /* Do all the assignments with our current guesses as to
7700 lang_do_assignments (lang_assigning_phase_enum
);
7702 /* We must do this after lang_do_assignments, because it uses
7704 lang_reset_memory_regions ();
7706 /* Perform another relax pass - this time we know where the
7707 globals are, so can make a better guess. */
7708 relax_again
= false;
7709 lang_size_sections (&relax_again
, false);
7711 while (relax_again
);
7713 link_info
.relax_pass
++;
7720 /* Final extra sizing to report errors. */
7721 lang_do_assignments (lang_assigning_phase_enum
);
7722 lang_reset_memory_regions ();
7723 lang_size_sections (NULL
, true);
7727 #if BFD_SUPPORTS_PLUGINS
7728 /* Find the insert point for the plugin's replacement files. We
7729 place them after the first claimed real object file, or if the
7730 first claimed object is an archive member, after the last real
7731 object file immediately preceding the archive. In the event
7732 no objects have been claimed at all, we return the first dummy
7733 object file on the list as the insert point; that works, but
7734 the callee must be careful when relinking the file_chain as it
7735 is not actually on that chain, only the statement_list and the
7736 input_file list; in that case, the replacement files must be
7737 inserted at the head of the file_chain. */
7739 static lang_input_statement_type
*
7740 find_replacements_insert_point (bool *before
)
7742 lang_input_statement_type
*claim1
, *lastobject
;
7743 lastobject
= (void *) input_file_chain
.head
;
7744 for (claim1
= (void *) file_chain
.head
;
7746 claim1
= claim1
->next
)
7748 if (claim1
->flags
.claimed
)
7750 *before
= claim1
->flags
.claim_archive
;
7751 return claim1
->flags
.claim_archive
? lastobject
: claim1
;
7753 /* Update lastobject if this is a real object file. */
7754 if (claim1
->the_bfd
!= NULL
&& claim1
->the_bfd
->my_archive
== NULL
)
7755 lastobject
= claim1
;
7757 /* No files were claimed by the plugin. Choose the last object
7758 file found on the list (maybe the first, dummy entry) as the
7764 /* Find where to insert ADD, an archive element or shared library
7765 added during a rescan. */
7767 static lang_input_statement_type
**
7768 find_rescan_insertion (lang_input_statement_type
*add
)
7770 bfd
*add_bfd
= add
->the_bfd
;
7771 lang_input_statement_type
*f
;
7772 lang_input_statement_type
*last_loaded
= NULL
;
7773 lang_input_statement_type
*before
= NULL
;
7774 lang_input_statement_type
**iter
= NULL
;
7776 if (add_bfd
->my_archive
!= NULL
)
7777 add_bfd
= add_bfd
->my_archive
;
7779 /* First look through the input file chain, to find an object file
7780 before the one we've rescanned. Normal object files always
7781 appear on both the input file chain and the file chain, so this
7782 lets us get quickly to somewhere near the correct place on the
7783 file chain if it is full of archive elements. Archives don't
7784 appear on the file chain, but if an element has been extracted
7785 then their input_statement->next points at it. */
7786 for (f
= (void *) input_file_chain
.head
;
7788 f
= f
->next_real_file
)
7790 if (f
->the_bfd
== add_bfd
)
7792 before
= last_loaded
;
7793 if (f
->next
!= NULL
)
7794 return &f
->next
->next
;
7796 if (f
->the_bfd
!= NULL
&& f
->next
!= NULL
)
7800 for (iter
= before
? &before
->next
: &file_chain
.head
->input_statement
.next
;
7802 iter
= &(*iter
)->next
)
7803 if (!(*iter
)->flags
.claim_archive
7804 && (*iter
)->the_bfd
->my_archive
== NULL
)
7810 /* Insert SRCLIST into DESTLIST after given element by chaining
7811 on FIELD as the next-pointer. (Counterintuitively does not need
7812 a pointer to the actual after-node itself, just its chain field.) */
7815 lang_list_insert_after (lang_statement_list_type
*destlist
,
7816 lang_statement_list_type
*srclist
,
7817 lang_statement_union_type
**field
)
7819 *(srclist
->tail
) = *field
;
7820 *field
= srclist
->head
;
7821 if (destlist
->tail
== field
)
7822 destlist
->tail
= srclist
->tail
;
7825 /* Detach new nodes added to DESTLIST since the time ORIGLIST
7826 was taken as a copy of it and leave them in ORIGLIST. */
7829 lang_list_remove_tail (lang_statement_list_type
*destlist
,
7830 lang_statement_list_type
*origlist
)
7832 union lang_statement_union
**savetail
;
7833 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
7834 ASSERT (origlist
->head
== destlist
->head
);
7835 savetail
= origlist
->tail
;
7836 origlist
->head
= *(savetail
);
7837 origlist
->tail
= destlist
->tail
;
7838 destlist
->tail
= savetail
;
7842 static lang_statement_union_type
**
7843 find_next_input_statement (lang_statement_union_type
**s
)
7845 for ( ; *s
; s
= &(*s
)->header
.next
)
7847 lang_statement_union_type
**t
;
7848 switch ((*s
)->header
.type
)
7850 case lang_input_statement_enum
:
7852 case lang_wild_statement_enum
:
7853 t
= &(*s
)->wild_statement
.children
.head
;
7855 case lang_group_statement_enum
:
7856 t
= &(*s
)->group_statement
.children
.head
;
7858 case lang_output_section_statement_enum
:
7859 t
= &(*s
)->output_section_statement
.children
.head
;
7864 t
= find_next_input_statement (t
);
7870 #endif /* BFD_SUPPORTS_PLUGINS */
7872 /* Add NAME to the list of garbage collection entry points. */
7875 lang_add_gc_name (const char *name
)
7877 struct bfd_sym_chain
*sym
;
7882 sym
= stat_alloc (sizeof (*sym
));
7884 sym
->next
= link_info
.gc_sym_list
;
7886 link_info
.gc_sym_list
= sym
;
7889 /* Check relocations. */
7892 lang_check_relocs (void)
7894 if (link_info
.check_relocs_after_open_input
)
7898 for (abfd
= link_info
.input_bfds
;
7899 abfd
!= (bfd
*) NULL
; abfd
= abfd
->link
.next
)
7900 if (!bfd_link_check_relocs (abfd
, &link_info
))
7902 /* No object output, fail return. */
7903 config
.make_executable
= false;
7904 /* Note: we do not abort the loop, but rather
7905 continue the scan in case there are other
7906 bad relocations to report. */
7911 /* Look through all output sections looking for places where we can
7912 propagate forward the lma region. */
7915 lang_propagate_lma_regions (void)
7917 lang_output_section_statement_type
*os
;
7919 for (os
= (void *) lang_os_list
.head
;
7923 if (os
->prev
!= NULL
7924 && os
->lma_region
== NULL
7925 && os
->load_base
== NULL
7926 && os
->addr_tree
== NULL
7927 && os
->region
== os
->prev
->region
)
7928 os
->lma_region
= os
->prev
->lma_region
;
7935 /* Finalize dynamic list. */
7936 if (link_info
.dynamic_list
)
7937 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
7939 current_target
= default_target
;
7941 /* Open the output file. */
7942 lang_for_each_statement (ldlang_open_output
);
7945 ldemul_create_output_section_statements ();
7947 /* Add to the hash table all undefineds on the command line. */
7948 lang_place_undefineds ();
7950 if (!bfd_section_already_linked_table_init ())
7951 einfo (_("%F%P: can not create hash table: %E\n"));
7953 /* A first pass through the memory regions ensures that if any region
7954 references a symbol for its origin or length then this symbol will be
7955 added to the symbol table. Having these symbols in the symbol table
7956 means that when we call open_input_bfds PROVIDE statements will
7957 trigger to provide any needed symbols. The regions origins and
7958 lengths are not assigned as a result of this call. */
7959 lang_do_memory_regions (false);
7961 /* Create a bfd for each input file. */
7962 current_target
= default_target
;
7963 lang_statement_iteration
++;
7964 open_input_bfds (statement_list
.head
, OPEN_BFD_NORMAL
);
7966 /* Now that open_input_bfds has processed assignments and provide
7967 statements we can give values to symbolic origin/length now. */
7968 lang_do_memory_regions (true);
7970 #if BFD_SUPPORTS_PLUGINS
7971 if (link_info
.lto_plugin_active
)
7973 lang_statement_list_type added
;
7974 lang_statement_list_type files
, inputfiles
;
7976 /* Now all files are read, let the plugin(s) decide if there
7977 are any more to be added to the link before we call the
7978 emulation's after_open hook. We create a private list of
7979 input statements for this purpose, which we will eventually
7980 insert into the global statement list after the first claimed
7983 /* We need to manipulate all three chains in synchrony. */
7985 inputfiles
= input_file_chain
;
7986 if (plugin_call_all_symbols_read ())
7987 einfo (_("%F%P: %s: plugin reported error after all symbols read\n"),
7988 plugin_error_plugin ());
7989 link_info
.lto_all_symbols_read
= true;
7990 /* Open any newly added files, updating the file chains. */
7991 plugin_undefs
= link_info
.hash
->undefs_tail
;
7992 open_input_bfds (*added
.tail
, OPEN_BFD_NORMAL
);
7993 if (plugin_undefs
== link_info
.hash
->undefs_tail
)
7994 plugin_undefs
= NULL
;
7995 /* Restore the global list pointer now they have all been added. */
7996 lang_list_remove_tail (stat_ptr
, &added
);
7997 /* And detach the fresh ends of the file lists. */
7998 lang_list_remove_tail (&file_chain
, &files
);
7999 lang_list_remove_tail (&input_file_chain
, &inputfiles
);
8000 /* Were any new files added? */
8001 if (added
.head
!= NULL
)
8003 /* If so, we will insert them into the statement list immediately
8004 after the first input file that was claimed by the plugin,
8005 unless that file was an archive in which case it is inserted
8006 immediately before. */
8008 lang_statement_union_type
**prev
;
8009 plugin_insert
= find_replacements_insert_point (&before
);
8010 /* If a plugin adds input files without having claimed any, we
8011 don't really have a good idea where to place them. Just putting
8012 them at the start or end of the list is liable to leave them
8013 outside the crtbegin...crtend range. */
8014 ASSERT (plugin_insert
!= NULL
);
8015 /* Splice the new statement list into the old one. */
8016 prev
= &plugin_insert
->header
.next
;
8019 prev
= find_next_input_statement (prev
);
8020 if (*prev
!= (void *) plugin_insert
->next_real_file
)
8022 /* We didn't find the expected input statement.
8023 Fall back to adding after plugin_insert. */
8024 prev
= &plugin_insert
->header
.next
;
8027 lang_list_insert_after (stat_ptr
, &added
, prev
);
8028 /* Likewise for the file chains. */
8029 lang_list_insert_after (&input_file_chain
, &inputfiles
,
8030 (void *) &plugin_insert
->next_real_file
);
8031 /* We must be careful when relinking file_chain; we may need to
8032 insert the new files at the head of the list if the insert
8033 point chosen is the dummy first input file. */
8034 if (plugin_insert
->filename
)
8035 lang_list_insert_after (&file_chain
, &files
,
8036 (void *) &plugin_insert
->next
);
8038 lang_list_insert_after (&file_chain
, &files
, &file_chain
.head
);
8040 /* Rescan archives in case new undefined symbols have appeared. */
8042 lang_statement_iteration
++;
8043 open_input_bfds (statement_list
.head
, OPEN_BFD_RESCAN
);
8044 lang_list_remove_tail (&file_chain
, &files
);
8045 while (files
.head
!= NULL
)
8047 lang_input_statement_type
**insert
;
8048 lang_input_statement_type
**iter
, *temp
;
8051 insert
= find_rescan_insertion (&files
.head
->input_statement
);
8052 /* All elements from an archive can be added at once. */
8053 iter
= &files
.head
->input_statement
.next
;
8054 my_arch
= files
.head
->input_statement
.the_bfd
->my_archive
;
8055 if (my_arch
!= NULL
)
8056 for (; *iter
!= NULL
; iter
= &(*iter
)->next
)
8057 if ((*iter
)->the_bfd
->my_archive
!= my_arch
)
8060 *insert
= &files
.head
->input_statement
;
8061 files
.head
= (lang_statement_union_type
*) *iter
;
8063 if (my_arch
!= NULL
)
8065 lang_input_statement_type
*parent
= bfd_usrdata (my_arch
);
8067 parent
->next
= (lang_input_statement_type
*)
8069 - offsetof (lang_input_statement_type
, next
));
8074 #endif /* BFD_SUPPORTS_PLUGINS */
8076 /* Make sure that nobody has tried to add a symbol to this list
8078 ASSERT (link_info
.gc_sym_list
== NULL
);
8080 link_info
.gc_sym_list
= &entry_symbol
;
8082 if (entry_symbol
.name
== NULL
)
8084 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
8086 /* entry_symbol is normally initialied by a ENTRY definition in the
8087 linker script or the -e command line option. But if neither of
8088 these have been used, the target specific backend may still have
8089 provided an entry symbol via a call to lang_default_entry().
8090 Unfortunately this value will not be processed until lang_end()
8091 is called, long after this function has finished. So detect this
8092 case here and add the target's entry symbol to the list of starting
8093 points for garbage collection resolution. */
8094 lang_add_gc_name (entry_symbol_default
);
8097 lang_add_gc_name (link_info
.init_function
);
8098 lang_add_gc_name (link_info
.fini_function
);
8100 ldemul_after_open ();
8101 if (config
.map_file
!= NULL
)
8102 lang_print_asneeded ();
8106 bfd_section_already_linked_table_free ();
8108 /* Make sure that we're not mixing architectures. We call this
8109 after all the input files have been opened, but before we do any
8110 other processing, so that any operations merge_private_bfd_data
8111 does on the output file will be known during the rest of the
8115 /* Handle .exports instead of a version script if we're told to do so. */
8116 if (command_line
.version_exports_section
)
8117 lang_do_version_exports_section ();
8119 /* Build all sets based on the information gathered from the input
8121 ldctor_build_sets ();
8123 /* Give initial values for __start and __stop symbols, so that ELF
8124 gc_sections will keep sections referenced by these symbols. Must
8125 be done before lang_do_assignments below. */
8126 if (config
.build_constructors
)
8127 lang_init_start_stop ();
8129 /* PR 13683: We must rerun the assignments prior to running garbage
8130 collection in order to make sure that all symbol aliases are resolved. */
8131 lang_do_assignments (lang_mark_phase_enum
);
8132 expld
.phase
= lang_first_phase_enum
;
8134 /* Size up the common data. */
8137 /* Remove unreferenced sections if asked to. */
8138 lang_gc_sections ();
8140 lang_mark_undefineds ();
8142 /* Check relocations. */
8143 lang_check_relocs ();
8145 ldemul_after_check_relocs ();
8147 /* Update wild statements. */
8148 update_wild_statements (statement_list
.head
);
8150 /* Run through the contours of the script and attach input sections
8151 to the correct output sections. */
8152 lang_statement_iteration
++;
8153 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
8155 /* Start at the statement immediately after the special abs_section
8156 output statement, so that it isn't reordered. */
8157 process_insert_statements (&lang_os_list
.head
->header
.next
);
8159 ldemul_before_place_orphans ();
8161 /* Find any sections not attached explicitly and handle them. */
8162 lang_place_orphans ();
8164 if (!bfd_link_relocatable (&link_info
))
8168 /* Merge SEC_MERGE sections. This has to be done after GC of
8169 sections, so that GCed sections are not merged, but before
8170 assigning dynamic symbols, since removing whole input sections
8172 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
8174 /* Look for a text section and set the readonly attribute in it. */
8175 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
8179 if (config
.text_read_only
)
8180 found
->flags
|= SEC_READONLY
;
8182 found
->flags
&= ~SEC_READONLY
;
8186 /* Merge together CTF sections. After this, only the symtab-dependent
8187 function and data object sections need adjustment. */
8190 /* Emit the CTF, iff the emulation doesn't need to do late emission after
8191 examining things laid out late, like the strtab. */
8194 /* Copy forward lma regions for output sections in same lma region. */
8195 lang_propagate_lma_regions ();
8197 /* Defining __start/__stop symbols early for --gc-sections to work
8198 around a glibc build problem can result in these symbols being
8199 defined when they should not be. Fix them now. */
8200 if (config
.build_constructors
)
8201 lang_undef_start_stop ();
8203 /* Define .startof./.sizeof. symbols with preliminary values before
8204 dynamic symbols are created. */
8205 if (!bfd_link_relocatable (&link_info
))
8206 lang_init_startof_sizeof ();
8208 /* Do anything special before sizing sections. This is where ELF
8209 and other back-ends size dynamic sections. */
8210 ldemul_before_allocation ();
8212 /* We must record the program headers before we try to fix the
8213 section positions, since they will affect SIZEOF_HEADERS. */
8214 lang_record_phdrs ();
8216 /* Check relro sections. */
8217 if (link_info
.relro
&& !bfd_link_relocatable (&link_info
))
8218 lang_find_relro_sections ();
8220 /* Size up the sections. */
8221 lang_size_sections (NULL
, !RELAXATION_ENABLED
);
8223 /* See if anything special should be done now we know how big
8224 everything is. This is where relaxation is done. */
8225 ldemul_after_allocation ();
8227 /* Fix any __start, __stop, .startof. or .sizeof. symbols. */
8228 lang_finalize_start_stop ();
8230 /* Do all the assignments again, to report errors. Assignment
8231 statements are processed multiple times, updating symbols; In
8232 open_input_bfds, lang_do_assignments, and lang_size_sections.
8233 Since lang_relax_sections calls lang_do_assignments, symbols are
8234 also updated in ldemul_after_allocation. */
8235 lang_do_assignments (lang_final_phase_enum
);
8239 /* Convert absolute symbols to section relative. */
8240 ldexp_finalize_syms ();
8242 /* Make sure that the section addresses make sense. */
8243 if (command_line
.check_section_addresses
)
8244 lang_check_section_addresses ();
8246 /* Check any required symbols are known. */
8247 ldlang_check_require_defined_symbols ();
8252 /* EXPORTED TO YACC */
8255 lang_add_wild (struct wildcard_spec
*filespec
,
8256 struct wildcard_list
*section_list
,
8259 struct wildcard_list
*curr
, *next
;
8260 lang_wild_statement_type
*new_stmt
;
8262 /* Reverse the list as the parser puts it back to front. */
8263 for (curr
= section_list
, section_list
= NULL
;
8265 section_list
= curr
, curr
= next
)
8268 curr
->next
= section_list
;
8271 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
8273 if (strcmp (filespec
->name
, "*") == 0)
8274 filespec
->name
= NULL
;
8275 else if (!wildcardp (filespec
->name
))
8276 lang_has_input_file
= true;
8279 new_stmt
= new_stat (lang_wild_statement
, stat_ptr
);
8280 new_stmt
->filename
= NULL
;
8281 new_stmt
->filenames_sorted
= false;
8282 new_stmt
->section_flag_list
= NULL
;
8283 new_stmt
->exclude_name_list
= NULL
;
8284 if (filespec
!= NULL
)
8286 new_stmt
->filename
= filespec
->name
;
8287 new_stmt
->filenames_sorted
= filespec
->sorted
== by_name
;
8288 new_stmt
->section_flag_list
= filespec
->section_flag_list
;
8289 new_stmt
->exclude_name_list
= filespec
->exclude_name_list
;
8291 new_stmt
->section_list
= section_list
;
8292 new_stmt
->keep_sections
= keep_sections
;
8293 lang_list_init (&new_stmt
->children
);
8294 analyze_walk_wild_section_handler (new_stmt
);
8298 lang_section_start (const char *name
, etree_type
*address
,
8299 const segment_type
*segment
)
8301 lang_address_statement_type
*ad
;
8303 ad
= new_stat (lang_address_statement
, stat_ptr
);
8304 ad
->section_name
= name
;
8305 ad
->address
= address
;
8306 ad
->segment
= segment
;
8309 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
8310 because of a -e argument on the command line, or zero if this is
8311 called by ENTRY in a linker script. Command line arguments take
8315 lang_add_entry (const char *name
, bool cmdline
)
8317 if (entry_symbol
.name
== NULL
8319 || !entry_from_cmdline
)
8321 entry_symbol
.name
= name
;
8322 entry_from_cmdline
= cmdline
;
8326 /* Set the default start symbol to NAME. .em files should use this,
8327 not lang_add_entry, to override the use of "start" if neither the
8328 linker script nor the command line specifies an entry point. NAME
8329 must be permanently allocated. */
8331 lang_default_entry (const char *name
)
8333 entry_symbol_default
= name
;
8337 lang_add_target (const char *name
)
8339 lang_target_statement_type
*new_stmt
;
8341 new_stmt
= new_stat (lang_target_statement
, stat_ptr
);
8342 new_stmt
->target
= name
;
8346 lang_add_map (const char *name
)
8353 map_option_f
= true;
8361 lang_add_fill (fill_type
*fill
)
8363 lang_fill_statement_type
*new_stmt
;
8365 new_stmt
= new_stat (lang_fill_statement
, stat_ptr
);
8366 new_stmt
->fill
= fill
;
8370 lang_add_data (int type
, union etree_union
*exp
)
8372 lang_data_statement_type
*new_stmt
;
8374 new_stmt
= new_stat (lang_data_statement
, stat_ptr
);
8375 new_stmt
->exp
= exp
;
8376 new_stmt
->type
= type
;
8379 /* Create a new reloc statement. RELOC is the BFD relocation type to
8380 generate. HOWTO is the corresponding howto structure (we could
8381 look this up, but the caller has already done so). SECTION is the
8382 section to generate a reloc against, or NAME is the name of the
8383 symbol to generate a reloc against. Exactly one of SECTION and
8384 NAME must be NULL. ADDEND is an expression for the addend. */
8387 lang_add_reloc (bfd_reloc_code_real_type reloc
,
8388 reloc_howto_type
*howto
,
8391 union etree_union
*addend
)
8393 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
8397 p
->section
= section
;
8399 p
->addend_exp
= addend
;
8401 p
->addend_value
= 0;
8402 p
->output_section
= NULL
;
8403 p
->output_offset
= 0;
8406 lang_assignment_statement_type
*
8407 lang_add_assignment (etree_type
*exp
)
8409 lang_assignment_statement_type
*new_stmt
;
8411 new_stmt
= new_stat (lang_assignment_statement
, stat_ptr
);
8412 new_stmt
->exp
= exp
;
8417 lang_add_attribute (enum statement_enum attribute
)
8419 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
8423 lang_startup (const char *name
)
8425 if (first_file
->filename
!= NULL
)
8427 einfo (_("%F%P: multiple STARTUP files\n"));
8429 first_file
->filename
= name
;
8430 first_file
->local_sym_name
= name
;
8431 first_file
->flags
.real
= true;
8435 lang_float (bool maybe
)
8437 lang_float_flag
= maybe
;
8441 /* Work out the load- and run-time regions from a script statement, and
8442 store them in *LMA_REGION and *REGION respectively.
8444 MEMSPEC is the name of the run-time region, or the value of
8445 DEFAULT_MEMORY_REGION if the statement didn't specify one.
8446 LMA_MEMSPEC is the name of the load-time region, or null if the
8447 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
8448 had an explicit load address.
8450 It is an error to specify both a load region and a load address. */
8453 lang_get_regions (lang_memory_region_type
**region
,
8454 lang_memory_region_type
**lma_region
,
8455 const char *memspec
,
8456 const char *lma_memspec
,
8460 *lma_region
= lang_memory_region_lookup (lma_memspec
, false);
8462 /* If no runtime region or VMA has been specified, but the load region
8463 has been specified, then use the load region for the runtime region
8465 if (lma_memspec
!= NULL
8467 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
8468 *region
= *lma_region
;
8470 *region
= lang_memory_region_lookup (memspec
, false);
8472 if (have_lma
&& lma_memspec
!= 0)
8473 einfo (_("%X%P:%pS: section has both a load address and a load region\n"),
8478 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
8479 lang_output_section_phdr_list
*phdrs
,
8480 const char *lma_memspec
)
8482 lang_get_regions (¤t_section
->region
,
8483 ¤t_section
->lma_region
,
8484 memspec
, lma_memspec
,
8485 current_section
->load_base
!= NULL
,
8486 current_section
->addr_tree
!= NULL
);
8488 current_section
->fill
= fill
;
8489 current_section
->phdrs
= phdrs
;
8493 /* Set the output format type. -oformat overrides scripts. */
8496 lang_add_output_format (const char *format
,
8501 if (output_target
== NULL
|| !from_script
)
8503 if (command_line
.endian
== ENDIAN_BIG
8506 else if (command_line
.endian
== ENDIAN_LITTLE
8510 output_target
= format
;
8515 lang_add_insert (const char *where
, int is_before
)
8517 lang_insert_statement_type
*new_stmt
;
8519 new_stmt
= new_stat (lang_insert_statement
, stat_ptr
);
8520 new_stmt
->where
= where
;
8521 new_stmt
->is_before
= is_before
;
8522 saved_script_handle
= previous_script_handle
;
8525 /* Enter a group. This creates a new lang_group_statement, and sets
8526 stat_ptr to build new statements within the group. */
8529 lang_enter_group (void)
8531 lang_group_statement_type
*g
;
8533 g
= new_stat (lang_group_statement
, stat_ptr
);
8534 lang_list_init (&g
->children
);
8535 push_stat_ptr (&g
->children
);
8538 /* Leave a group. This just resets stat_ptr to start writing to the
8539 regular list of statements again. Note that this will not work if
8540 groups can occur inside anything else which can adjust stat_ptr,
8541 but currently they can't. */
8544 lang_leave_group (void)
8549 /* Add a new program header. This is called for each entry in a PHDRS
8550 command in a linker script. */
8553 lang_new_phdr (const char *name
,
8560 struct lang_phdr
*n
, **pp
;
8563 n
= stat_alloc (sizeof (struct lang_phdr
));
8566 n
->type
= exp_get_vma (type
, 0, "program header type");
8567 n
->filehdr
= filehdr
;
8572 hdrs
= n
->type
== 1 && (phdrs
|| filehdr
);
8574 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
8577 && !((*pp
)->filehdr
|| (*pp
)->phdrs
))
8579 einfo (_("%X%P:%pS: PHDRS and FILEHDR are not supported"
8580 " when prior PT_LOAD headers lack them\n"), NULL
);
8587 /* Record the program header information in the output BFD. FIXME: We
8588 should not be calling an ELF specific function here. */
8591 lang_record_phdrs (void)
8595 lang_output_section_phdr_list
*last
;
8596 struct lang_phdr
*l
;
8597 lang_output_section_statement_type
*os
;
8600 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
8603 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
8610 for (os
= (void *) lang_os_list
.head
;
8614 lang_output_section_phdr_list
*pl
;
8616 if (os
->constraint
< 0)
8624 if (os
->sectype
== noload_section
8625 || os
->bfd_section
== NULL
8626 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
8629 /* Don't add orphans to PT_INTERP header. */
8635 lang_output_section_statement_type
*tmp_os
;
8637 /* If we have not run across a section with a program
8638 header assigned to it yet, then scan forwards to find
8639 one. This prevents inconsistencies in the linker's
8640 behaviour when a script has specified just a single
8641 header and there are sections in that script which are
8642 not assigned to it, and which occur before the first
8643 use of that header. See here for more details:
8644 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
8645 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
8648 last
= tmp_os
->phdrs
;
8652 einfo (_("%F%P: no sections assigned to phdrs\n"));
8657 if (os
->bfd_section
== NULL
)
8660 for (; pl
!= NULL
; pl
= pl
->next
)
8662 if (strcmp (pl
->name
, l
->name
) == 0)
8667 secs
= (asection
**) xrealloc (secs
,
8668 alc
* sizeof (asection
*));
8670 secs
[c
] = os
->bfd_section
;
8677 if (l
->flags
== NULL
)
8680 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
8685 at
= exp_get_vma (l
->at
, 0, "phdr load address");
8687 if (!bfd_record_phdr (link_info
.output_bfd
, l
->type
,
8688 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
8689 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
8690 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
8695 /* Make sure all the phdr assignments succeeded. */
8696 for (os
= (void *) lang_os_list
.head
;
8700 lang_output_section_phdr_list
*pl
;
8702 if (os
->constraint
< 0
8703 || os
->bfd_section
== NULL
)
8706 for (pl
= os
->phdrs
;
8709 if (!pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
8710 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
8711 os
->name
, pl
->name
);
8715 /* Record a list of sections which may not be cross referenced. */
8718 lang_add_nocrossref (lang_nocrossref_type
*l
)
8720 struct lang_nocrossrefs
*n
;
8722 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
8723 n
->next
= nocrossref_list
;
8725 n
->onlyfirst
= false;
8726 nocrossref_list
= n
;
8728 /* Set notice_all so that we get informed about all symbols. */
8729 link_info
.notice_all
= true;
8732 /* Record a section that cannot be referenced from a list of sections. */
8735 lang_add_nocrossref_to (lang_nocrossref_type
*l
)
8737 lang_add_nocrossref (l
);
8738 nocrossref_list
->onlyfirst
= true;
8741 /* Overlay handling. We handle overlays with some static variables. */
8743 /* The overlay virtual address. */
8744 static etree_type
*overlay_vma
;
8745 /* And subsection alignment. */
8746 static etree_type
*overlay_subalign
;
8748 /* An expression for the maximum section size seen so far. */
8749 static etree_type
*overlay_max
;
8751 /* A list of all the sections in this overlay. */
8753 struct overlay_list
{
8754 struct overlay_list
*next
;
8755 lang_output_section_statement_type
*os
;
8758 static struct overlay_list
*overlay_list
;
8760 /* Start handling an overlay. */
8763 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
8765 /* The grammar should prevent nested overlays from occurring. */
8766 ASSERT (overlay_vma
== NULL
8767 && overlay_subalign
== NULL
8768 && overlay_max
== NULL
);
8770 overlay_vma
= vma_expr
;
8771 overlay_subalign
= subalign
;
8774 /* Start a section in an overlay. We handle this by calling
8775 lang_enter_output_section_statement with the correct VMA.
8776 lang_leave_overlay sets up the LMA and memory regions. */
8779 lang_enter_overlay_section (const char *name
)
8781 struct overlay_list
*n
;
8784 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
8785 0, overlay_subalign
, 0, 0, 0);
8787 /* If this is the first section, then base the VMA of future
8788 sections on this one. This will work correctly even if `.' is
8789 used in the addresses. */
8790 if (overlay_list
== NULL
)
8791 overlay_vma
= exp_nameop (ADDR
, name
);
8793 /* Remember the section. */
8794 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
8795 n
->os
= current_section
;
8796 n
->next
= overlay_list
;
8799 size
= exp_nameop (SIZEOF
, name
);
8801 /* Arrange to work out the maximum section end address. */
8802 if (overlay_max
== NULL
)
8805 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
8808 /* Finish a section in an overlay. There isn't any special to do
8812 lang_leave_overlay_section (fill_type
*fill
,
8813 lang_output_section_phdr_list
*phdrs
)
8820 name
= current_section
->name
;
8822 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
8823 region and that no load-time region has been specified. It doesn't
8824 really matter what we say here, since lang_leave_overlay will
8826 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
8828 /* Define the magic symbols. */
8830 clean
= (char *) xmalloc (strlen (name
) + 1);
8832 for (s1
= name
; *s1
!= '\0'; s1
++)
8833 if (ISALNUM (*s1
) || *s1
== '_')
8837 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_start_");
8838 sprintf (buf
, "__load_start_%s", clean
);
8839 lang_add_assignment (exp_provide (buf
,
8840 exp_nameop (LOADADDR
, name
),
8843 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_stop_");
8844 sprintf (buf
, "__load_stop_%s", clean
);
8845 lang_add_assignment (exp_provide (buf
,
8847 exp_nameop (LOADADDR
, name
),
8848 exp_nameop (SIZEOF
, name
)),
8854 /* Finish an overlay. If there are any overlay wide settings, this
8855 looks through all the sections in the overlay and sets them. */
8858 lang_leave_overlay (etree_type
*lma_expr
,
8861 const char *memspec
,
8862 lang_output_section_phdr_list
*phdrs
,
8863 const char *lma_memspec
)
8865 lang_memory_region_type
*region
;
8866 lang_memory_region_type
*lma_region
;
8867 struct overlay_list
*l
;
8868 lang_nocrossref_type
*nocrossref
;
8870 lang_get_regions (®ion
, &lma_region
,
8871 memspec
, lma_memspec
,
8872 lma_expr
!= NULL
, false);
8876 /* After setting the size of the last section, set '.' to end of the
8878 if (overlay_list
!= NULL
)
8880 overlay_list
->os
->update_dot
= 1;
8881 overlay_list
->os
->update_dot_tree
8882 = exp_assign (".", exp_binop ('+', overlay_vma
, overlay_max
), false);
8888 struct overlay_list
*next
;
8890 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
8893 l
->os
->region
= region
;
8894 l
->os
->lma_region
= lma_region
;
8896 /* The first section has the load address specified in the
8897 OVERLAY statement. The rest are worked out from that.
8898 The base address is not needed (and should be null) if
8899 an LMA region was specified. */
8902 l
->os
->load_base
= lma_expr
;
8903 l
->os
->sectype
= first_overlay_section
;
8905 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
8906 l
->os
->phdrs
= phdrs
;
8910 lang_nocrossref_type
*nc
;
8912 nc
= (lang_nocrossref_type
*) xmalloc (sizeof *nc
);
8913 nc
->name
= l
->os
->name
;
8914 nc
->next
= nocrossref
;
8923 if (nocrossref
!= NULL
)
8924 lang_add_nocrossref (nocrossref
);
8927 overlay_list
= NULL
;
8929 overlay_subalign
= NULL
;
8932 /* Version handling. This is only useful for ELF. */
8934 /* If PREV is NULL, return first version pattern matching particular symbol.
8935 If PREV is non-NULL, return first version pattern matching particular
8936 symbol after PREV (previously returned by lang_vers_match). */
8938 static struct bfd_elf_version_expr
*
8939 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
8940 struct bfd_elf_version_expr
*prev
,
8944 const char *cxx_sym
= sym
;
8945 const char *java_sym
= sym
;
8946 struct bfd_elf_version_expr
*expr
= NULL
;
8947 enum demangling_styles curr_style
;
8949 curr_style
= CURRENT_DEMANGLING_STYLE
;
8950 cplus_demangle_set_style (no_demangling
);
8951 c_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_NO_OPTS
);
8954 cplus_demangle_set_style (curr_style
);
8956 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8958 cxx_sym
= bfd_demangle (link_info
.output_bfd
, sym
,
8959 DMGL_PARAMS
| DMGL_ANSI
);
8963 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8965 java_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_JAVA
);
8970 if (head
->htab
&& (prev
== NULL
|| prev
->literal
))
8972 struct bfd_elf_version_expr e
;
8974 switch (prev
? prev
->mask
: 0)
8977 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
8980 expr
= (struct bfd_elf_version_expr
*)
8981 htab_find ((htab_t
) head
->htab
, &e
);
8982 while (expr
&& strcmp (expr
->pattern
, c_sym
) == 0)
8983 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
8989 case BFD_ELF_VERSION_C_TYPE
:
8990 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8992 e
.pattern
= cxx_sym
;
8993 expr
= (struct bfd_elf_version_expr
*)
8994 htab_find ((htab_t
) head
->htab
, &e
);
8995 while (expr
&& strcmp (expr
->pattern
, cxx_sym
) == 0)
8996 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
9002 case BFD_ELF_VERSION_CXX_TYPE
:
9003 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
9005 e
.pattern
= java_sym
;
9006 expr
= (struct bfd_elf_version_expr
*)
9007 htab_find ((htab_t
) head
->htab
, &e
);
9008 while (expr
&& strcmp (expr
->pattern
, java_sym
) == 0)
9009 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
9020 /* Finally, try the wildcards. */
9021 if (prev
== NULL
|| prev
->literal
)
9022 expr
= head
->remaining
;
9025 for (; expr
; expr
= expr
->next
)
9032 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
9035 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
9037 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
9041 if (fnmatch (expr
->pattern
, s
, 0) == 0)
9047 free ((char *) c_sym
);
9049 free ((char *) cxx_sym
);
9050 if (java_sym
!= sym
)
9051 free ((char *) java_sym
);
9055 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
9056 return a pointer to the symbol name with any backslash quotes removed. */
9059 realsymbol (const char *pattern
)
9062 bool changed
= false, backslash
= false;
9063 char *s
, *symbol
= (char *) xmalloc (strlen (pattern
) + 1);
9065 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
9067 /* It is a glob pattern only if there is no preceding
9071 /* Remove the preceding backslash. */
9078 if (*p
== '?' || *p
== '*' || *p
== '[')
9085 backslash
= *p
== '\\';
9101 /* This is called for each variable name or match expression. NEW_NAME is
9102 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
9103 pattern to be matched against symbol names. */
9105 struct bfd_elf_version_expr
*
9106 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
9107 const char *new_name
,
9111 struct bfd_elf_version_expr
*ret
;
9113 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
9117 ret
->literal
= true;
9118 ret
->pattern
= literal_p
? new_name
: realsymbol (new_name
);
9119 if (ret
->pattern
== NULL
)
9121 ret
->pattern
= new_name
;
9122 ret
->literal
= false;
9125 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
9126 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
9127 else if (strcasecmp (lang
, "C++") == 0)
9128 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
9129 else if (strcasecmp (lang
, "Java") == 0)
9130 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
9133 einfo (_("%X%P: unknown language `%s' in version information\n"),
9135 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
9138 return ldemul_new_vers_pattern (ret
);
9141 /* This is called for each set of variable names and match
9144 struct bfd_elf_version_tree
*
9145 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
9146 struct bfd_elf_version_expr
*locals
)
9148 struct bfd_elf_version_tree
*ret
;
9150 ret
= (struct bfd_elf_version_tree
*) xcalloc (1, sizeof *ret
);
9151 ret
->globals
.list
= globals
;
9152 ret
->locals
.list
= locals
;
9153 ret
->match
= lang_vers_match
;
9154 ret
->name_indx
= (unsigned int) -1;
9158 /* This static variable keeps track of version indices. */
9160 static int version_index
;
9163 version_expr_head_hash (const void *p
)
9165 const struct bfd_elf_version_expr
*e
=
9166 (const struct bfd_elf_version_expr
*) p
;
9168 return htab_hash_string (e
->pattern
);
9172 version_expr_head_eq (const void *p1
, const void *p2
)
9174 const struct bfd_elf_version_expr
*e1
=
9175 (const struct bfd_elf_version_expr
*) p1
;
9176 const struct bfd_elf_version_expr
*e2
=
9177 (const struct bfd_elf_version_expr
*) p2
;
9179 return strcmp (e1
->pattern
, e2
->pattern
) == 0;
9183 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
9186 struct bfd_elf_version_expr
*e
, *next
;
9187 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
9189 for (e
= head
->list
; e
; e
= e
->next
)
9193 head
->mask
|= e
->mask
;
9198 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
9199 version_expr_head_eq
, NULL
);
9200 list_loc
= &head
->list
;
9201 remaining_loc
= &head
->remaining
;
9202 for (e
= head
->list
; e
; e
= next
)
9208 remaining_loc
= &e
->next
;
9212 void **loc
= htab_find_slot ((htab_t
) head
->htab
, e
, INSERT
);
9216 struct bfd_elf_version_expr
*e1
, *last
;
9218 e1
= (struct bfd_elf_version_expr
*) *loc
;
9222 if (e1
->mask
== e
->mask
)
9230 while (e1
&& strcmp (e1
->pattern
, e
->pattern
) == 0);
9234 /* This is a duplicate. */
9235 /* FIXME: Memory leak. Sometimes pattern is not
9236 xmalloced alone, but in larger chunk of memory. */
9237 /* free (e->pattern); */
9242 e
->next
= last
->next
;
9250 list_loc
= &e
->next
;
9254 *remaining_loc
= NULL
;
9255 *list_loc
= head
->remaining
;
9258 head
->remaining
= head
->list
;
9261 /* This is called when we know the name and dependencies of the
9265 lang_register_vers_node (const char *name
,
9266 struct bfd_elf_version_tree
*version
,
9267 struct bfd_elf_version_deps
*deps
)
9269 struct bfd_elf_version_tree
*t
, **pp
;
9270 struct bfd_elf_version_expr
*e1
;
9275 if (link_info
.version_info
!= NULL
9276 && (name
[0] == '\0' || link_info
.version_info
->name
[0] == '\0'))
9278 einfo (_("%X%P: anonymous version tag cannot be combined"
9279 " with other version tags\n"));
9284 /* Make sure this node has a unique name. */
9285 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9286 if (strcmp (t
->name
, name
) == 0)
9287 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
9289 lang_finalize_version_expr_head (&version
->globals
);
9290 lang_finalize_version_expr_head (&version
->locals
);
9292 /* Check the global and local match names, and make sure there
9293 aren't any duplicates. */
9295 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
9297 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9299 struct bfd_elf_version_expr
*e2
;
9301 if (t
->locals
.htab
&& e1
->literal
)
9303 e2
= (struct bfd_elf_version_expr
*)
9304 htab_find ((htab_t
) t
->locals
.htab
, e1
);
9305 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
9307 if (e1
->mask
== e2
->mask
)
9308 einfo (_("%X%P: duplicate expression `%s'"
9309 " in version information\n"), e1
->pattern
);
9313 else if (!e1
->literal
)
9314 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
9315 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
9316 && e1
->mask
== e2
->mask
)
9317 einfo (_("%X%P: duplicate expression `%s'"
9318 " in version information\n"), e1
->pattern
);
9322 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
9324 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9326 struct bfd_elf_version_expr
*e2
;
9328 if (t
->globals
.htab
&& e1
->literal
)
9330 e2
= (struct bfd_elf_version_expr
*)
9331 htab_find ((htab_t
) t
->globals
.htab
, e1
);
9332 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
9334 if (e1
->mask
== e2
->mask
)
9335 einfo (_("%X%P: duplicate expression `%s'"
9336 " in version information\n"),
9341 else if (!e1
->literal
)
9342 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
9343 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
9344 && e1
->mask
== e2
->mask
)
9345 einfo (_("%X%P: duplicate expression `%s'"
9346 " in version information\n"), e1
->pattern
);
9350 version
->deps
= deps
;
9351 version
->name
= name
;
9352 if (name
[0] != '\0')
9355 version
->vernum
= version_index
;
9358 version
->vernum
= 0;
9360 for (pp
= &link_info
.version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
9365 /* This is called when we see a version dependency. */
9367 struct bfd_elf_version_deps
*
9368 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
9370 struct bfd_elf_version_deps
*ret
;
9371 struct bfd_elf_version_tree
*t
;
9373 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
9376 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9378 if (strcmp (t
->name
, name
) == 0)
9380 ret
->version_needed
= t
;
9385 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
9387 ret
->version_needed
= NULL
;
9392 lang_do_version_exports_section (void)
9394 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
9396 LANG_FOR_EACH_INPUT_STATEMENT (is
)
9398 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
9406 contents
= (char *) xmalloc (len
);
9407 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
9408 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
9411 while (p
< contents
+ len
)
9413 greg
= lang_new_vers_pattern (greg
, p
, NULL
, false);
9414 p
= strchr (p
, '\0') + 1;
9417 /* Do not free the contents, as we used them creating the regex. */
9419 /* Do not include this section in the link. */
9420 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
9423 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, false);
9424 lang_register_vers_node (command_line
.version_exports_section
,
9425 lang_new_vers_node (greg
, lreg
), NULL
);
9428 /* Evaluate LENGTH and ORIGIN parts of MEMORY spec. This is initially
9429 called with UPDATE_REGIONS_P set to FALSE, in this case no errors are
9430 thrown, however, references to symbols in the origin and length fields
9431 will be pushed into the symbol table, this allows PROVIDE statements to
9432 then provide these symbols. This function is called a second time with
9433 UPDATE_REGIONS_P set to TRUE, this time the we update the actual region
9434 data structures, and throw errors if missing symbols are encountered. */
9437 lang_do_memory_regions (bool update_regions_p
)
9439 lang_memory_region_type
*r
= lang_memory_region_list
;
9441 for (; r
!= NULL
; r
= r
->next
)
9445 exp_fold_tree_no_dot (r
->origin_exp
);
9446 if (update_regions_p
)
9448 if (expld
.result
.valid_p
)
9450 r
->origin
= expld
.result
.value
;
9451 r
->current
= r
->origin
;
9454 einfo (_("%P: invalid origin for memory region %s\n"),
9460 exp_fold_tree_no_dot (r
->length_exp
);
9461 if (update_regions_p
)
9463 if (expld
.result
.valid_p
)
9464 r
->length
= expld
.result
.value
;
9466 einfo (_("%P: invalid length for memory region %s\n"),
9474 lang_add_unique (const char *name
)
9476 struct unique_sections
*ent
;
9478 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
9479 if (strcmp (ent
->name
, name
) == 0)
9482 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
9483 ent
->name
= xstrdup (name
);
9484 ent
->next
= unique_section_list
;
9485 unique_section_list
= ent
;
9488 /* Append the list of dynamic symbols to the existing one. */
9491 lang_append_dynamic_list (struct bfd_elf_dynamic_list
**list_p
,
9492 struct bfd_elf_version_expr
*dynamic
)
9496 struct bfd_elf_version_expr
*tail
;
9497 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
9499 tail
->next
= (*list_p
)->head
.list
;
9500 (*list_p
)->head
.list
= dynamic
;
9504 struct bfd_elf_dynamic_list
*d
;
9506 d
= (struct bfd_elf_dynamic_list
*) xcalloc (1, sizeof *d
);
9507 d
->head
.list
= dynamic
;
9508 d
->match
= lang_vers_match
;
9513 /* Append the list of C++ typeinfo dynamic symbols to the existing
9517 lang_append_dynamic_list_cpp_typeinfo (void)
9519 const char *symbols
[] =
9521 "typeinfo name for*",
9524 struct bfd_elf_version_expr
*dynamic
= NULL
;
9527 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9528 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9531 lang_append_dynamic_list (&link_info
.dynamic_list
, dynamic
);
9534 /* Append the list of C++ operator new and delete dynamic symbols to the
9538 lang_append_dynamic_list_cpp_new (void)
9540 const char *symbols
[] =
9545 struct bfd_elf_version_expr
*dynamic
= NULL
;
9548 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9549 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9552 lang_append_dynamic_list (&link_info
.dynamic_list
, dynamic
);
9555 /* Scan a space and/or comma separated string of features. */
9558 lang_ld_feature (char *str
)
9566 while (*p
== ',' || ISSPACE (*p
))
9571 while (*q
&& *q
!= ',' && !ISSPACE (*q
))
9575 if (strcasecmp (p
, "SANE_EXPR") == 0)
9576 config
.sane_expr
= true;
9578 einfo (_("%X%P: unknown feature `%s'\n"), p
);
9584 /* Pretty print memory amount. */
9587 lang_print_memory_size (bfd_vma sz
)
9589 if ((sz
& 0x3fffffff) == 0)
9590 printf ("%10" BFD_VMA_FMT
"u GB", sz
>> 30);
9591 else if ((sz
& 0xfffff) == 0)
9592 printf ("%10" BFD_VMA_FMT
"u MB", sz
>> 20);
9593 else if ((sz
& 0x3ff) == 0)
9594 printf ("%10" BFD_VMA_FMT
"u KB", sz
>> 10);
9596 printf (" %10" BFD_VMA_FMT
"u B", sz
);
9599 /* Implement --print-memory-usage: disply per region memory usage. */
9602 lang_print_memory_usage (void)
9604 lang_memory_region_type
*r
;
9606 printf ("Memory region Used Size Region Size %%age Used\n");
9607 for (r
= lang_memory_region_list
; r
->next
!= NULL
; r
= r
->next
)
9609 bfd_vma used_length
= r
->current
- r
->origin
;
9611 printf ("%16s: ",r
->name_list
.name
);
9612 lang_print_memory_size (used_length
);
9613 lang_print_memory_size ((bfd_vma
) r
->length
);
9617 double percent
= used_length
* 100.0 / r
->length
;
9618 printf (" %6.2f%%", percent
);