1 /* Linker command language support.
2 Copyright (C) 1991-2020 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 bfd_boolean map_head_is_link_order
= FALSE
;
67 static lang_output_section_statement_type
*default_common_section
;
68 static bfd_boolean map_option_f
;
69 static bfd_vma print_dot
;
70 static lang_input_statement_type
*first_file
;
71 static const char *current_target
;
72 /* Header for list of statements corresponding to any files involved in the
73 link, either specified from the command-line or added implicitely (eg.
74 archive member used to resolved undefined symbol, wildcard statement from
75 linker script, etc.). Next pointer is in next field of a
76 lang_statement_header_type (reached via header field in a
77 lang_statement_union). */
78 static lang_statement_list_type statement_list
;
79 static lang_statement_list_type
*stat_save
[10];
80 static lang_statement_list_type
**stat_save_ptr
= &stat_save
[0];
81 static struct unique_sections
*unique_section_list
;
82 static struct asneeded_minfo
*asneeded_list_head
;
83 static unsigned int opb_shift
= 0;
85 /* Forward declarations. */
86 static void exp_init_os (etree_type
*);
87 static lang_input_statement_type
*lookup_name (const char *);
88 static void insert_undefined (const char *);
89 static bfd_boolean
sort_def_symbol (struct bfd_link_hash_entry
*, void *);
90 static void print_statement (lang_statement_union_type
*,
91 lang_output_section_statement_type
*);
92 static void print_statement_list (lang_statement_union_type
*,
93 lang_output_section_statement_type
*);
94 static void print_statements (void);
95 static void print_input_section (asection
*, bfd_boolean
);
96 static bfd_boolean
lang_one_common (struct bfd_link_hash_entry
*, void *);
97 static void lang_record_phdrs (void);
98 static void lang_do_version_exports_section (void);
99 static void lang_finalize_version_expr_head
100 (struct bfd_elf_version_expr_head
*);
101 static void lang_do_memory_regions (bfd_boolean
);
103 /* Exported variables. */
104 const char *output_target
;
105 lang_output_section_statement_type
*abs_output_section
;
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 bfd_boolean entry_from_cmdline
;
126 bfd_boolean lang_has_input_file
= FALSE
;
127 bfd_boolean had_output_filename
= FALSE
;
128 bfd_boolean lang_float_flag
= FALSE
;
129 bfd_boolean 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
)
226 bfd_boolean match
= FALSE
;
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
, ptr
->section_flag_list
, 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
, ptr
->section_flag_list
, file
, data
);
346 bfd_boolean skip
= FALSE
;
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 bfd_boolean 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 bfd_boolean
*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 struct flag_info
*sflag_list ATTRIBUTE_UNUSED
,
570 lang_input_statement_type
*file
,
573 lang_section_bst_type
*node
;
574 lang_section_bst_type
**tree
;
575 lang_output_section_statement_type
*os
;
577 os
= (lang_output_section_statement_type
*) output
;
579 if (unique_section_p (section
, os
))
582 node
= (lang_section_bst_type
*) xmalloc (sizeof (lang_section_bst_type
));
585 node
->section
= section
;
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
, 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 bfd_boolean 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 bfd_boolean 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 bfd_boolean 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 bfd_boolean 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 bfd_boolean 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 bfd_boolean 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 bfd_boolean 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 bfd_boolean skip
= !match_simple_wild (wildsec2
->spec
.name
,
775 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
779 skip
= !match_simple_wild (wildsec3
->spec
.name
, sname
);
781 walk_wild_consider_section (ptr
, file
, s
, wildsec3
,
789 walk_wild_section (lang_wild_statement_type
*ptr
,
790 lang_input_statement_type
*file
,
794 if (file
->flags
.just_syms
)
797 (*ptr
->walk_wild_section_handler
) (ptr
, file
, callback
, data
);
800 /* Returns TRUE when name1 is a wildcard spec that might match
801 something name2 can match. We're conservative: we return FALSE
802 only if the prefixes of name1 and name2 are different up to the
803 first wildcard character. */
806 wild_spec_can_overlap (const char *name1
, const char *name2
)
808 size_t prefix1_len
= strcspn (name1
, "?*[");
809 size_t prefix2_len
= strcspn (name2
, "?*[");
810 size_t min_prefix_len
;
812 /* Note that if there is no wildcard character, then we treat the
813 terminating 0 as part of the prefix. Thus ".text" won't match
814 ".text." or ".text.*", for example. */
815 if (name1
[prefix1_len
] == '\0')
817 if (name2
[prefix2_len
] == '\0')
820 min_prefix_len
= prefix1_len
< prefix2_len
? prefix1_len
: prefix2_len
;
822 return memcmp (name1
, name2
, min_prefix_len
) == 0;
825 /* Select specialized code to handle various kinds of wildcard
829 analyze_walk_wild_section_handler (lang_wild_statement_type
*ptr
)
832 int wild_name_count
= 0;
833 struct wildcard_list
*sec
;
837 ptr
->walk_wild_section_handler
= walk_wild_section_general
;
838 ptr
->handler_data
[0] = NULL
;
839 ptr
->handler_data
[1] = NULL
;
840 ptr
->handler_data
[2] = NULL
;
841 ptr
->handler_data
[3] = NULL
;
844 /* Count how many wildcard_specs there are, and how many of those
845 actually use wildcards in the name. Also, bail out if any of the
846 wildcard names are NULL. (Can this actually happen?
847 walk_wild_section used to test for it.) And bail out if any
848 of the wildcards are more complex than a simple string
849 ending in a single '*'. */
850 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
853 if (sec
->spec
.name
== NULL
)
855 if (wildcardp (sec
->spec
.name
))
858 if (!is_simple_wild (sec
->spec
.name
))
863 /* The zero-spec case would be easy to optimize but it doesn't
864 happen in practice. Likewise, more than 4 specs doesn't
865 happen in practice. */
866 if (sec_count
== 0 || sec_count
> 4)
869 /* Check that no two specs can match the same section. */
870 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
872 struct wildcard_list
*sec2
;
873 for (sec2
= sec
->next
; sec2
!= NULL
; sec2
= sec2
->next
)
875 if (wild_spec_can_overlap (sec
->spec
.name
, sec2
->spec
.name
))
880 signature
= (sec_count
<< 8) + wild_name_count
;
884 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild0
;
887 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild1
;
890 ptr
->walk_wild_section_handler
= walk_wild_section_specs2_wild1
;
893 ptr
->walk_wild_section_handler
= walk_wild_section_specs3_wild2
;
896 ptr
->walk_wild_section_handler
= walk_wild_section_specs4_wild2
;
902 /* Now fill the data array with pointers to the specs, first the
903 specs with non-wildcard names, then the specs with wildcard
904 names. It's OK to process the specs in different order from the
905 given order, because we've already determined that no section
906 will match more than one spec. */
908 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
909 if (!wildcardp (sec
->spec
.name
))
910 ptr
->handler_data
[data_counter
++] = sec
;
911 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
912 if (wildcardp (sec
->spec
.name
))
913 ptr
->handler_data
[data_counter
++] = sec
;
916 /* Handle a wild statement for a single file F. */
919 walk_wild_file (lang_wild_statement_type
*s
,
920 lang_input_statement_type
*f
,
924 if (walk_wild_file_in_exclude_list (s
->exclude_name_list
, f
))
927 if (f
->the_bfd
== NULL
928 || !bfd_check_format (f
->the_bfd
, bfd_archive
))
929 walk_wild_section (s
, f
, callback
, data
);
934 /* This is an archive file. We must map each member of the
935 archive separately. */
936 member
= bfd_openr_next_archived_file (f
->the_bfd
, NULL
);
937 while (member
!= NULL
)
939 /* When lookup_name is called, it will call the add_symbols
940 entry point for the archive. For each element of the
941 archive which is included, BFD will call ldlang_add_file,
942 which will set the usrdata field of the member to the
943 lang_input_statement. */
944 if (bfd_usrdata (member
) != NULL
)
945 walk_wild_section (s
, bfd_usrdata (member
), callback
, data
);
947 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
953 walk_wild (lang_wild_statement_type
*s
, callback_t callback
, void *data
)
955 const char *file_spec
= s
->filename
;
958 if (file_spec
== NULL
)
960 /* Perform the iteration over all files in the list. */
961 LANG_FOR_EACH_INPUT_STATEMENT (f
)
963 walk_wild_file (s
, f
, callback
, data
);
966 else if ((p
= archive_path (file_spec
)) != NULL
)
968 LANG_FOR_EACH_INPUT_STATEMENT (f
)
970 if (input_statement_is_archive_path (file_spec
, p
, f
))
971 walk_wild_file (s
, f
, callback
, data
);
974 else if (wildcardp (file_spec
))
976 LANG_FOR_EACH_INPUT_STATEMENT (f
)
978 if (fnmatch (file_spec
, f
->filename
, 0) == 0)
979 walk_wild_file (s
, f
, callback
, data
);
984 lang_input_statement_type
*f
;
986 /* Perform the iteration over a single file. */
987 f
= lookup_name (file_spec
);
989 walk_wild_file (s
, f
, callback
, data
);
993 /* lang_for_each_statement walks the parse tree and calls the provided
994 function for each node, except those inside output section statements
995 with constraint set to -1. */
998 lang_for_each_statement_worker (void (*func
) (lang_statement_union_type
*),
999 lang_statement_union_type
*s
)
1001 for (; s
!= NULL
; s
= s
->header
.next
)
1005 switch (s
->header
.type
)
1007 case lang_constructors_statement_enum
:
1008 lang_for_each_statement_worker (func
, constructor_list
.head
);
1010 case lang_output_section_statement_enum
:
1011 if (s
->output_section_statement
.constraint
!= -1)
1012 lang_for_each_statement_worker
1013 (func
, s
->output_section_statement
.children
.head
);
1015 case lang_wild_statement_enum
:
1016 lang_for_each_statement_worker (func
,
1017 s
->wild_statement
.children
.head
);
1019 case lang_group_statement_enum
:
1020 lang_for_each_statement_worker (func
,
1021 s
->group_statement
.children
.head
);
1023 case lang_data_statement_enum
:
1024 case lang_reloc_statement_enum
:
1025 case lang_object_symbols_statement_enum
:
1026 case lang_output_statement_enum
:
1027 case lang_target_statement_enum
:
1028 case lang_input_section_enum
:
1029 case lang_input_statement_enum
:
1030 case lang_assignment_statement_enum
:
1031 case lang_padding_statement_enum
:
1032 case lang_address_statement_enum
:
1033 case lang_fill_statement_enum
:
1034 case lang_insert_statement_enum
:
1044 lang_for_each_statement (void (*func
) (lang_statement_union_type
*))
1046 lang_for_each_statement_worker (func
, statement_list
.head
);
1049 /*----------------------------------------------------------------------*/
1052 lang_list_init (lang_statement_list_type
*list
)
1055 list
->tail
= &list
->head
;
1059 lang_statement_append (lang_statement_list_type
*list
,
1063 *(list
->tail
) = element
;
1068 push_stat_ptr (lang_statement_list_type
*new_ptr
)
1070 if (stat_save_ptr
>= stat_save
+ sizeof (stat_save
) / sizeof (stat_save
[0]))
1072 *stat_save_ptr
++ = stat_ptr
;
1079 if (stat_save_ptr
<= stat_save
)
1081 stat_ptr
= *--stat_save_ptr
;
1084 /* Build a new statement node for the parse tree. */
1086 static lang_statement_union_type
*
1087 new_statement (enum statement_enum type
,
1089 lang_statement_list_type
*list
)
1091 lang_statement_union_type
*new_stmt
;
1093 new_stmt
= stat_alloc (size
);
1094 new_stmt
->header
.type
= type
;
1095 new_stmt
->header
.next
= NULL
;
1096 lang_statement_append (list
, new_stmt
, &new_stmt
->header
.next
);
1100 /* Build a new input file node for the language. There are several
1101 ways in which we treat an input file, eg, we only look at symbols,
1102 or prefix it with a -l etc.
1104 We can be supplied with requests for input files more than once;
1105 they may, for example be split over several lines like foo.o(.text)
1106 foo.o(.data) etc, so when asked for a file we check that we haven't
1107 got it already so we don't duplicate the bfd. */
1109 static lang_input_statement_type
*
1110 new_afile (const char *name
,
1111 lang_input_file_enum_type file_type
,
1113 const char *from_filename
)
1115 lang_input_statement_type
*p
;
1117 lang_has_input_file
= TRUE
;
1119 p
= new_stat (lang_input_statement
, stat_ptr
);
1120 memset (&p
->the_bfd
, 0,
1121 sizeof (*p
) - offsetof (lang_input_statement_type
, the_bfd
));
1122 p
->extra_search_path
= NULL
;
1124 p
->flags
.dynamic
= input_flags
.dynamic
;
1125 p
->flags
.add_DT_NEEDED_for_dynamic
= input_flags
.add_DT_NEEDED_for_dynamic
;
1126 p
->flags
.add_DT_NEEDED_for_regular
= input_flags
.add_DT_NEEDED_for_regular
;
1127 p
->flags
.whole_archive
= input_flags
.whole_archive
;
1128 p
->flags
.sysrooted
= input_flags
.sysrooted
;
1132 case lang_input_file_is_symbols_only_enum
:
1134 p
->local_sym_name
= name
;
1135 p
->flags
.real
= TRUE
;
1136 p
->flags
.just_syms
= TRUE
;
1138 case lang_input_file_is_fake_enum
:
1140 p
->local_sym_name
= name
;
1142 case lang_input_file_is_l_enum
:
1143 if (name
[0] == ':' && name
[1] != '\0')
1145 p
->filename
= name
+ 1;
1146 p
->flags
.full_name_provided
= TRUE
;
1150 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
1151 p
->flags
.maybe_archive
= TRUE
;
1152 p
->flags
.real
= TRUE
;
1153 p
->flags
.search_dirs
= TRUE
;
1155 case lang_input_file_is_marker_enum
:
1157 p
->local_sym_name
= name
;
1158 p
->flags
.search_dirs
= TRUE
;
1160 case lang_input_file_is_search_file_enum
:
1162 p
->local_sym_name
= name
;
1163 /* If name is a relative path, search the directory of the current linker
1165 if (from_filename
&& !IS_ABSOLUTE_PATH (name
))
1166 p
->extra_search_path
= ldirname (from_filename
);
1167 p
->flags
.real
= TRUE
;
1168 p
->flags
.search_dirs
= TRUE
;
1170 case lang_input_file_is_file_enum
:
1172 p
->local_sym_name
= name
;
1173 p
->flags
.real
= TRUE
;
1179 lang_statement_append (&input_file_chain
, p
, &p
->next_real_file
);
1183 lang_input_statement_type
*
1184 lang_add_input_file (const char *name
,
1185 lang_input_file_enum_type file_type
,
1189 && (*name
== '=' || CONST_STRNEQ (name
, "$SYSROOT")))
1191 lang_input_statement_type
*ret
;
1192 char *sysrooted_name
1193 = concat (ld_sysroot
,
1194 name
+ (*name
== '=' ? 1 : strlen ("$SYSROOT")),
1195 (const char *) NULL
);
1197 /* We've now forcibly prepended the sysroot, making the input
1198 file independent of the context. Therefore, temporarily
1199 force a non-sysrooted context for this statement, so it won't
1200 get the sysroot prepended again when opened. (N.B. if it's a
1201 script, any child nodes with input files starting with "/"
1202 will be handled as "sysrooted" as they'll be found to be
1203 within the sysroot subdirectory.) */
1204 unsigned int outer_sysrooted
= input_flags
.sysrooted
;
1205 input_flags
.sysrooted
= 0;
1206 ret
= new_afile (sysrooted_name
, file_type
, target
, NULL
);
1207 input_flags
.sysrooted
= outer_sysrooted
;
1211 return new_afile (name
, file_type
, target
, current_input_file
);
1214 struct out_section_hash_entry
1216 struct bfd_hash_entry root
;
1217 lang_statement_union_type s
;
1220 /* The hash table. */
1222 static struct bfd_hash_table output_section_statement_table
;
1224 /* Support routines for the hash table used by lang_output_section_find,
1225 initialize the table, fill in an entry and remove the table. */
1227 static struct bfd_hash_entry
*
1228 output_section_statement_newfunc (struct bfd_hash_entry
*entry
,
1229 struct bfd_hash_table
*table
,
1232 lang_output_section_statement_type
**nextp
;
1233 struct out_section_hash_entry
*ret
;
1237 entry
= (struct bfd_hash_entry
*) bfd_hash_allocate (table
,
1243 entry
= bfd_hash_newfunc (entry
, table
, string
);
1247 ret
= (struct out_section_hash_entry
*) entry
;
1248 memset (&ret
->s
, 0, sizeof (ret
->s
));
1249 ret
->s
.header
.type
= lang_output_section_statement_enum
;
1250 ret
->s
.output_section_statement
.subsection_alignment
= NULL
;
1251 ret
->s
.output_section_statement
.section_alignment
= NULL
;
1252 ret
->s
.output_section_statement
.block_value
= 1;
1253 lang_list_init (&ret
->s
.output_section_statement
.children
);
1254 lang_statement_append (stat_ptr
, &ret
->s
, &ret
->s
.header
.next
);
1256 /* For every output section statement added to the list, except the
1257 first one, lang_os_list.tail points to the "next"
1258 field of the last element of the list. */
1259 if (lang_os_list
.head
!= NULL
)
1260 ret
->s
.output_section_statement
.prev
1261 = ((lang_output_section_statement_type
*)
1262 ((char *) lang_os_list
.tail
1263 - offsetof (lang_output_section_statement_type
, next
)));
1265 /* GCC's strict aliasing rules prevent us from just casting the
1266 address, so we store the pointer in a variable and cast that
1268 nextp
= &ret
->s
.output_section_statement
.next
;
1269 lang_statement_append (&lang_os_list
, &ret
->s
, nextp
);
1274 output_section_statement_table_init (void)
1276 if (!bfd_hash_table_init_n (&output_section_statement_table
,
1277 output_section_statement_newfunc
,
1278 sizeof (struct out_section_hash_entry
),
1280 einfo (_("%F%P: can not create hash table: %E\n"));
1284 output_section_statement_table_free (void)
1286 bfd_hash_table_free (&output_section_statement_table
);
1289 /* Build enough state so that the parser can build its tree. */
1294 obstack_begin (&stat_obstack
, 1000);
1296 stat_ptr
= &statement_list
;
1298 output_section_statement_table_init ();
1300 lang_list_init (stat_ptr
);
1302 lang_list_init (&input_file_chain
);
1303 lang_list_init (&lang_os_list
);
1304 lang_list_init (&file_chain
);
1305 first_file
= lang_add_input_file (NULL
, lang_input_file_is_marker_enum
,
1307 abs_output_section
=
1308 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
, 0, TRUE
);
1310 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
1312 asneeded_list_head
= NULL
;
1313 asneeded_list_tail
= &asneeded_list_head
;
1319 output_section_statement_table_free ();
1322 /*----------------------------------------------------------------------
1323 A region is an area of memory declared with the
1324 MEMORY { name:org=exp, len=exp ... }
1327 We maintain a list of all the regions here.
1329 If no regions are specified in the script, then the default is used
1330 which is created when looked up to be the entire data space.
1332 If create is true we are creating a region inside a MEMORY block.
1333 In this case it is probably an error to create a region that has
1334 already been created. If we are not inside a MEMORY block it is
1335 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1336 and so we issue a warning.
1338 Each region has at least one name. The first name is either
1339 DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add
1340 alias names to an existing region within a script with
1341 REGION_ALIAS (alias, region_name). Each name corresponds to at most one
1344 static lang_memory_region_type
*lang_memory_region_list
;
1345 static lang_memory_region_type
**lang_memory_region_list_tail
1346 = &lang_memory_region_list
;
1348 lang_memory_region_type
*
1349 lang_memory_region_lookup (const char *const name
, bfd_boolean create
)
1351 lang_memory_region_name
*n
;
1352 lang_memory_region_type
*r
;
1353 lang_memory_region_type
*new_region
;
1355 /* NAME is NULL for LMA memspecs if no region was specified. */
1359 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1360 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1361 if (strcmp (n
->name
, name
) == 0)
1364 einfo (_("%P:%pS: warning: redeclaration of memory region `%s'\n"),
1369 if (!create
&& strcmp (name
, DEFAULT_MEMORY_REGION
))
1370 einfo (_("%P:%pS: warning: memory region `%s' not declared\n"),
1373 new_region
= stat_alloc (sizeof (lang_memory_region_type
));
1375 new_region
->name_list
.name
= xstrdup (name
);
1376 new_region
->name_list
.next
= NULL
;
1377 new_region
->next
= NULL
;
1378 new_region
->origin_exp
= NULL
;
1379 new_region
->origin
= 0;
1380 new_region
->length_exp
= NULL
;
1381 new_region
->length
= ~(bfd_size_type
) 0;
1382 new_region
->current
= 0;
1383 new_region
->last_os
= NULL
;
1384 new_region
->flags
= 0;
1385 new_region
->not_flags
= 0;
1386 new_region
->had_full_message
= FALSE
;
1388 *lang_memory_region_list_tail
= new_region
;
1389 lang_memory_region_list_tail
= &new_region
->next
;
1395 lang_memory_region_alias (const char *alias
, const char *region_name
)
1397 lang_memory_region_name
*n
;
1398 lang_memory_region_type
*r
;
1399 lang_memory_region_type
*region
;
1401 /* The default region must be unique. This ensures that it is not necessary
1402 to iterate through the name list if someone wants the check if a region is
1403 the default memory region. */
1404 if (strcmp (region_name
, DEFAULT_MEMORY_REGION
) == 0
1405 || strcmp (alias
, DEFAULT_MEMORY_REGION
) == 0)
1406 einfo (_("%F%P:%pS: error: alias for default memory region\n"), NULL
);
1408 /* Look for the target region and check if the alias is not already
1411 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1412 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1414 if (region
== NULL
&& strcmp (n
->name
, region_name
) == 0)
1416 if (strcmp (n
->name
, alias
) == 0)
1417 einfo (_("%F%P:%pS: error: redefinition of memory region "
1422 /* Check if the target region exists. */
1424 einfo (_("%F%P:%pS: error: memory region `%s' "
1425 "for alias `%s' does not exist\n"),
1426 NULL
, region_name
, alias
);
1428 /* Add alias to region name list. */
1429 n
= stat_alloc (sizeof (lang_memory_region_name
));
1430 n
->name
= xstrdup (alias
);
1431 n
->next
= region
->name_list
.next
;
1432 region
->name_list
.next
= n
;
1435 static lang_memory_region_type
*
1436 lang_memory_default (asection
*section
)
1438 lang_memory_region_type
*p
;
1440 flagword sec_flags
= section
->flags
;
1442 /* Override SEC_DATA to mean a writable section. */
1443 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
1444 sec_flags
|= SEC_DATA
;
1446 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
1448 if ((p
->flags
& sec_flags
) != 0
1449 && (p
->not_flags
& sec_flags
) == 0)
1454 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
1457 /* Get the output section statement directly from the userdata. */
1459 lang_output_section_statement_type
*
1460 lang_output_section_get (const asection
*output_section
)
1462 return bfd_section_userdata (output_section
);
1465 /* Find or create an output_section_statement with the given NAME.
1466 If CONSTRAINT is non-zero match one with that constraint, otherwise
1467 match any non-negative constraint. If CREATE, always make a
1468 new output_section_statement for SPECIAL CONSTRAINT. */
1470 lang_output_section_statement_type
*
1471 lang_output_section_statement_lookup (const char *name
,
1475 struct out_section_hash_entry
*entry
;
1477 entry
= ((struct out_section_hash_entry
*)
1478 bfd_hash_lookup (&output_section_statement_table
, name
,
1483 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1487 if (entry
->s
.output_section_statement
.name
!= NULL
)
1489 /* We have a section of this name, but it might not have the correct
1491 struct out_section_hash_entry
*last_ent
;
1493 name
= entry
->s
.output_section_statement
.name
;
1494 if (create
&& constraint
== SPECIAL
)
1495 /* Not traversing to the end reverses the order of the second
1496 and subsequent SPECIAL sections in the hash table chain,
1497 but that shouldn't matter. */
1502 if (constraint
== entry
->s
.output_section_statement
.constraint
1504 && entry
->s
.output_section_statement
.constraint
>= 0))
1505 return &entry
->s
.output_section_statement
;
1507 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1509 while (entry
!= NULL
1510 && name
== entry
->s
.output_section_statement
.name
);
1516 = ((struct out_section_hash_entry
*)
1517 output_section_statement_newfunc (NULL
,
1518 &output_section_statement_table
,
1522 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1525 entry
->root
= last_ent
->root
;
1526 last_ent
->root
.next
= &entry
->root
;
1529 entry
->s
.output_section_statement
.name
= name
;
1530 entry
->s
.output_section_statement
.constraint
= constraint
;
1531 return &entry
->s
.output_section_statement
;
1534 /* Find the next output_section_statement with the same name as OS.
1535 If CONSTRAINT is non-zero, find one with that constraint otherwise
1536 match any non-negative constraint. */
1538 lang_output_section_statement_type
*
1539 next_matching_output_section_statement (lang_output_section_statement_type
*os
,
1542 /* All output_section_statements are actually part of a
1543 struct out_section_hash_entry. */
1544 struct out_section_hash_entry
*entry
= (struct out_section_hash_entry
*)
1546 - offsetof (struct out_section_hash_entry
, s
.output_section_statement
));
1547 const char *name
= os
->name
;
1549 ASSERT (name
== entry
->root
.string
);
1552 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1554 || name
!= entry
->s
.output_section_statement
.name
)
1557 while (constraint
!= entry
->s
.output_section_statement
.constraint
1559 || entry
->s
.output_section_statement
.constraint
< 0));
1561 return &entry
->s
.output_section_statement
;
1564 /* A variant of lang_output_section_find used by place_orphan.
1565 Returns the output statement that should precede a new output
1566 statement for SEC. If an exact match is found on certain flags,
1569 lang_output_section_statement_type
*
1570 lang_output_section_find_by_flags (const asection
*sec
,
1572 lang_output_section_statement_type
**exact
,
1573 lang_match_sec_type_func match_type
)
1575 lang_output_section_statement_type
*first
, *look
, *found
;
1576 flagword look_flags
, differ
;
1578 /* We know the first statement on this list is *ABS*. May as well
1580 first
= (void *) lang_os_list
.head
;
1581 first
= first
->next
;
1583 /* First try for an exact match. */
1585 for (look
= first
; look
; look
= look
->next
)
1587 look_flags
= look
->flags
;
1588 if (look
->bfd_section
!= NULL
)
1590 look_flags
= look
->bfd_section
->flags
;
1591 if (match_type
&& !match_type (link_info
.output_bfd
,
1596 differ
= look_flags
^ sec_flags
;
1597 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1598 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1608 if ((sec_flags
& SEC_CODE
) != 0
1609 && (sec_flags
& SEC_ALLOC
) != 0)
1611 /* Try for a rw code section. */
1612 for (look
= first
; look
; look
= look
->next
)
1614 look_flags
= look
->flags
;
1615 if (look
->bfd_section
!= NULL
)
1617 look_flags
= look
->bfd_section
->flags
;
1618 if (match_type
&& !match_type (link_info
.output_bfd
,
1623 differ
= look_flags
^ sec_flags
;
1624 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1625 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1629 else if ((sec_flags
& SEC_READONLY
) != 0
1630 && (sec_flags
& SEC_ALLOC
) != 0)
1632 /* .rodata can go after .text, .sdata2 after .rodata. */
1633 for (look
= first
; look
; look
= look
->next
)
1635 look_flags
= look
->flags
;
1636 if (look
->bfd_section
!= NULL
)
1638 look_flags
= look
->bfd_section
->flags
;
1639 if (match_type
&& !match_type (link_info
.output_bfd
,
1644 differ
= look_flags
^ sec_flags
;
1645 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1646 | SEC_READONLY
| SEC_SMALL_DATA
))
1647 || (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1649 && !(look_flags
& SEC_SMALL_DATA
)))
1653 else if ((sec_flags
& SEC_THREAD_LOCAL
) != 0
1654 && (sec_flags
& SEC_ALLOC
) != 0)
1656 /* .tdata can go after .data, .tbss after .tdata. Treat .tbss
1657 as if it were a loaded section, and don't use match_type. */
1658 bfd_boolean seen_thread_local
= FALSE
;
1661 for (look
= first
; look
; look
= look
->next
)
1663 look_flags
= look
->flags
;
1664 if (look
->bfd_section
!= NULL
)
1665 look_flags
= look
->bfd_section
->flags
;
1667 differ
= look_flags
^ (sec_flags
| SEC_LOAD
| SEC_HAS_CONTENTS
);
1668 if (!(differ
& (SEC_THREAD_LOCAL
| SEC_ALLOC
)))
1670 /* .tdata and .tbss must be adjacent and in that order. */
1671 if (!(look_flags
& SEC_LOAD
)
1672 && (sec_flags
& SEC_LOAD
))
1673 /* ..so if we're at a .tbss section and we're placing
1674 a .tdata section stop looking and return the
1675 previous section. */
1678 seen_thread_local
= TRUE
;
1680 else if (seen_thread_local
)
1682 else if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
)))
1686 else if ((sec_flags
& SEC_SMALL_DATA
) != 0
1687 && (sec_flags
& SEC_ALLOC
) != 0)
1689 /* .sdata goes after .data, .sbss after .sdata. */
1690 for (look
= first
; look
; look
= look
->next
)
1692 look_flags
= look
->flags
;
1693 if (look
->bfd_section
!= NULL
)
1695 look_flags
= look
->bfd_section
->flags
;
1696 if (match_type
&& !match_type (link_info
.output_bfd
,
1701 differ
= look_flags
^ sec_flags
;
1702 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1703 | SEC_THREAD_LOCAL
))
1704 || ((look_flags
& SEC_SMALL_DATA
)
1705 && !(sec_flags
& SEC_HAS_CONTENTS
)))
1709 else if ((sec_flags
& SEC_HAS_CONTENTS
) != 0
1710 && (sec_flags
& SEC_ALLOC
) != 0)
1712 /* .data goes after .rodata. */
1713 for (look
= first
; look
; look
= look
->next
)
1715 look_flags
= look
->flags
;
1716 if (look
->bfd_section
!= NULL
)
1718 look_flags
= look
->bfd_section
->flags
;
1719 if (match_type
&& !match_type (link_info
.output_bfd
,
1724 differ
= look_flags
^ sec_flags
;
1725 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1726 | SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1730 else if ((sec_flags
& SEC_ALLOC
) != 0)
1732 /* .bss goes after any other alloc section. */
1733 for (look
= first
; look
; look
= look
->next
)
1735 look_flags
= look
->flags
;
1736 if (look
->bfd_section
!= NULL
)
1738 look_flags
= look
->bfd_section
->flags
;
1739 if (match_type
&& !match_type (link_info
.output_bfd
,
1744 differ
= look_flags
^ sec_flags
;
1745 if (!(differ
& SEC_ALLOC
))
1751 /* non-alloc go last. */
1752 for (look
= first
; look
; look
= look
->next
)
1754 look_flags
= look
->flags
;
1755 if (look
->bfd_section
!= NULL
)
1756 look_flags
= look
->bfd_section
->flags
;
1757 differ
= look_flags
^ sec_flags
;
1758 if (!(differ
& SEC_DEBUGGING
))
1764 if (found
|| !match_type
)
1767 return lang_output_section_find_by_flags (sec
, sec_flags
, NULL
, NULL
);
1770 /* Find the last output section before given output statement.
1771 Used by place_orphan. */
1774 output_prev_sec_find (lang_output_section_statement_type
*os
)
1776 lang_output_section_statement_type
*lookup
;
1778 for (lookup
= os
->prev
; lookup
!= NULL
; lookup
= lookup
->prev
)
1780 if (lookup
->constraint
< 0)
1783 if (lookup
->bfd_section
!= NULL
&& lookup
->bfd_section
->owner
!= NULL
)
1784 return lookup
->bfd_section
;
1790 /* Look for a suitable place for a new output section statement. The
1791 idea is to skip over anything that might be inside a SECTIONS {}
1792 statement in a script, before we find another output section
1793 statement. Assignments to "dot" before an output section statement
1794 are assumed to belong to it, except in two cases; The first
1795 assignment to dot, and assignments before non-alloc sections.
1796 Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
1797 similar assignments that set the initial address, or we might
1798 insert non-alloc note sections among assignments setting end of
1801 static lang_statement_union_type
**
1802 insert_os_after (lang_output_section_statement_type
*after
)
1804 lang_statement_union_type
**where
;
1805 lang_statement_union_type
**assign
= NULL
;
1806 bfd_boolean ignore_first
;
1808 ignore_first
= after
== (void *) lang_os_list
.head
;
1810 for (where
= &after
->header
.next
;
1812 where
= &(*where
)->header
.next
)
1814 switch ((*where
)->header
.type
)
1816 case lang_assignment_statement_enum
:
1819 lang_assignment_statement_type
*ass
;
1821 ass
= &(*where
)->assignment_statement
;
1822 if (ass
->exp
->type
.node_class
!= etree_assert
1823 && ass
->exp
->assign
.dst
[0] == '.'
1824 && ass
->exp
->assign
.dst
[1] == 0)
1828 ignore_first
= FALSE
;
1832 case lang_wild_statement_enum
:
1833 case lang_input_section_enum
:
1834 case lang_object_symbols_statement_enum
:
1835 case lang_fill_statement_enum
:
1836 case lang_data_statement_enum
:
1837 case lang_reloc_statement_enum
:
1838 case lang_padding_statement_enum
:
1839 case lang_constructors_statement_enum
:
1841 ignore_first
= FALSE
;
1843 case lang_output_section_statement_enum
:
1846 asection
*s
= (*where
)->output_section_statement
.bfd_section
;
1849 || s
->map_head
.s
== NULL
1850 || (s
->flags
& SEC_ALLOC
) != 0)
1854 case lang_input_statement_enum
:
1855 case lang_address_statement_enum
:
1856 case lang_target_statement_enum
:
1857 case lang_output_statement_enum
:
1858 case lang_group_statement_enum
:
1859 case lang_insert_statement_enum
:
1868 lang_output_section_statement_type
*
1869 lang_insert_orphan (asection
*s
,
1870 const char *secname
,
1872 lang_output_section_statement_type
*after
,
1873 struct orphan_save
*place
,
1874 etree_type
*address
,
1875 lang_statement_list_type
*add_child
)
1877 lang_statement_list_type add
;
1878 lang_output_section_statement_type
*os
;
1879 lang_output_section_statement_type
**os_tail
;
1881 /* If we have found an appropriate place for the output section
1882 statements for this orphan, add them to our own private list,
1883 inserting them later into the global statement list. */
1886 lang_list_init (&add
);
1887 push_stat_ptr (&add
);
1890 if (bfd_link_relocatable (&link_info
)
1891 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
1892 address
= exp_intop (0);
1894 os_tail
= (lang_output_section_statement_type
**) lang_os_list
.tail
;
1895 os
= lang_enter_output_section_statement (secname
, address
, normal_section
,
1896 NULL
, NULL
, NULL
, constraint
, 0);
1898 if (add_child
== NULL
)
1899 add_child
= &os
->children
;
1900 lang_add_section (add_child
, s
, NULL
, os
);
1902 if (after
&& (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) != 0)
1904 const char *region
= (after
->region
1905 ? after
->region
->name_list
.name
1906 : DEFAULT_MEMORY_REGION
);
1907 const char *lma_region
= (after
->lma_region
1908 ? after
->lma_region
->name_list
.name
1910 lang_leave_output_section_statement (NULL
, region
, after
->phdrs
,
1914 lang_leave_output_section_statement (NULL
, DEFAULT_MEMORY_REGION
, NULL
,
1917 /* Restore the global list pointer. */
1921 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
1923 asection
*snew
, *as
;
1924 bfd_boolean place_after
= place
->stmt
== NULL
;
1925 bfd_boolean insert_after
= TRUE
;
1927 snew
= os
->bfd_section
;
1929 /* Shuffle the bfd section list to make the output file look
1930 neater. This is really only cosmetic. */
1931 if (place
->section
== NULL
1932 && after
!= (void *) lang_os_list
.head
)
1934 asection
*bfd_section
= after
->bfd_section
;
1936 /* If the output statement hasn't been used to place any input
1937 sections (and thus doesn't have an output bfd_section),
1938 look for the closest prior output statement having an
1940 if (bfd_section
== NULL
)
1941 bfd_section
= output_prev_sec_find (after
);
1943 if (bfd_section
!= NULL
&& bfd_section
!= snew
)
1944 place
->section
= &bfd_section
->next
;
1947 if (place
->section
== NULL
)
1948 place
->section
= &link_info
.output_bfd
->sections
;
1950 as
= *place
->section
;
1954 /* Put the section at the end of the list. */
1956 /* Unlink the section. */
1957 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1959 /* Now tack it back on in the right place. */
1960 bfd_section_list_append (link_info
.output_bfd
, snew
);
1962 else if ((bfd_get_flavour (link_info
.output_bfd
)
1963 == bfd_target_elf_flavour
)
1964 && (bfd_get_flavour (s
->owner
)
1965 == bfd_target_elf_flavour
)
1966 && ((elf_section_type (s
) == SHT_NOTE
1967 && (s
->flags
& SEC_LOAD
) != 0)
1968 || (elf_section_type (as
) == SHT_NOTE
1969 && (as
->flags
& SEC_LOAD
) != 0)))
1971 /* Make sure that output note sections are grouped and sorted
1972 by alignments when inserting a note section or insert a
1973 section after a note section, */
1975 /* A specific section after which the output note section
1976 should be placed. */
1977 asection
*after_sec
;
1978 /* True if we need to insert the orphan section after a
1979 specific section to maintain output note section order. */
1980 bfd_boolean after_sec_note
= FALSE
;
1982 static asection
*first_orphan_note
= NULL
;
1984 /* Group and sort output note section by alignments in
1987 if (elf_section_type (s
) == SHT_NOTE
1988 && (s
->flags
& SEC_LOAD
) != 0)
1990 /* Search from the beginning for the last output note
1991 section with equal or larger alignments. NB: Don't
1992 place orphan note section after non-note sections. */
1994 first_orphan_note
= NULL
;
1995 for (sec
= link_info
.output_bfd
->sections
;
1997 && !bfd_is_abs_section (sec
));
2000 && elf_section_type (sec
) == SHT_NOTE
2001 && (sec
->flags
& SEC_LOAD
) != 0)
2003 if (!first_orphan_note
)
2004 first_orphan_note
= sec
;
2005 if (sec
->alignment_power
>= s
->alignment_power
)
2008 else if (first_orphan_note
)
2010 /* Stop if there is non-note section after the first
2011 orphan note section. */
2015 /* If this will be the first orphan note section, it can
2016 be placed at the default location. */
2017 after_sec_note
= first_orphan_note
!= NULL
;
2018 if (after_sec
== NULL
&& after_sec_note
)
2020 /* If all output note sections have smaller
2021 alignments, place the section before all
2022 output orphan note sections. */
2023 after_sec
= first_orphan_note
;
2024 insert_after
= FALSE
;
2027 else if (first_orphan_note
)
2029 /* Don't place non-note sections in the middle of orphan
2031 after_sec_note
= TRUE
;
2033 for (sec
= as
->next
;
2035 && !bfd_is_abs_section (sec
));
2037 if (elf_section_type (sec
) == SHT_NOTE
2038 && (sec
->flags
& SEC_LOAD
) != 0)
2046 /* Search forward to insert OS after AFTER_SEC output
2048 lang_output_section_statement_type
*stmt
, *next
;
2049 bfd_boolean found
= FALSE
;
2050 for (stmt
= after
; stmt
!= NULL
; stmt
= next
)
2055 if (stmt
->bfd_section
== after_sec
)
2065 /* If INSERT_AFTER is FALSE, place OS before
2066 AFTER_SEC output statement. */
2067 if (next
&& next
->bfd_section
== after_sec
)
2077 /* Search backward to insert OS after AFTER_SEC output
2080 for (stmt
= after
; stmt
!= NULL
; stmt
= stmt
->prev
)
2084 if (stmt
->bfd_section
== after_sec
)
2093 /* If INSERT_AFTER is FALSE, place OS before
2094 AFTER_SEC output statement. */
2095 if (stmt
->next
->bfd_section
== after_sec
)
2105 if (after_sec
== NULL
2106 || (insert_after
&& after_sec
->next
!= snew
)
2107 || (!insert_after
&& after_sec
->prev
!= snew
))
2109 /* Unlink the section. */
2110 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2112 /* Place SNEW after AFTER_SEC. If AFTER_SEC is NULL,
2117 bfd_section_list_insert_after (link_info
.output_bfd
,
2120 bfd_section_list_insert_before (link_info
.output_bfd
,
2124 bfd_section_list_prepend (link_info
.output_bfd
, snew
);
2127 else if (as
!= snew
&& as
->prev
!= snew
)
2129 /* Unlink the section. */
2130 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2132 /* Now tack it back on in the right place. */
2133 bfd_section_list_insert_before (link_info
.output_bfd
,
2137 else if (as
!= snew
&& as
->prev
!= snew
)
2139 /* Unlink the section. */
2140 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2142 /* Now tack it back on in the right place. */
2143 bfd_section_list_insert_before (link_info
.output_bfd
, as
, snew
);
2146 /* Save the end of this list. Further ophans of this type will
2147 follow the one we've just added. */
2148 place
->section
= &snew
->next
;
2150 /* The following is non-cosmetic. We try to put the output
2151 statements in some sort of reasonable order here, because they
2152 determine the final load addresses of the orphan sections.
2153 In addition, placing output statements in the wrong order may
2154 require extra segments. For instance, given a typical
2155 situation of all read-only sections placed in one segment and
2156 following that a segment containing all the read-write
2157 sections, we wouldn't want to place an orphan read/write
2158 section before or amongst the read-only ones. */
2159 if (add
.head
!= NULL
)
2161 lang_output_section_statement_type
*newly_added_os
;
2163 /* Place OS after AFTER if AFTER_NOTE is TRUE. */
2166 lang_statement_union_type
**where
= insert_os_after (after
);
2171 place
->os_tail
= &after
->next
;
2175 /* Put it after the last orphan statement we added. */
2176 *add
.tail
= *place
->stmt
;
2177 *place
->stmt
= add
.head
;
2180 /* Fix the global list pointer if we happened to tack our
2181 new list at the tail. */
2182 if (*stat_ptr
->tail
== add
.head
)
2183 stat_ptr
->tail
= add
.tail
;
2185 /* Save the end of this list. */
2186 place
->stmt
= add
.tail
;
2188 /* Do the same for the list of output section statements. */
2189 newly_added_os
= *os_tail
;
2191 newly_added_os
->prev
= (lang_output_section_statement_type
*)
2192 ((char *) place
->os_tail
2193 - offsetof (lang_output_section_statement_type
, next
));
2194 newly_added_os
->next
= *place
->os_tail
;
2195 if (newly_added_os
->next
!= NULL
)
2196 newly_added_os
->next
->prev
= newly_added_os
;
2197 *place
->os_tail
= newly_added_os
;
2198 place
->os_tail
= &newly_added_os
->next
;
2200 /* Fixing the global list pointer here is a little different.
2201 We added to the list in lang_enter_output_section_statement,
2202 trimmed off the new output_section_statment above when
2203 assigning *os_tail = NULL, but possibly added it back in
2204 the same place when assigning *place->os_tail. */
2205 if (*os_tail
== NULL
)
2206 lang_os_list
.tail
= (lang_statement_union_type
**) os_tail
;
2213 lang_print_asneeded (void)
2215 struct asneeded_minfo
*m
;
2217 if (asneeded_list_head
== NULL
)
2220 minfo (_("\nAs-needed library included to satisfy reference by file (symbol)\n\n"));
2222 for (m
= asneeded_list_head
; m
!= NULL
; m
= m
->next
)
2226 minfo ("%s", m
->soname
);
2227 len
= strlen (m
->soname
);
2241 minfo ("%pB ", m
->ref
);
2242 minfo ("(%pT)\n", m
->name
);
2247 lang_map_flags (flagword flag
)
2249 if (flag
& SEC_ALLOC
)
2252 if (flag
& SEC_CODE
)
2255 if (flag
& SEC_READONLY
)
2258 if (flag
& SEC_DATA
)
2261 if (flag
& SEC_LOAD
)
2268 lang_memory_region_type
*m
;
2269 bfd_boolean dis_header_printed
= FALSE
;
2271 LANG_FOR_EACH_INPUT_STATEMENT (file
)
2275 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
2276 || file
->flags
.just_syms
)
2279 if (config
.print_map_discarded
)
2280 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2281 if ((s
->output_section
== NULL
2282 || s
->output_section
->owner
!= link_info
.output_bfd
)
2283 && (s
->flags
& (SEC_LINKER_CREATED
| SEC_KEEP
)) == 0)
2285 if (! dis_header_printed
)
2287 fprintf (config
.map_file
, _("\nDiscarded input sections\n\n"));
2288 dis_header_printed
= TRUE
;
2291 print_input_section (s
, TRUE
);
2295 minfo (_("\nMemory Configuration\n\n"));
2296 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
2297 _("Name"), _("Origin"), _("Length"), _("Attributes"));
2299 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
2304 fprintf (config
.map_file
, "%-16s ", m
->name_list
.name
);
2306 sprintf_vma (buf
, m
->origin
);
2307 minfo ("0x%s ", buf
);
2315 minfo ("0x%V", m
->length
);
2316 if (m
->flags
|| m
->not_flags
)
2324 lang_map_flags (m
->flags
);
2330 lang_map_flags (m
->not_flags
);
2337 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
2339 if (!link_info
.reduce_memory_overheads
)
2341 obstack_begin (&map_obstack
, 1000);
2342 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
2344 expld
.phase
= lang_fixed_phase_enum
;
2345 lang_statement_iteration
++;
2346 print_statements ();
2348 ldemul_extra_map_file_text (link_info
.output_bfd
, &link_info
,
2353 sort_def_symbol (struct bfd_link_hash_entry
*hash_entry
,
2354 void *info ATTRIBUTE_UNUSED
)
2356 if ((hash_entry
->type
== bfd_link_hash_defined
2357 || hash_entry
->type
== bfd_link_hash_defweak
)
2358 && hash_entry
->u
.def
.section
->owner
!= link_info
.output_bfd
2359 && hash_entry
->u
.def
.section
->owner
!= NULL
)
2361 input_section_userdata_type
*ud
;
2362 struct map_symbol_def
*def
;
2364 ud
= bfd_section_userdata (hash_entry
->u
.def
.section
);
2367 ud
= stat_alloc (sizeof (*ud
));
2368 bfd_set_section_userdata (hash_entry
->u
.def
.section
, ud
);
2369 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2370 ud
->map_symbol_def_count
= 0;
2372 else if (!ud
->map_symbol_def_tail
)
2373 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2375 def
= (struct map_symbol_def
*) obstack_alloc (&map_obstack
, sizeof *def
);
2376 def
->entry
= hash_entry
;
2377 *(ud
->map_symbol_def_tail
) = def
;
2378 ud
->map_symbol_def_tail
= &def
->next
;
2379 ud
->map_symbol_def_count
++;
2384 /* Initialize an output section. */
2387 init_os (lang_output_section_statement_type
*s
, flagword flags
)
2389 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
2390 einfo (_("%F%P: illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
2392 if (s
->constraint
!= SPECIAL
)
2393 s
->bfd_section
= bfd_get_section_by_name (link_info
.output_bfd
, s
->name
);
2394 if (s
->bfd_section
== NULL
)
2395 s
->bfd_section
= bfd_make_section_anyway_with_flags (link_info
.output_bfd
,
2397 if (s
->bfd_section
== NULL
)
2399 einfo (_("%F%P: output format %s cannot represent section"
2400 " called %s: %E\n"),
2401 link_info
.output_bfd
->xvec
->name
, s
->name
);
2403 s
->bfd_section
->output_section
= s
->bfd_section
;
2404 s
->bfd_section
->output_offset
= 0;
2406 /* Set the userdata of the output section to the output section
2407 statement to avoid lookup. */
2408 bfd_set_section_userdata (s
->bfd_section
, s
);
2410 /* If there is a base address, make sure that any sections it might
2411 mention are initialized. */
2412 if (s
->addr_tree
!= NULL
)
2413 exp_init_os (s
->addr_tree
);
2415 if (s
->load_base
!= NULL
)
2416 exp_init_os (s
->load_base
);
2418 /* If supplied an alignment, set it. */
2419 if (s
->section_alignment
!= NULL
)
2420 s
->bfd_section
->alignment_power
= exp_get_power (s
->section_alignment
,
2421 "section alignment");
2424 /* Make sure that all output sections mentioned in an expression are
2428 exp_init_os (etree_type
*exp
)
2430 switch (exp
->type
.node_class
)
2434 case etree_provided
:
2435 exp_init_os (exp
->assign
.src
);
2439 exp_init_os (exp
->binary
.lhs
);
2440 exp_init_os (exp
->binary
.rhs
);
2444 exp_init_os (exp
->trinary
.cond
);
2445 exp_init_os (exp
->trinary
.lhs
);
2446 exp_init_os (exp
->trinary
.rhs
);
2450 exp_init_os (exp
->assert_s
.child
);
2454 exp_init_os (exp
->unary
.child
);
2458 switch (exp
->type
.node_code
)
2464 lang_output_section_statement_type
*os
;
2466 os
= lang_output_section_find (exp
->name
.name
);
2467 if (os
!= NULL
&& os
->bfd_section
== NULL
)
2479 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
2481 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
2483 /* If we are only reading symbols from this object, then we want to
2484 discard all sections. */
2485 if (entry
->flags
.just_syms
)
2487 bfd_link_just_syms (abfd
, sec
, &link_info
);
2491 /* Deal with SHF_EXCLUDE ELF sections. */
2492 if (!bfd_link_relocatable (&link_info
)
2493 && (abfd
->flags
& BFD_PLUGIN
) == 0
2494 && (sec
->flags
& (SEC_GROUP
| SEC_KEEP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
2495 sec
->output_section
= bfd_abs_section_ptr
;
2497 if (!(abfd
->flags
& DYNAMIC
))
2498 bfd_section_already_linked (abfd
, sec
, &link_info
);
2502 /* Returns true if SECTION is one we know will be discarded based on its
2503 section flags, otherwise returns false. */
2506 lang_discard_section_p (asection
*section
)
2508 bfd_boolean discard
;
2509 flagword flags
= section
->flags
;
2511 /* Discard sections marked with SEC_EXCLUDE. */
2512 discard
= (flags
& SEC_EXCLUDE
) != 0;
2514 /* Discard the group descriptor sections when we're finally placing the
2515 sections from within the group. */
2516 if ((flags
& SEC_GROUP
) != 0
2517 && link_info
.resolve_section_groups
)
2520 /* Discard debugging sections if we are stripping debugging
2522 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
2523 && (flags
& SEC_DEBUGGING
) != 0)
2529 /* The wild routines.
2531 These expand statements like *(.text) and foo.o to a list of
2532 explicit actions, like foo.o(.text), bar.o(.text) and
2533 foo.o(.text, .data). */
2535 /* Add SECTION to the output section OUTPUT. Do this by creating a
2536 lang_input_section statement which is placed at PTR. */
2539 lang_add_section (lang_statement_list_type
*ptr
,
2541 struct flag_info
*sflag_info
,
2542 lang_output_section_statement_type
*output
)
2544 flagword flags
= section
->flags
;
2546 bfd_boolean discard
;
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 noload_section
:
2644 flags
|= SEC_NEVER_LOAD
;
2645 /* Unfortunately GNU ld has managed to evolve two different
2646 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2647 alloc, no contents section. All others get a noload, noalloc
2649 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
2650 flags
&= ~SEC_HAS_CONTENTS
;
2652 flags
&= ~SEC_ALLOC
;
2656 if (output
->bfd_section
== NULL
)
2657 init_os (output
, flags
);
2659 /* If SEC_READONLY is not set in the input section, then clear
2660 it from the output section. */
2661 output
->bfd_section
->flags
&= flags
| ~SEC_READONLY
;
2663 if (output
->bfd_section
->linker_has_input
)
2665 /* Only set SEC_READONLY flag on the first input section. */
2666 flags
&= ~ SEC_READONLY
;
2668 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2669 if ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2670 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2671 || ((flags
& SEC_MERGE
) != 0
2672 && output
->bfd_section
->entsize
!= section
->entsize
))
2674 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2675 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2678 output
->bfd_section
->flags
|= flags
;
2680 if (!output
->bfd_section
->linker_has_input
)
2682 output
->bfd_section
->linker_has_input
= 1;
2683 /* This must happen after flags have been updated. The output
2684 section may have been created before we saw its first input
2685 section, eg. for a data statement. */
2686 bfd_init_private_section_data (section
->owner
, section
,
2687 link_info
.output_bfd
,
2688 output
->bfd_section
,
2690 if ((flags
& SEC_MERGE
) != 0)
2691 output
->bfd_section
->entsize
= section
->entsize
;
2694 if ((flags
& SEC_TIC54X_BLOCK
) != 0
2695 && bfd_get_arch (section
->owner
) == bfd_arch_tic54x
)
2697 /* FIXME: This value should really be obtained from the bfd... */
2698 output
->block_value
= 128;
2701 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2702 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2704 section
->output_section
= output
->bfd_section
;
2706 if (!map_head_is_link_order
)
2708 asection
*s
= output
->bfd_section
->map_tail
.s
;
2709 output
->bfd_section
->map_tail
.s
= section
;
2710 section
->map_head
.s
= NULL
;
2711 section
->map_tail
.s
= s
;
2713 s
->map_head
.s
= section
;
2715 output
->bfd_section
->map_head
.s
= section
;
2718 /* Add a section reference to the list. */
2719 new_section
= new_stat (lang_input_section
, ptr
);
2720 new_section
->section
= section
;
2723 /* Handle wildcard sorting. This returns the lang_input_section which
2724 should follow the one we are going to create for SECTION and FILE,
2725 based on the sorting requirements of WILD. It returns NULL if the
2726 new section should just go at the end of the current list. */
2728 static lang_statement_union_type
*
2729 wild_sort (lang_wild_statement_type
*wild
,
2730 struct wildcard_list
*sec
,
2731 lang_input_statement_type
*file
,
2734 lang_statement_union_type
*l
;
2736 if (!wild
->filenames_sorted
2737 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
2740 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
2742 lang_input_section_type
*ls
;
2744 if (l
->header
.type
!= lang_input_section_enum
)
2746 ls
= &l
->input_section
;
2748 /* Sorting by filename takes precedence over sorting by section
2751 if (wild
->filenames_sorted
)
2753 const char *fn
, *ln
;
2757 /* The PE support for the .idata section as generated by
2758 dlltool assumes that files will be sorted by the name of
2759 the archive and then the name of the file within the
2762 if (file
->the_bfd
!= NULL
2763 && file
->the_bfd
->my_archive
!= NULL
)
2765 fn
= bfd_get_filename (file
->the_bfd
->my_archive
);
2770 fn
= file
->filename
;
2774 if (ls
->section
->owner
->my_archive
!= NULL
)
2776 ln
= bfd_get_filename (ls
->section
->owner
->my_archive
);
2781 ln
= bfd_get_filename (ls
->section
->owner
);
2785 i
= filename_cmp (fn
, ln
);
2794 fn
= file
->filename
;
2796 ln
= bfd_get_filename (ls
->section
->owner
);
2798 i
= filename_cmp (fn
, ln
);
2806 /* Here either the files are not sorted by name, or we are
2807 looking at the sections for this file. */
2810 && sec
->spec
.sorted
!= none
2811 && sec
->spec
.sorted
!= by_none
)
2812 if (compare_section (sec
->spec
.sorted
, section
, ls
->section
) < 0)
2819 /* Expand a wild statement for a particular FILE. SECTION may be
2820 NULL, in which case it is a wild card. */
2823 output_section_callback (lang_wild_statement_type
*ptr
,
2824 struct wildcard_list
*sec
,
2826 struct flag_info
*sflag_info
,
2827 lang_input_statement_type
*file
,
2830 lang_statement_union_type
*before
;
2831 lang_output_section_statement_type
*os
;
2833 os
= (lang_output_section_statement_type
*) output
;
2835 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2836 if (unique_section_p (section
, os
))
2839 before
= wild_sort (ptr
, sec
, file
, section
);
2841 /* Here BEFORE points to the lang_input_section which
2842 should follow the one we are about to add. If BEFORE
2843 is NULL, then the section should just go at the end
2844 of the current list. */
2847 lang_add_section (&ptr
->children
, section
, sflag_info
, os
);
2850 lang_statement_list_type list
;
2851 lang_statement_union_type
**pp
;
2853 lang_list_init (&list
);
2854 lang_add_section (&list
, section
, sflag_info
, os
);
2856 /* If we are discarding the section, LIST.HEAD will
2858 if (list
.head
!= NULL
)
2860 ASSERT (list
.head
->header
.next
== NULL
);
2862 for (pp
= &ptr
->children
.head
;
2864 pp
= &(*pp
)->header
.next
)
2865 ASSERT (*pp
!= NULL
);
2867 list
.head
->header
.next
= *pp
;
2873 /* Check if all sections in a wild statement for a particular FILE
2877 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2878 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2880 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
2881 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2884 lang_output_section_statement_type
*os
;
2886 os
= (lang_output_section_statement_type
*) output
;
2888 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2889 if (unique_section_p (section
, os
))
2892 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2893 os
->all_input_readonly
= FALSE
;
2896 /* This is passed a file name which must have been seen already and
2897 added to the statement tree. We will see if it has been opened
2898 already and had its symbols read. If not then we'll read it. */
2900 static lang_input_statement_type
*
2901 lookup_name (const char *name
)
2903 lang_input_statement_type
*search
;
2905 for (search
= (void *) input_file_chain
.head
;
2907 search
= search
->next_real_file
)
2909 /* Use the local_sym_name as the name of the file that has
2910 already been loaded as filename might have been transformed
2911 via the search directory lookup mechanism. */
2912 const char *filename
= search
->local_sym_name
;
2914 if (filename
!= NULL
2915 && filename_cmp (filename
, name
) == 0)
2921 /* Arrange to splice the input statement added by new_afile into
2922 statement_list after the current input_file_chain tail.
2923 We know input_file_chain is not an empty list, and that
2924 lookup_name was called via open_input_bfds. Later calls to
2925 lookup_name should always match an existing input_statement. */
2926 lang_statement_union_type
**tail
= stat_ptr
->tail
;
2927 lang_statement_union_type
**after
2928 = (void *) ((char *) input_file_chain
.tail
2929 - offsetof (lang_input_statement_type
, next_real_file
)
2930 + offsetof (lang_input_statement_type
, header
.next
));
2931 lang_statement_union_type
*rest
= *after
;
2932 stat_ptr
->tail
= after
;
2933 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2934 default_target
, NULL
);
2935 *stat_ptr
->tail
= rest
;
2937 stat_ptr
->tail
= tail
;
2940 /* If we have already added this file, or this file is not real
2941 don't add this file. */
2942 if (search
->flags
.loaded
|| !search
->flags
.real
)
2945 if (!load_symbols (search
, NULL
))
2951 /* Save LIST as a list of libraries whose symbols should not be exported. */
2956 struct excluded_lib
*next
;
2958 static struct excluded_lib
*excluded_libs
;
2961 add_excluded_libs (const char *list
)
2963 const char *p
= list
, *end
;
2967 struct excluded_lib
*entry
;
2968 end
= strpbrk (p
, ",:");
2970 end
= p
+ strlen (p
);
2971 entry
= (struct excluded_lib
*) xmalloc (sizeof (*entry
));
2972 entry
->next
= excluded_libs
;
2973 entry
->name
= (char *) xmalloc (end
- p
+ 1);
2974 memcpy (entry
->name
, p
, end
- p
);
2975 entry
->name
[end
- p
] = '\0';
2976 excluded_libs
= entry
;
2984 check_excluded_libs (bfd
*abfd
)
2986 struct excluded_lib
*lib
= excluded_libs
;
2990 int len
= strlen (lib
->name
);
2991 const char *filename
= lbasename (bfd_get_filename (abfd
));
2993 if (strcmp (lib
->name
, "ALL") == 0)
2995 abfd
->no_export
= TRUE
;
2999 if (filename_ncmp (lib
->name
, filename
, len
) == 0
3000 && (filename
[len
] == '\0'
3001 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
3002 && filename
[len
+ 2] == '\0')))
3004 abfd
->no_export
= TRUE
;
3012 /* Get the symbols for an input file. */
3015 load_symbols (lang_input_statement_type
*entry
,
3016 lang_statement_list_type
*place
)
3020 if (entry
->flags
.loaded
)
3023 ldfile_open_file (entry
);
3025 /* Do not process further if the file was missing. */
3026 if (entry
->flags
.missing_file
)
3029 if (trace_files
|| verbose
)
3030 info_msg ("%pI\n", entry
);
3032 if (!bfd_check_format (entry
->the_bfd
, bfd_archive
)
3033 && !bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
3036 struct lang_input_statement_flags save_flags
;
3039 err
= bfd_get_error ();
3041 /* See if the emulation has some special knowledge. */
3042 if (ldemul_unrecognized_file (entry
))
3045 if (err
== bfd_error_file_ambiguously_recognized
)
3049 einfo (_("%P: %pB: file not recognized: %E;"
3050 " matching formats:"), entry
->the_bfd
);
3051 for (p
= matching
; *p
!= NULL
; p
++)
3055 else if (err
!= bfd_error_file_not_recognized
3057 einfo (_("%F%P: %pB: file not recognized: %E\n"), entry
->the_bfd
);
3059 bfd_close (entry
->the_bfd
);
3060 entry
->the_bfd
= NULL
;
3062 /* Try to interpret the file as a linker script. */
3063 save_flags
= input_flags
;
3064 ldfile_open_command_file (entry
->filename
);
3066 push_stat_ptr (place
);
3067 input_flags
.add_DT_NEEDED_for_regular
3068 = entry
->flags
.add_DT_NEEDED_for_regular
;
3069 input_flags
.add_DT_NEEDED_for_dynamic
3070 = entry
->flags
.add_DT_NEEDED_for_dynamic
;
3071 input_flags
.whole_archive
= entry
->flags
.whole_archive
;
3072 input_flags
.dynamic
= entry
->flags
.dynamic
;
3074 ldfile_assumed_script
= TRUE
;
3075 parser_input
= input_script
;
3076 current_input_file
= entry
->filename
;
3078 current_input_file
= NULL
;
3079 ldfile_assumed_script
= FALSE
;
3081 /* missing_file is sticky. sysrooted will already have been
3082 restored when seeing EOF in yyparse, but no harm to restore
3084 save_flags
.missing_file
|= input_flags
.missing_file
;
3085 input_flags
= save_flags
;
3089 entry
->flags
.loaded
= TRUE
;
3094 if (ldemul_recognized_file (entry
))
3097 /* We don't call ldlang_add_file for an archive. Instead, the
3098 add_symbols entry point will call ldlang_add_file, via the
3099 add_archive_element callback, for each element of the archive
3101 switch (bfd_get_format (entry
->the_bfd
))
3107 if (!entry
->flags
.reload
)
3108 ldlang_add_file (entry
);
3112 check_excluded_libs (entry
->the_bfd
);
3114 bfd_set_usrdata (entry
->the_bfd
, entry
);
3115 if (entry
->flags
.whole_archive
)
3118 bfd_boolean loaded
= TRUE
;
3123 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
3128 if (!bfd_check_format (member
, bfd_object
))
3130 einfo (_("%F%P: %pB: member %pB in archive is not an object\n"),
3131 entry
->the_bfd
, member
);
3136 if (!(*link_info
.callbacks
3137 ->add_archive_element
) (&link_info
, member
,
3138 "--whole-archive", &subsbfd
))
3141 /* Potentially, the add_archive_element hook may have set a
3142 substitute BFD for us. */
3143 if (!bfd_link_add_symbols (subsbfd
, &link_info
))
3145 einfo (_("%F%P: %pB: error adding symbols: %E\n"), member
);
3150 entry
->flags
.loaded
= loaded
;
3156 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
3157 entry
->flags
.loaded
= TRUE
;
3159 einfo (_("%F%P: %pB: error adding symbols: %E\n"), entry
->the_bfd
);
3161 return entry
->flags
.loaded
;
3164 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
3165 may be NULL, indicating that it is a wildcard. Separate
3166 lang_input_section statements are created for each part of the
3167 expansion; they are added after the wild statement S. OUTPUT is
3168 the output section. */
3171 wild (lang_wild_statement_type
*s
,
3172 const char *target ATTRIBUTE_UNUSED
,
3173 lang_output_section_statement_type
*output
)
3175 struct wildcard_list
*sec
;
3177 if (s
->handler_data
[0]
3178 && s
->handler_data
[0]->spec
.sorted
== by_name
3179 && !s
->filenames_sorted
)
3181 lang_section_bst_type
*tree
;
3183 walk_wild (s
, output_section_callback_fast
, output
);
3188 output_section_callback_tree_to_list (s
, tree
, output
);
3193 walk_wild (s
, output_section_callback
, output
);
3195 if (default_common_section
== NULL
)
3196 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
3197 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
3199 /* Remember the section that common is going to in case we
3200 later get something which doesn't know where to put it. */
3201 default_common_section
= output
;
3206 /* Return TRUE iff target is the sought target. */
3209 get_target (const bfd_target
*target
, void *data
)
3211 const char *sought
= (const char *) data
;
3213 return strcmp (target
->name
, sought
) == 0;
3216 /* Like strcpy() but convert to lower case as well. */
3219 stricpy (char *dest
, const char *src
)
3223 while ((c
= *src
++) != 0)
3224 *dest
++ = TOLOWER (c
);
3229 /* Remove the first occurrence of needle (if any) in haystack
3233 strcut (char *haystack
, const char *needle
)
3235 haystack
= strstr (haystack
, needle
);
3241 for (src
= haystack
+ strlen (needle
); *src
;)
3242 *haystack
++ = *src
++;
3248 /* Compare two target format name strings.
3249 Return a value indicating how "similar" they are. */
3252 name_compare (const char *first
, const char *second
)
3258 copy1
= (char *) xmalloc (strlen (first
) + 1);
3259 copy2
= (char *) xmalloc (strlen (second
) + 1);
3261 /* Convert the names to lower case. */
3262 stricpy (copy1
, first
);
3263 stricpy (copy2
, second
);
3265 /* Remove size and endian strings from the name. */
3266 strcut (copy1
, "big");
3267 strcut (copy1
, "little");
3268 strcut (copy2
, "big");
3269 strcut (copy2
, "little");
3271 /* Return a value based on how many characters match,
3272 starting from the beginning. If both strings are
3273 the same then return 10 * their length. */
3274 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
3275 if (copy1
[result
] == 0)
3287 /* Set by closest_target_match() below. */
3288 static const bfd_target
*winner
;
3290 /* Scan all the valid bfd targets looking for one that has the endianness
3291 requirement that was specified on the command line, and is the nearest
3292 match to the original output target. */
3295 closest_target_match (const bfd_target
*target
, void *data
)
3297 const bfd_target
*original
= (const bfd_target
*) data
;
3299 if (command_line
.endian
== ENDIAN_BIG
3300 && target
->byteorder
!= BFD_ENDIAN_BIG
)
3303 if (command_line
.endian
== ENDIAN_LITTLE
3304 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
3307 /* Must be the same flavour. */
3308 if (target
->flavour
!= original
->flavour
)
3311 /* Ignore generic big and little endian elf vectors. */
3312 if (strcmp (target
->name
, "elf32-big") == 0
3313 || strcmp (target
->name
, "elf64-big") == 0
3314 || strcmp (target
->name
, "elf32-little") == 0
3315 || strcmp (target
->name
, "elf64-little") == 0)
3318 /* If we have not found a potential winner yet, then record this one. */
3325 /* Oh dear, we now have two potential candidates for a successful match.
3326 Compare their names and choose the better one. */
3327 if (name_compare (target
->name
, original
->name
)
3328 > name_compare (winner
->name
, original
->name
))
3331 /* Keep on searching until wqe have checked them all. */
3335 /* Return the BFD target format of the first input file. */
3338 get_first_input_target (void)
3340 const char *target
= NULL
;
3342 LANG_FOR_EACH_INPUT_STATEMENT (s
)
3344 if (s
->header
.type
== lang_input_statement_enum
3347 ldfile_open_file (s
);
3349 if (s
->the_bfd
!= NULL
3350 && bfd_check_format (s
->the_bfd
, bfd_object
))
3352 target
= bfd_get_target (s
->the_bfd
);
3364 lang_get_output_target (void)
3368 /* Has the user told us which output format to use? */
3369 if (output_target
!= NULL
)
3370 return output_target
;
3372 /* No - has the current target been set to something other than
3374 if (current_target
!= default_target
&& current_target
!= NULL
)
3375 return current_target
;
3377 /* No - can we determine the format of the first input file? */
3378 target
= get_first_input_target ();
3382 /* Failed - use the default output target. */
3383 return default_target
;
3386 /* Open the output file. */
3389 open_output (const char *name
)
3391 output_target
= lang_get_output_target ();
3393 /* Has the user requested a particular endianness on the command
3395 if (command_line
.endian
!= ENDIAN_UNSET
)
3397 /* Get the chosen target. */
3398 const bfd_target
*target
3399 = bfd_iterate_over_targets (get_target
, (void *) output_target
);
3401 /* If the target is not supported, we cannot do anything. */
3404 enum bfd_endian desired_endian
;
3406 if (command_line
.endian
== ENDIAN_BIG
)
3407 desired_endian
= BFD_ENDIAN_BIG
;
3409 desired_endian
= BFD_ENDIAN_LITTLE
;
3411 /* See if the target has the wrong endianness. This should
3412 not happen if the linker script has provided big and
3413 little endian alternatives, but some scrips don't do
3415 if (target
->byteorder
!= desired_endian
)
3417 /* If it does, then see if the target provides
3418 an alternative with the correct endianness. */
3419 if (target
->alternative_target
!= NULL
3420 && (target
->alternative_target
->byteorder
== desired_endian
))
3421 output_target
= target
->alternative_target
->name
;
3424 /* Try to find a target as similar as possible to
3425 the default target, but which has the desired
3426 endian characteristic. */
3427 bfd_iterate_over_targets (closest_target_match
,
3430 /* Oh dear - we could not find any targets that
3431 satisfy our requirements. */
3433 einfo (_("%P: warning: could not find any targets"
3434 " that match endianness requirement\n"));
3436 output_target
= winner
->name
;
3442 link_info
.output_bfd
= bfd_openw (name
, output_target
);
3444 if (link_info
.output_bfd
== NULL
)
3446 if (bfd_get_error () == bfd_error_invalid_target
)
3447 einfo (_("%F%P: target %s not found\n"), output_target
);
3449 einfo (_("%F%P: cannot open output file %s: %E\n"), name
);
3452 delete_output_file_on_failure
= TRUE
;
3454 if (!bfd_set_format (link_info
.output_bfd
, bfd_object
))
3455 einfo (_("%F%P: %s: can not make object file: %E\n"), name
);
3456 if (!bfd_set_arch_mach (link_info
.output_bfd
,
3457 ldfile_output_architecture
,
3458 ldfile_output_machine
))
3459 einfo (_("%F%P: %s: can not set architecture: %E\n"), name
);
3461 link_info
.hash
= bfd_link_hash_table_create (link_info
.output_bfd
);
3462 if (link_info
.hash
== NULL
)
3463 einfo (_("%F%P: can not create hash table: %E\n"));
3465 bfd_set_gp_size (link_info
.output_bfd
, g_switch_value
);
3469 ldlang_open_output (lang_statement_union_type
*statement
)
3471 switch (statement
->header
.type
)
3473 case lang_output_statement_enum
:
3474 ASSERT (link_info
.output_bfd
== NULL
);
3475 open_output (statement
->output_statement
.name
);
3476 ldemul_set_output_arch ();
3477 if (config
.magic_demand_paged
3478 && !bfd_link_relocatable (&link_info
))
3479 link_info
.output_bfd
->flags
|= D_PAGED
;
3481 link_info
.output_bfd
->flags
&= ~D_PAGED
;
3482 if (config
.text_read_only
)
3483 link_info
.output_bfd
->flags
|= WP_TEXT
;
3485 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
3486 if (link_info
.traditional_format
)
3487 link_info
.output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
3489 link_info
.output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
3492 case lang_target_statement_enum
:
3493 current_target
= statement
->target_statement
.target
;
3501 init_opb (asection
*s
)
3506 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
3508 && (s
->flags
& SEC_ELF_OCTETS
) != 0)
3511 x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3512 ldfile_output_machine
);
3514 while ((x
& 1) == 0)
3522 /* Open all the input files. */
3526 OPEN_BFD_NORMAL
= 0,
3530 #if BFD_SUPPORTS_PLUGINS
3531 static lang_input_statement_type
*plugin_insert
= NULL
;
3532 static struct bfd_link_hash_entry
*plugin_undefs
= NULL
;
3536 open_input_bfds (lang_statement_union_type
*s
, enum open_bfd_mode mode
)
3538 for (; s
!= NULL
; s
= s
->header
.next
)
3540 switch (s
->header
.type
)
3542 case lang_constructors_statement_enum
:
3543 open_input_bfds (constructor_list
.head
, mode
);
3545 case lang_output_section_statement_enum
:
3546 open_input_bfds (s
->output_section_statement
.children
.head
, mode
);
3548 case lang_wild_statement_enum
:
3549 /* Maybe we should load the file's symbols. */
3550 if ((mode
& OPEN_BFD_RESCAN
) == 0
3551 && s
->wild_statement
.filename
3552 && !wildcardp (s
->wild_statement
.filename
)
3553 && !archive_path (s
->wild_statement
.filename
))
3554 lookup_name (s
->wild_statement
.filename
);
3555 open_input_bfds (s
->wild_statement
.children
.head
, mode
);
3557 case lang_group_statement_enum
:
3559 struct bfd_link_hash_entry
*undefs
;
3560 #if BFD_SUPPORTS_PLUGINS
3561 lang_input_statement_type
*plugin_insert_save
;
3564 /* We must continually search the entries in the group
3565 until no new symbols are added to the list of undefined
3570 #if BFD_SUPPORTS_PLUGINS
3571 plugin_insert_save
= plugin_insert
;
3573 undefs
= link_info
.hash
->undefs_tail
;
3574 open_input_bfds (s
->group_statement
.children
.head
,
3575 mode
| OPEN_BFD_FORCE
);
3577 while (undefs
!= link_info
.hash
->undefs_tail
3578 #if BFD_SUPPORTS_PLUGINS
3579 /* Objects inserted by a plugin, which are loaded
3580 before we hit this loop, may have added new
3582 || (plugin_insert
!= plugin_insert_save
&& plugin_undefs
)
3587 case lang_target_statement_enum
:
3588 current_target
= s
->target_statement
.target
;
3590 case lang_input_statement_enum
:
3591 if (s
->input_statement
.flags
.real
)
3593 lang_statement_union_type
**os_tail
;
3594 lang_statement_list_type add
;
3597 s
->input_statement
.target
= current_target
;
3599 /* If we are being called from within a group, and this
3600 is an archive which has already been searched, then
3601 force it to be researched unless the whole archive
3602 has been loaded already. Do the same for a rescan.
3603 Likewise reload --as-needed shared libs. */
3604 if (mode
!= OPEN_BFD_NORMAL
3605 #if BFD_SUPPORTS_PLUGINS
3606 && ((mode
& OPEN_BFD_RESCAN
) == 0
3607 || plugin_insert
== NULL
)
3609 && s
->input_statement
.flags
.loaded
3610 && (abfd
= s
->input_statement
.the_bfd
) != NULL
3611 && ((bfd_get_format (abfd
) == bfd_archive
3612 && !s
->input_statement
.flags
.whole_archive
)
3613 || (bfd_get_format (abfd
) == bfd_object
3614 && ((abfd
->flags
) & DYNAMIC
) != 0
3615 && s
->input_statement
.flags
.add_DT_NEEDED_for_regular
3616 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3617 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)))
3619 s
->input_statement
.flags
.loaded
= FALSE
;
3620 s
->input_statement
.flags
.reload
= TRUE
;
3623 os_tail
= lang_os_list
.tail
;
3624 lang_list_init (&add
);
3626 if (!load_symbols (&s
->input_statement
, &add
))
3627 config
.make_executable
= FALSE
;
3629 if (add
.head
!= NULL
)
3631 /* If this was a script with output sections then
3632 tack any added statements on to the end of the
3633 list. This avoids having to reorder the output
3634 section statement list. Very likely the user
3635 forgot -T, and whatever we do here will not meet
3636 naive user expectations. */
3637 if (os_tail
!= lang_os_list
.tail
)
3639 einfo (_("%P: warning: %s contains output sections;"
3640 " did you forget -T?\n"),
3641 s
->input_statement
.filename
);
3642 *stat_ptr
->tail
= add
.head
;
3643 stat_ptr
->tail
= add
.tail
;
3647 *add
.tail
= s
->header
.next
;
3648 s
->header
.next
= add
.head
;
3652 #if BFD_SUPPORTS_PLUGINS
3653 /* If we have found the point at which a plugin added new
3654 files, clear plugin_insert to enable archive rescan. */
3655 if (&s
->input_statement
== plugin_insert
)
3656 plugin_insert
= NULL
;
3659 case lang_assignment_statement_enum
:
3660 if (s
->assignment_statement
.exp
->type
.node_class
!= etree_assert
)
3661 exp_fold_tree_no_dot (s
->assignment_statement
.exp
);
3668 /* Exit if any of the files were missing. */
3669 if (input_flags
.missing_file
)
3673 #ifdef ENABLE_LIBCTF
3674 /* Emit CTF errors and warnings. fp can be NULL to report errors/warnings
3675 that happened specifically at CTF open time. */
3677 lang_ctf_errs_warnings (ctf_dict_t
*fp
)
3679 ctf_next_t
*i
= NULL
;
3684 while ((text
= ctf_errwarning_next (fp
, &i
, &is_warning
, &err
)) != NULL
)
3686 einfo (_("%s: %s\n"), is_warning
? _("CTF warning"): _("CTF error"),
3690 if (err
!= ECTF_NEXT_END
)
3692 einfo (_("CTF error: cannot get CTF errors: `%s'\n"),
3696 /* `err' returns errors from the error/warning iterator in particular.
3697 These never assert. But if we have an fp, that could have recorded
3698 an assertion failure: assert if it has done so. */
3699 ASSERT (!fp
|| ctf_errno (fp
) != ECTF_INTERNAL
);
3702 /* Open the CTF sections in the input files with libctf: if any were opened,
3703 create a fake input file that we'll write the merged CTF data to later
3707 ldlang_open_ctf (void)
3712 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3716 /* Incoming files from the compiler have a single ctf_dict_t in them
3717 (which is presented to us by the libctf API in a ctf_archive_t
3718 wrapper): files derived from a previous relocatable link have a CTF
3719 archive containing possibly many CTF files. */
3721 if ((file
->the_ctf
= ctf_bfdopen (file
->the_bfd
, &err
)) == NULL
)
3723 if (err
!= ECTF_NOCTFDATA
)
3725 lang_ctf_errs_warnings (NULL
);
3726 einfo (_("%P: warning: CTF section in %pB not loaded; "
3727 "its types will be discarded: %s\n"), file
->the_bfd
,
3733 /* Prevent the contents of this section from being written, while
3734 requiring the section itself to be duplicated in the output, but only
3736 /* This section must exist if ctf_bfdopen() succeeded. */
3737 sect
= bfd_get_section_by_name (file
->the_bfd
, ".ctf");
3739 sect
->flags
|= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
| SEC_LINKER_CREATED
;
3742 sect
->flags
|= SEC_EXCLUDE
;
3752 if ((ctf_output
= ctf_create (&err
)) != NULL
)
3755 einfo (_("%P: warning: CTF output not created: `%s'\n"),
3758 LANG_FOR_EACH_INPUT_STATEMENT (errfile
)
3759 ctf_close (errfile
->the_ctf
);
3762 /* Merge together CTF sections. After this, only the symtab-dependent
3763 function and data object sections need adjustment. */
3766 lang_merge_ctf (void)
3768 asection
*output_sect
;
3774 output_sect
= bfd_get_section_by_name (link_info
.output_bfd
, ".ctf");
3776 /* If the section was discarded, don't waste time merging. */
3777 if (output_sect
== NULL
)
3779 ctf_dict_close (ctf_output
);
3782 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3784 ctf_close (file
->the_ctf
);
3785 file
->the_ctf
= NULL
;
3790 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3795 /* Takes ownership of file->the_ctf. */
3796 if (ctf_link_add_ctf (ctf_output
, file
->the_ctf
, file
->filename
) < 0)
3798 einfo (_("%P: warning: CTF section in %pB cannot be linked: `%s'\n"),
3799 file
->the_bfd
, ctf_errmsg (ctf_errno (ctf_output
)));
3800 ctf_close (file
->the_ctf
);
3801 file
->the_ctf
= NULL
;
3806 if (!config
.ctf_share_duplicated
)
3807 flags
= CTF_LINK_SHARE_UNCONFLICTED
;
3809 flags
= CTF_LINK_SHARE_DUPLICATED
;
3810 if (!config
.ctf_variables
)
3811 flags
|= CTF_LINK_OMIT_VARIABLES_SECTION
;
3813 if (ctf_link (ctf_output
, flags
) < 0)
3815 lang_ctf_errs_warnings (ctf_output
);
3816 einfo (_("%P: warning: CTF linking failed; "
3817 "output will have no CTF section: %s\n"),
3818 ctf_errmsg (ctf_errno (ctf_output
)));
3821 output_sect
->size
= 0;
3822 output_sect
->flags
|= SEC_EXCLUDE
;
3825 /* Output any lingering errors that didn't come from ctf_link. */
3826 lang_ctf_errs_warnings (ctf_output
);
3829 /* Let the emulation examine the symbol table and strtab to help it optimize the
3830 CTF, if supported. */
3833 ldlang_ctf_apply_strsym (struct elf_sym_strtab
*syms
, bfd_size_type symcount
,
3834 struct elf_strtab_hash
*symstrtab
)
3836 ldemul_examine_strtab_for_ctf (ctf_output
, syms
, symcount
, symstrtab
);
3839 /* Write out the CTF section. Called early, if the emulation isn't going to
3840 need to dedup against the strtab and symtab, then possibly called from the
3841 target linker code if the dedup has happened. */
3843 lang_write_ctf (int late
)
3846 asection
*output_sect
;
3853 /* Emit CTF late if this emulation says it can do so. */
3854 if (ldemul_emit_ctf_early ())
3859 if (!ldemul_emit_ctf_early ())
3865 output_sect
= bfd_get_section_by_name (link_info
.output_bfd
, ".ctf");
3868 output_sect
->contents
= ctf_link_write (ctf_output
, &output_size
,
3869 CTF_COMPRESSION_THRESHOLD
);
3870 output_sect
->size
= output_size
;
3871 output_sect
->flags
|= SEC_IN_MEMORY
| SEC_KEEP
;
3873 lang_ctf_errs_warnings (ctf_output
);
3874 if (!output_sect
->contents
)
3876 einfo (_("%P: warning: CTF section emission failed; "
3877 "output will have no CTF section: %s\n"),
3878 ctf_errmsg (ctf_errno (ctf_output
)));
3879 output_sect
->size
= 0;
3880 output_sect
->flags
|= SEC_EXCLUDE
;
3884 /* This also closes every CTF input file used in the link. */
3885 ctf_dict_close (ctf_output
);
3888 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3889 file
->the_ctf
= NULL
;
3892 /* Write out the CTF section late, if the emulation needs that. */
3895 ldlang_write_ctf_late (void)
3897 /* Trigger a "late call", if the emulation needs one. */
3903 ldlang_open_ctf (void)
3905 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3909 /* If built without CTF, warn and delete all CTF sections from the output.
3910 (The alternative would be to simply concatenate them, which does not
3911 yield a valid CTF section.) */
3913 if ((sect
= bfd_get_section_by_name (file
->the_bfd
, ".ctf")) != NULL
)
3915 einfo (_("%P: warning: CTF section in %pB not linkable: "
3916 "%P was built without support for CTF\n"), file
->the_bfd
);
3918 sect
->flags
|= SEC_EXCLUDE
;
3923 static void lang_merge_ctf (void) {}
3925 ldlang_ctf_apply_strsym (struct elf_sym_strtab
*syms ATTRIBUTE_UNUSED
,
3926 bfd_size_type symcount ATTRIBUTE_UNUSED
,
3927 struct elf_strtab_hash
*symstrtab ATTRIBUTE_UNUSED
)
3930 static void lang_write_ctf (int late ATTRIBUTE_UNUSED
) {}
3931 void ldlang_write_ctf_late (void) {}
3934 /* Add the supplied name to the symbol table as an undefined reference.
3935 This is a two step process as the symbol table doesn't even exist at
3936 the time the ld command line is processed. First we put the name
3937 on a list, then, once the output file has been opened, transfer the
3938 name to the symbol table. */
3940 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3942 #define ldlang_undef_chain_list_head entry_symbol.next
3945 ldlang_add_undef (const char *const name
, bfd_boolean cmdline ATTRIBUTE_UNUSED
)
3947 ldlang_undef_chain_list_type
*new_undef
;
3949 new_undef
= stat_alloc (sizeof (*new_undef
));
3950 new_undef
->next
= ldlang_undef_chain_list_head
;
3951 ldlang_undef_chain_list_head
= new_undef
;
3953 new_undef
->name
= xstrdup (name
);
3955 if (link_info
.output_bfd
!= NULL
)
3956 insert_undefined (new_undef
->name
);
3959 /* Insert NAME as undefined in the symbol table. */
3962 insert_undefined (const char *name
)
3964 struct bfd_link_hash_entry
*h
;
3966 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
3968 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
3969 if (h
->type
== bfd_link_hash_new
)
3971 h
->type
= bfd_link_hash_undefined
;
3972 h
->u
.undef
.abfd
= NULL
;
3973 h
->non_ir_ref_regular
= TRUE
;
3974 if (is_elf_hash_table (link_info
.hash
))
3975 ((struct elf_link_hash_entry
*) h
)->mark
= 1;
3976 bfd_link_add_undef (link_info
.hash
, h
);
3980 /* Run through the list of undefineds created above and place them
3981 into the linker hash table as undefined symbols belonging to the
3985 lang_place_undefineds (void)
3987 ldlang_undef_chain_list_type
*ptr
;
3989 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3990 insert_undefined (ptr
->name
);
3993 /* Structure used to build the list of symbols that the user has required
3996 struct require_defined_symbol
3999 struct require_defined_symbol
*next
;
4002 /* The list of symbols that the user has required be defined. */
4004 static struct require_defined_symbol
*require_defined_symbol_list
;
4006 /* Add a new symbol NAME to the list of symbols that are required to be
4010 ldlang_add_require_defined (const char *const name
)
4012 struct require_defined_symbol
*ptr
;
4014 ldlang_add_undef (name
, TRUE
);
4015 ptr
= stat_alloc (sizeof (*ptr
));
4016 ptr
->next
= require_defined_symbol_list
;
4017 ptr
->name
= strdup (name
);
4018 require_defined_symbol_list
= ptr
;
4021 /* Check that all symbols the user required to be defined, are defined,
4022 raise an error if we find a symbol that is not defined. */
4025 ldlang_check_require_defined_symbols (void)
4027 struct require_defined_symbol
*ptr
;
4029 for (ptr
= require_defined_symbol_list
; ptr
!= NULL
; ptr
= ptr
->next
)
4031 struct bfd_link_hash_entry
*h
;
4033 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
,
4034 FALSE
, FALSE
, TRUE
);
4036 || (h
->type
!= bfd_link_hash_defined
4037 && h
->type
!= bfd_link_hash_defweak
))
4038 einfo(_("%X%P: required symbol `%s' not defined\n"), ptr
->name
);
4042 /* Check for all readonly or some readwrite sections. */
4045 check_input_sections
4046 (lang_statement_union_type
*s
,
4047 lang_output_section_statement_type
*output_section_statement
)
4049 for (; s
!= NULL
; s
= s
->header
.next
)
4051 switch (s
->header
.type
)
4053 case lang_wild_statement_enum
:
4054 walk_wild (&s
->wild_statement
, check_section_callback
,
4055 output_section_statement
);
4056 if (!output_section_statement
->all_input_readonly
)
4059 case lang_constructors_statement_enum
:
4060 check_input_sections (constructor_list
.head
,
4061 output_section_statement
);
4062 if (!output_section_statement
->all_input_readonly
)
4065 case lang_group_statement_enum
:
4066 check_input_sections (s
->group_statement
.children
.head
,
4067 output_section_statement
);
4068 if (!output_section_statement
->all_input_readonly
)
4077 /* Update wildcard statements if needed. */
4080 update_wild_statements (lang_statement_union_type
*s
)
4082 struct wildcard_list
*sec
;
4084 switch (sort_section
)
4094 for (; s
!= NULL
; s
= s
->header
.next
)
4096 switch (s
->header
.type
)
4101 case lang_wild_statement_enum
:
4102 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
4104 /* Don't sort .init/.fini sections. */
4105 if (strcmp (sec
->spec
.name
, ".init") != 0
4106 && strcmp (sec
->spec
.name
, ".fini") != 0)
4107 switch (sec
->spec
.sorted
)
4110 sec
->spec
.sorted
= sort_section
;
4113 if (sort_section
== by_alignment
)
4114 sec
->spec
.sorted
= by_name_alignment
;
4117 if (sort_section
== by_name
)
4118 sec
->spec
.sorted
= by_alignment_name
;
4125 case lang_constructors_statement_enum
:
4126 update_wild_statements (constructor_list
.head
);
4129 case lang_output_section_statement_enum
:
4130 update_wild_statements
4131 (s
->output_section_statement
.children
.head
);
4134 case lang_group_statement_enum
:
4135 update_wild_statements (s
->group_statement
.children
.head
);
4143 /* Open input files and attach to output sections. */
4146 map_input_to_output_sections
4147 (lang_statement_union_type
*s
, const char *target
,
4148 lang_output_section_statement_type
*os
)
4150 for (; s
!= NULL
; s
= s
->header
.next
)
4152 lang_output_section_statement_type
*tos
;
4155 switch (s
->header
.type
)
4157 case lang_wild_statement_enum
:
4158 wild (&s
->wild_statement
, target
, os
);
4160 case lang_constructors_statement_enum
:
4161 map_input_to_output_sections (constructor_list
.head
,
4165 case lang_output_section_statement_enum
:
4166 tos
= &s
->output_section_statement
;
4167 if (tos
->constraint
!= 0)
4169 if (tos
->constraint
!= ONLY_IF_RW
4170 && tos
->constraint
!= ONLY_IF_RO
)
4172 tos
->all_input_readonly
= TRUE
;
4173 check_input_sections (tos
->children
.head
, tos
);
4174 if (tos
->all_input_readonly
!= (tos
->constraint
== ONLY_IF_RO
))
4176 tos
->constraint
= -1;
4180 map_input_to_output_sections (tos
->children
.head
,
4184 case lang_output_statement_enum
:
4186 case lang_target_statement_enum
:
4187 target
= s
->target_statement
.target
;
4189 case lang_group_statement_enum
:
4190 map_input_to_output_sections (s
->group_statement
.children
.head
,
4194 case lang_data_statement_enum
:
4195 /* Make sure that any sections mentioned in the expression
4197 exp_init_os (s
->data_statement
.exp
);
4198 /* The output section gets CONTENTS, ALLOC and LOAD, but
4199 these may be overridden by the script. */
4200 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
;
4201 switch (os
->sectype
)
4203 case normal_section
:
4204 case overlay_section
:
4205 case first_overlay_section
:
4207 case noalloc_section
:
4208 flags
= SEC_HAS_CONTENTS
;
4210 case noload_section
:
4211 if (bfd_get_flavour (link_info
.output_bfd
)
4212 == bfd_target_elf_flavour
)
4213 flags
= SEC_NEVER_LOAD
| SEC_ALLOC
;
4215 flags
= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
;
4218 if (os
->bfd_section
== NULL
)
4219 init_os (os
, flags
);
4221 os
->bfd_section
->flags
|= flags
;
4223 case lang_input_section_enum
:
4225 case lang_fill_statement_enum
:
4226 case lang_object_symbols_statement_enum
:
4227 case lang_reloc_statement_enum
:
4228 case lang_padding_statement_enum
:
4229 case lang_input_statement_enum
:
4230 if (os
!= NULL
&& os
->bfd_section
== NULL
)
4233 case lang_assignment_statement_enum
:
4234 if (os
!= NULL
&& os
->bfd_section
== NULL
)
4237 /* Make sure that any sections mentioned in the assignment
4239 exp_init_os (s
->assignment_statement
.exp
);
4241 case lang_address_statement_enum
:
4242 /* Mark the specified section with the supplied address.
4243 If this section was actually a segment marker, then the
4244 directive is ignored if the linker script explicitly
4245 processed the segment marker. Originally, the linker
4246 treated segment directives (like -Ttext on the
4247 command-line) as section directives. We honor the
4248 section directive semantics for backwards compatibility;
4249 linker scripts that do not specifically check for
4250 SEGMENT_START automatically get the old semantics. */
4251 if (!s
->address_statement
.segment
4252 || !s
->address_statement
.segment
->used
)
4254 const char *name
= s
->address_statement
.section_name
;
4256 /* Create the output section statement here so that
4257 orphans with a set address will be placed after other
4258 script sections. If we let the orphan placement code
4259 place them in amongst other sections then the address
4260 will affect following script sections, which is
4261 likely to surprise naive users. */
4262 tos
= lang_output_section_statement_lookup (name
, 0, TRUE
);
4263 tos
->addr_tree
= s
->address_statement
.address
;
4264 if (tos
->bfd_section
== NULL
)
4268 case lang_insert_statement_enum
:
4274 /* An insert statement snips out all the linker statements from the
4275 start of the list and places them after the output section
4276 statement specified by the insert. This operation is complicated
4277 by the fact that we keep a doubly linked list of output section
4278 statements as well as the singly linked list of all statements.
4279 FIXME someday: Twiddling with the list not only moves statements
4280 from the user's script but also input and group statements that are
4281 built from command line object files and --start-group. We only
4282 get away with this because the list pointers used by file_chain
4283 and input_file_chain are not reordered, and processing via
4284 statement_list after this point mostly ignores input statements.
4285 One exception is the map file, where LOAD and START GROUP/END GROUP
4286 can end up looking odd. */
4289 process_insert_statements (lang_statement_union_type
**start
)
4291 lang_statement_union_type
**s
;
4292 lang_output_section_statement_type
*first_os
= NULL
;
4293 lang_output_section_statement_type
*last_os
= NULL
;
4294 lang_output_section_statement_type
*os
;
4299 if ((*s
)->header
.type
== lang_output_section_statement_enum
)
4301 /* Keep pointers to the first and last output section
4302 statement in the sequence we may be about to move. */
4303 os
= &(*s
)->output_section_statement
;
4305 ASSERT (last_os
== NULL
|| last_os
->next
== os
);
4308 /* Set constraint negative so that lang_output_section_find
4309 won't match this output section statement. At this
4310 stage in linking constraint has values in the range
4311 [-1, ONLY_IN_RW]. */
4312 last_os
->constraint
= -2 - last_os
->constraint
;
4313 if (first_os
== NULL
)
4316 else if ((*s
)->header
.type
== lang_group_statement_enum
)
4318 /* A user might put -T between --start-group and
4319 --end-group. One way this odd construct might arise is
4320 from a wrapper around ld to change library search
4321 behaviour. For example:
4323 exec real_ld --start-group "$@" --end-group
4324 This isn't completely unreasonable so go looking inside a
4325 group statement for insert statements. */
4326 process_insert_statements (&(*s
)->group_statement
.children
.head
);
4328 else if ((*s
)->header
.type
== lang_insert_statement_enum
)
4330 lang_insert_statement_type
*i
= &(*s
)->insert_statement
;
4331 lang_output_section_statement_type
*where
;
4332 lang_statement_union_type
**ptr
;
4333 lang_statement_union_type
*first
;
4335 if (link_info
.non_contiguous_regions
)
4337 einfo (_("warning: INSERT statement in linker script is "
4338 "incompatible with --enable-non-contiguous-regions.\n"));
4341 where
= lang_output_section_find (i
->where
);
4342 if (where
!= NULL
&& i
->is_before
)
4345 where
= where
->prev
;
4346 while (where
!= NULL
&& where
->constraint
< 0);
4350 einfo (_("%F%P: %s not found for insert\n"), i
->where
);
4354 /* Deal with reordering the output section statement list. */
4355 if (last_os
!= NULL
)
4357 asection
*first_sec
, *last_sec
;
4358 struct lang_output_section_statement_struct
**next
;
4360 /* Snip out the output sections we are moving. */
4361 first_os
->prev
->next
= last_os
->next
;
4362 if (last_os
->next
== NULL
)
4364 next
= &first_os
->prev
->next
;
4365 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4368 last_os
->next
->prev
= first_os
->prev
;
4369 /* Add them in at the new position. */
4370 last_os
->next
= where
->next
;
4371 if (where
->next
== NULL
)
4373 next
= &last_os
->next
;
4374 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4377 where
->next
->prev
= last_os
;
4378 first_os
->prev
= where
;
4379 where
->next
= first_os
;
4381 /* Move the bfd sections in the same way. */
4384 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4386 os
->constraint
= -2 - os
->constraint
;
4387 if (os
->bfd_section
!= NULL
4388 && os
->bfd_section
->owner
!= NULL
)
4390 last_sec
= os
->bfd_section
;
4391 if (first_sec
== NULL
)
4392 first_sec
= last_sec
;
4397 if (last_sec
!= NULL
)
4399 asection
*sec
= where
->bfd_section
;
4401 sec
= output_prev_sec_find (where
);
4403 /* The place we want to insert must come after the
4404 sections we are moving. So if we find no
4405 section or if the section is the same as our
4406 last section, then no move is needed. */
4407 if (sec
!= NULL
&& sec
!= last_sec
)
4409 /* Trim them off. */
4410 if (first_sec
->prev
!= NULL
)
4411 first_sec
->prev
->next
= last_sec
->next
;
4413 link_info
.output_bfd
->sections
= last_sec
->next
;
4414 if (last_sec
->next
!= NULL
)
4415 last_sec
->next
->prev
= first_sec
->prev
;
4417 link_info
.output_bfd
->section_last
= first_sec
->prev
;
4419 last_sec
->next
= sec
->next
;
4420 if (sec
->next
!= NULL
)
4421 sec
->next
->prev
= last_sec
;
4423 link_info
.output_bfd
->section_last
= last_sec
;
4424 first_sec
->prev
= sec
;
4425 sec
->next
= first_sec
;
4433 ptr
= insert_os_after (where
);
4434 /* Snip everything from the start of the list, up to and
4435 including the insert statement we are currently processing. */
4437 *start
= (*s
)->header
.next
;
4438 /* Add them back where they belong, minus the insert. */
4441 statement_list
.tail
= s
;
4446 s
= &(*s
)->header
.next
;
4449 /* Undo constraint twiddling. */
4450 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4452 os
->constraint
= -2 - os
->constraint
;
4458 /* An output section might have been removed after its statement was
4459 added. For example, ldemul_before_allocation can remove dynamic
4460 sections if they turn out to be not needed. Clean them up here. */
4463 strip_excluded_output_sections (void)
4465 lang_output_section_statement_type
*os
;
4467 /* Run lang_size_sections (if not already done). */
4468 if (expld
.phase
!= lang_mark_phase_enum
)
4470 expld
.phase
= lang_mark_phase_enum
;
4471 expld
.dataseg
.phase
= exp_seg_none
;
4472 one_lang_size_sections_pass (NULL
, FALSE
);
4473 lang_reset_memory_regions ();
4476 for (os
= (void *) lang_os_list
.head
;
4480 asection
*output_section
;
4481 bfd_boolean exclude
;
4483 if (os
->constraint
< 0)
4486 output_section
= os
->bfd_section
;
4487 if (output_section
== NULL
)
4490 exclude
= (output_section
->rawsize
== 0
4491 && (output_section
->flags
& SEC_KEEP
) == 0
4492 && !bfd_section_removed_from_list (link_info
.output_bfd
,
4495 /* Some sections have not yet been sized, notably .gnu.version,
4496 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
4497 input sections, so don't drop output sections that have such
4498 input sections unless they are also marked SEC_EXCLUDE. */
4499 if (exclude
&& output_section
->map_head
.s
!= NULL
)
4503 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
4504 if ((s
->flags
& SEC_EXCLUDE
) == 0
4505 && ((s
->flags
& SEC_LINKER_CREATED
) != 0
4506 || link_info
.emitrelocations
))
4515 /* We don't set bfd_section to NULL since bfd_section of the
4516 removed output section statement may still be used. */
4517 if (!os
->update_dot
)
4519 output_section
->flags
|= SEC_EXCLUDE
;
4520 bfd_section_list_remove (link_info
.output_bfd
, output_section
);
4521 link_info
.output_bfd
->section_count
--;
4526 /* Called from ldwrite to clear out asection.map_head and
4527 asection.map_tail for use as link_orders in ldwrite. */
4530 lang_clear_os_map (void)
4532 lang_output_section_statement_type
*os
;
4534 if (map_head_is_link_order
)
4537 for (os
= (void *) lang_os_list
.head
;
4541 asection
*output_section
;
4543 if (os
->constraint
< 0)
4546 output_section
= os
->bfd_section
;
4547 if (output_section
== NULL
)
4550 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
4551 output_section
->map_head
.link_order
= NULL
;
4552 output_section
->map_tail
.link_order
= NULL
;
4555 /* Stop future calls to lang_add_section from messing with map_head
4556 and map_tail link_order fields. */
4557 map_head_is_link_order
= TRUE
;
4561 print_output_section_statement
4562 (lang_output_section_statement_type
*output_section_statement
)
4564 asection
*section
= output_section_statement
->bfd_section
;
4567 if (output_section_statement
!= abs_output_section
)
4569 minfo ("\n%s", output_section_statement
->name
);
4571 if (section
!= NULL
)
4573 print_dot
= section
->vma
;
4575 len
= strlen (output_section_statement
->name
);
4576 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4581 while (len
< SECTION_NAME_MAP_LENGTH
)
4587 minfo ("0x%V %W", section
->vma
, TO_ADDR (section
->size
));
4589 if (section
->vma
!= section
->lma
)
4590 minfo (_(" load address 0x%V"), section
->lma
);
4592 if (output_section_statement
->update_dot_tree
!= NULL
)
4593 exp_fold_tree (output_section_statement
->update_dot_tree
,
4594 bfd_abs_section_ptr
, &print_dot
);
4600 print_statement_list (output_section_statement
->children
.head
,
4601 output_section_statement
);
4605 print_assignment (lang_assignment_statement_type
*assignment
,
4606 lang_output_section_statement_type
*output_section
)
4613 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4616 if (assignment
->exp
->type
.node_class
== etree_assert
)
4619 tree
= assignment
->exp
->assert_s
.child
;
4623 const char *dst
= assignment
->exp
->assign
.dst
;
4625 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
4626 tree
= assignment
->exp
;
4629 osec
= output_section
->bfd_section
;
4631 osec
= bfd_abs_section_ptr
;
4633 if (assignment
->exp
->type
.node_class
!= etree_provide
)
4634 exp_fold_tree (tree
, osec
, &print_dot
);
4636 expld
.result
.valid_p
= FALSE
;
4638 if (expld
.result
.valid_p
)
4642 if (assignment
->exp
->type
.node_class
== etree_assert
4644 || expld
.assign_name
!= NULL
)
4646 value
= expld
.result
.value
;
4648 if (expld
.result
.section
!= NULL
)
4649 value
+= expld
.result
.section
->vma
;
4651 minfo ("0x%V", value
);
4657 struct bfd_link_hash_entry
*h
;
4659 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
4660 FALSE
, FALSE
, TRUE
);
4662 && (h
->type
== bfd_link_hash_defined
4663 || h
->type
== bfd_link_hash_defweak
))
4665 value
= h
->u
.def
.value
;
4666 value
+= h
->u
.def
.section
->output_section
->vma
;
4667 value
+= h
->u
.def
.section
->output_offset
;
4669 minfo ("[0x%V]", value
);
4672 minfo ("[unresolved]");
4677 if (assignment
->exp
->type
.node_class
== etree_provide
)
4678 minfo ("[!provide]");
4685 expld
.assign_name
= NULL
;
4688 exp_print_tree (assignment
->exp
);
4693 print_input_statement (lang_input_statement_type
*statm
)
4695 if (statm
->filename
!= NULL
)
4696 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
4699 /* Print all symbols defined in a particular section. This is called
4700 via bfd_link_hash_traverse, or by print_all_symbols. */
4703 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
4705 asection
*sec
= (asection
*) ptr
;
4707 if ((hash_entry
->type
== bfd_link_hash_defined
4708 || hash_entry
->type
== bfd_link_hash_defweak
)
4709 && sec
== hash_entry
->u
.def
.section
)
4713 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4716 (hash_entry
->u
.def
.value
4717 + hash_entry
->u
.def
.section
->output_offset
4718 + hash_entry
->u
.def
.section
->output_section
->vma
));
4720 minfo (" %pT\n", hash_entry
->root
.string
);
4727 hash_entry_addr_cmp (const void *a
, const void *b
)
4729 const struct bfd_link_hash_entry
*l
= *(const struct bfd_link_hash_entry
**)a
;
4730 const struct bfd_link_hash_entry
*r
= *(const struct bfd_link_hash_entry
**)b
;
4732 if (l
->u
.def
.value
< r
->u
.def
.value
)
4734 else if (l
->u
.def
.value
> r
->u
.def
.value
)
4741 print_all_symbols (asection
*sec
)
4743 input_section_userdata_type
*ud
= bfd_section_userdata (sec
);
4744 struct map_symbol_def
*def
;
4745 struct bfd_link_hash_entry
**entries
;
4751 *ud
->map_symbol_def_tail
= 0;
4753 /* Sort the symbols by address. */
4754 entries
= (struct bfd_link_hash_entry
**)
4755 obstack_alloc (&map_obstack
,
4756 ud
->map_symbol_def_count
* sizeof (*entries
));
4758 for (i
= 0, def
= ud
->map_symbol_def_head
; def
; def
= def
->next
, i
++)
4759 entries
[i
] = def
->entry
;
4761 qsort (entries
, ud
->map_symbol_def_count
, sizeof (*entries
),
4762 hash_entry_addr_cmp
);
4764 /* Print the symbols. */
4765 for (i
= 0; i
< ud
->map_symbol_def_count
; i
++)
4766 ldemul_print_symbol (entries
[i
], sec
);
4768 obstack_free (&map_obstack
, entries
);
4771 /* Print information about an input section to the map file. */
4774 print_input_section (asection
*i
, bfd_boolean is_discarded
)
4776 bfd_size_type size
= i
->size
;
4783 minfo ("%s", i
->name
);
4785 len
= 1 + strlen (i
->name
);
4786 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4791 while (len
< SECTION_NAME_MAP_LENGTH
)
4797 if (i
->output_section
!= NULL
4798 && i
->output_section
->owner
== link_info
.output_bfd
)
4799 addr
= i
->output_section
->vma
+ i
->output_offset
;
4807 minfo ("0x%V %W %pB\n", addr
, TO_ADDR (size
), i
->owner
);
4809 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
4811 len
= SECTION_NAME_MAP_LENGTH
+ 3;
4823 minfo (_("%W (size before relaxing)\n"), TO_ADDR (i
->rawsize
));
4826 if (i
->output_section
!= NULL
4827 && i
->output_section
->owner
== link_info
.output_bfd
)
4829 if (link_info
.reduce_memory_overheads
)
4830 bfd_link_hash_traverse (link_info
.hash
, ldemul_print_symbol
, i
);
4832 print_all_symbols (i
);
4834 /* Update print_dot, but make sure that we do not move it
4835 backwards - this could happen if we have overlays and a
4836 later overlay is shorter than an earier one. */
4837 if (addr
+ TO_ADDR (size
) > print_dot
)
4838 print_dot
= addr
+ TO_ADDR (size
);
4843 print_fill_statement (lang_fill_statement_type
*fill
)
4847 fputs (" FILL mask 0x", config
.map_file
);
4848 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
4849 fprintf (config
.map_file
, "%02x", *p
);
4850 fputs ("\n", config
.map_file
);
4854 print_data_statement (lang_data_statement_type
*data
)
4861 init_opb (data
->output_section
);
4862 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4865 addr
= data
->output_offset
;
4866 if (data
->output_section
!= NULL
)
4867 addr
+= data
->output_section
->vma
;
4895 if (size
< TO_SIZE ((unsigned) 1))
4896 size
= TO_SIZE ((unsigned) 1);
4897 minfo ("0x%V %W %s 0x%v", addr
, TO_ADDR (size
), name
, data
->value
);
4899 if (data
->exp
->type
.node_class
!= etree_value
)
4902 exp_print_tree (data
->exp
);
4907 print_dot
= addr
+ TO_ADDR (size
);
4910 /* Print an address statement. These are generated by options like
4914 print_address_statement (lang_address_statement_type
*address
)
4916 minfo (_("Address of section %s set to "), address
->section_name
);
4917 exp_print_tree (address
->address
);
4921 /* Print a reloc statement. */
4924 print_reloc_statement (lang_reloc_statement_type
*reloc
)
4930 init_opb (reloc
->output_section
);
4931 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4934 addr
= reloc
->output_offset
;
4935 if (reloc
->output_section
!= NULL
)
4936 addr
+= reloc
->output_section
->vma
;
4938 size
= bfd_get_reloc_size (reloc
->howto
);
4940 minfo ("0x%V %W RELOC %s ", addr
, TO_ADDR (size
), reloc
->howto
->name
);
4942 if (reloc
->name
!= NULL
)
4943 minfo ("%s+", reloc
->name
);
4945 minfo ("%s+", reloc
->section
->name
);
4947 exp_print_tree (reloc
->addend_exp
);
4951 print_dot
= addr
+ TO_ADDR (size
);
4955 print_padding_statement (lang_padding_statement_type
*s
)
4960 init_opb (s
->output_section
);
4963 len
= sizeof " *fill*" - 1;
4964 while (len
< SECTION_NAME_MAP_LENGTH
)
4970 addr
= s
->output_offset
;
4971 if (s
->output_section
!= NULL
)
4972 addr
+= s
->output_section
->vma
;
4973 minfo ("0x%V %W ", addr
, TO_ADDR (s
->size
));
4975 if (s
->fill
->size
!= 0)
4979 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
4980 fprintf (config
.map_file
, "%02x", *p
);
4985 print_dot
= addr
+ TO_ADDR (s
->size
);
4989 print_wild_statement (lang_wild_statement_type
*w
,
4990 lang_output_section_statement_type
*os
)
4992 struct wildcard_list
*sec
;
4996 if (w
->exclude_name_list
)
4999 minfo ("EXCLUDE_FILE(%s", w
->exclude_name_list
->name
);
5000 for (tmp
= w
->exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
5001 minfo (" %s", tmp
->name
);
5005 if (w
->filenames_sorted
)
5006 minfo ("SORT_BY_NAME(");
5007 if (w
->filename
!= NULL
)
5008 minfo ("%s", w
->filename
);
5011 if (w
->filenames_sorted
)
5015 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
5017 int closing_paren
= 0;
5019 switch (sec
->spec
.sorted
)
5025 minfo ("SORT_BY_NAME(");
5030 minfo ("SORT_BY_ALIGNMENT(");
5034 case by_name_alignment
:
5035 minfo ("SORT_BY_NAME(SORT_BY_ALIGNMENT(");
5039 case by_alignment_name
:
5040 minfo ("SORT_BY_ALIGNMENT(SORT_BY_NAME(");
5045 minfo ("SORT_NONE(");
5049 case by_init_priority
:
5050 minfo ("SORT_BY_INIT_PRIORITY(");
5055 if (sec
->spec
.exclude_name_list
!= NULL
)
5058 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
5059 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
5060 minfo (" %s", tmp
->name
);
5063 if (sec
->spec
.name
!= NULL
)
5064 minfo ("%s", sec
->spec
.name
);
5067 for (;closing_paren
> 0; closing_paren
--)
5076 print_statement_list (w
->children
.head
, os
);
5079 /* Print a group statement. */
5082 print_group (lang_group_statement_type
*s
,
5083 lang_output_section_statement_type
*os
)
5085 fprintf (config
.map_file
, "START GROUP\n");
5086 print_statement_list (s
->children
.head
, os
);
5087 fprintf (config
.map_file
, "END GROUP\n");
5090 /* Print the list of statements in S.
5091 This can be called for any statement type. */
5094 print_statement_list (lang_statement_union_type
*s
,
5095 lang_output_section_statement_type
*os
)
5099 print_statement (s
, os
);
5104 /* Print the first statement in statement list S.
5105 This can be called for any statement type. */
5108 print_statement (lang_statement_union_type
*s
,
5109 lang_output_section_statement_type
*os
)
5111 switch (s
->header
.type
)
5114 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
5117 case lang_constructors_statement_enum
:
5118 if (constructor_list
.head
!= NULL
)
5120 if (constructors_sorted
)
5121 minfo (" SORT (CONSTRUCTORS)\n");
5123 minfo (" CONSTRUCTORS\n");
5124 print_statement_list (constructor_list
.head
, os
);
5127 case lang_wild_statement_enum
:
5128 print_wild_statement (&s
->wild_statement
, os
);
5130 case lang_address_statement_enum
:
5131 print_address_statement (&s
->address_statement
);
5133 case lang_object_symbols_statement_enum
:
5134 minfo (" CREATE_OBJECT_SYMBOLS\n");
5136 case lang_fill_statement_enum
:
5137 print_fill_statement (&s
->fill_statement
);
5139 case lang_data_statement_enum
:
5140 print_data_statement (&s
->data_statement
);
5142 case lang_reloc_statement_enum
:
5143 print_reloc_statement (&s
->reloc_statement
);
5145 case lang_input_section_enum
:
5146 print_input_section (s
->input_section
.section
, FALSE
);
5148 case lang_padding_statement_enum
:
5149 print_padding_statement (&s
->padding_statement
);
5151 case lang_output_section_statement_enum
:
5152 print_output_section_statement (&s
->output_section_statement
);
5154 case lang_assignment_statement_enum
:
5155 print_assignment (&s
->assignment_statement
, os
);
5157 case lang_target_statement_enum
:
5158 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
5160 case lang_output_statement_enum
:
5161 minfo ("OUTPUT(%s", s
->output_statement
.name
);
5162 if (output_target
!= NULL
)
5163 minfo (" %s", output_target
);
5166 case lang_input_statement_enum
:
5167 print_input_statement (&s
->input_statement
);
5169 case lang_group_statement_enum
:
5170 print_group (&s
->group_statement
, os
);
5172 case lang_insert_statement_enum
:
5173 minfo ("INSERT %s %s\n",
5174 s
->insert_statement
.is_before
? "BEFORE" : "AFTER",
5175 s
->insert_statement
.where
);
5181 print_statements (void)
5183 print_statement_list (statement_list
.head
, abs_output_section
);
5186 /* Print the first N statements in statement list S to STDERR.
5187 If N == 0, nothing is printed.
5188 If N < 0, the entire list is printed.
5189 Intended to be called from GDB. */
5192 dprint_statement (lang_statement_union_type
*s
, int n
)
5194 FILE *map_save
= config
.map_file
;
5196 config
.map_file
= stderr
;
5199 print_statement_list (s
, abs_output_section
);
5202 while (s
&& --n
>= 0)
5204 print_statement (s
, abs_output_section
);
5209 config
.map_file
= map_save
;
5213 insert_pad (lang_statement_union_type
**ptr
,
5215 bfd_size_type alignment_needed
,
5216 asection
*output_section
,
5219 static fill_type zero_fill
;
5220 lang_statement_union_type
*pad
= NULL
;
5222 if (ptr
!= &statement_list
.head
)
5223 pad
= ((lang_statement_union_type
*)
5224 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
5226 && pad
->header
.type
== lang_padding_statement_enum
5227 && pad
->padding_statement
.output_section
== output_section
)
5229 /* Use the existing pad statement. */
5231 else if ((pad
= *ptr
) != NULL
5232 && pad
->header
.type
== lang_padding_statement_enum
5233 && pad
->padding_statement
.output_section
== output_section
)
5235 /* Use the existing pad statement. */
5239 /* Make a new padding statement, linked into existing chain. */
5240 pad
= stat_alloc (sizeof (lang_padding_statement_type
));
5241 pad
->header
.next
= *ptr
;
5243 pad
->header
.type
= lang_padding_statement_enum
;
5244 pad
->padding_statement
.output_section
= output_section
;
5247 pad
->padding_statement
.fill
= fill
;
5249 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
5250 pad
->padding_statement
.size
= alignment_needed
;
5251 if (!(output_section
->flags
& SEC_FIXED_SIZE
))
5252 output_section
->size
= TO_SIZE (dot
+ TO_ADDR (alignment_needed
)
5253 - output_section
->vma
);
5256 /* Work out how much this section will move the dot point. */
5260 (lang_statement_union_type
**this_ptr
,
5261 lang_output_section_statement_type
*output_section_statement
,
5263 bfd_boolean
*removed
,
5266 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
5267 asection
*i
= is
->section
;
5268 asection
*o
= output_section_statement
->bfd_section
;
5271 if (link_info
.non_contiguous_regions
)
5273 /* If the input section I has already been successfully assigned
5274 to an output section other than O, don't bother with it and
5275 let the caller remove it from the list. Keep processing in
5276 case we have already handled O, because the repeated passes
5277 have reinitialized its size. */
5278 if (i
->already_assigned
&& i
->already_assigned
!= o
)
5285 if (i
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
5286 i
->output_offset
= i
->vma
- o
->vma
;
5287 else if (((i
->flags
& SEC_EXCLUDE
) != 0)
5288 || output_section_statement
->ignored
)
5289 i
->output_offset
= dot
- o
->vma
;
5292 bfd_size_type alignment_needed
;
5294 /* Align this section first to the input sections requirement,
5295 then to the output section's requirement. If this alignment
5296 is greater than any seen before, then record it too. Perform
5297 the alignment by inserting a magic 'padding' statement. */
5299 if (output_section_statement
->subsection_alignment
!= NULL
)
5301 = exp_get_power (output_section_statement
->subsection_alignment
,
5302 "subsection alignment");
5304 if (o
->alignment_power
< i
->alignment_power
)
5305 o
->alignment_power
= i
->alignment_power
;
5307 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
5309 if (alignment_needed
!= 0)
5311 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
5312 dot
+= alignment_needed
;
5315 if (link_info
.non_contiguous_regions
)
5317 /* If I would overflow O, let the caller remove I from the
5319 if (output_section_statement
->region
)
5321 bfd_vma end
= output_section_statement
->region
->origin
5322 + output_section_statement
->region
->length
;
5324 if (dot
+ TO_ADDR (i
->size
) > end
)
5326 if (i
->flags
& SEC_LINKER_CREATED
)
5327 einfo (_("%F%P: Output section '%s' not large enough for the "
5328 "linker-created stubs section '%s'.\n"),
5329 i
->output_section
->name
, i
->name
);
5331 if (i
->rawsize
&& i
->rawsize
!= i
->size
)
5332 einfo (_("%F%P: Relaxation not supported with "
5333 "--enable-non-contiguous-regions (section '%s' "
5334 "would overflow '%s' after it changed size).\n"),
5335 i
->name
, i
->output_section
->name
);
5339 i
->output_section
= NULL
;
5345 /* Remember where in the output section this input section goes. */
5346 i
->output_offset
= dot
- o
->vma
;
5348 /* Mark how big the output section must be to contain this now. */
5349 dot
+= TO_ADDR (i
->size
);
5350 if (!(o
->flags
& SEC_FIXED_SIZE
))
5351 o
->size
= TO_SIZE (dot
- o
->vma
);
5353 if (link_info
.non_contiguous_regions
)
5355 /* Record that I was successfully assigned to O, and update
5356 its actual output section too. */
5357 i
->already_assigned
= o
;
5358 i
->output_section
= o
;
5372 sort_sections_by_lma (const void *arg1
, const void *arg2
)
5374 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
5375 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
5377 if (sec1
->lma
< sec2
->lma
)
5379 else if (sec1
->lma
> sec2
->lma
)
5381 else if (sec1
->id
< sec2
->id
)
5383 else if (sec1
->id
> sec2
->id
)
5390 sort_sections_by_vma (const void *arg1
, const void *arg2
)
5392 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
5393 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
5395 if (sec1
->vma
< sec2
->vma
)
5397 else if (sec1
->vma
> sec2
->vma
)
5399 else if (sec1
->id
< sec2
->id
)
5401 else if (sec1
->id
> sec2
->id
)
5407 #define IS_TBSS(s) \
5408 ((s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == SEC_THREAD_LOCAL)
5410 #define IGNORE_SECTION(s) \
5411 ((s->flags & SEC_ALLOC) == 0 || IS_TBSS (s))
5413 /* Check to see if any allocated sections overlap with other allocated
5414 sections. This can happen if a linker script specifies the output
5415 section addresses of the two sections. Also check whether any memory
5416 region has overflowed. */
5419 lang_check_section_addresses (void)
5422 struct check_sec
*sections
;
5427 bfd_vma p_start
= 0;
5429 lang_memory_region_type
*m
;
5430 bfd_boolean overlays
;
5432 /* Detect address space overflow on allocated sections. */
5433 addr_mask
= ((bfd_vma
) 1 <<
5434 (bfd_arch_bits_per_address (link_info
.output_bfd
) - 1)) - 1;
5435 addr_mask
= (addr_mask
<< 1) + 1;
5436 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5437 if ((s
->flags
& SEC_ALLOC
) != 0)
5439 s_end
= (s
->vma
+ s
->size
) & addr_mask
;
5440 if (s_end
!= 0 && s_end
< (s
->vma
& addr_mask
))
5441 einfo (_("%X%P: section %s VMA wraps around address space\n"),
5445 s_end
= (s
->lma
+ s
->size
) & addr_mask
;
5446 if (s_end
!= 0 && s_end
< (s
->lma
& addr_mask
))
5447 einfo (_("%X%P: section %s LMA wraps around address space\n"),
5452 if (bfd_count_sections (link_info
.output_bfd
) <= 1)
5455 count
= bfd_count_sections (link_info
.output_bfd
);
5456 sections
= XNEWVEC (struct check_sec
, count
);
5458 /* Scan all sections in the output list. */
5460 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5462 if (IGNORE_SECTION (s
)
5466 sections
[count
].sec
= s
;
5467 sections
[count
].warned
= FALSE
;
5477 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_lma
);
5479 /* First check section LMAs. There should be no overlap of LMAs on
5480 loadable sections, even with overlays. */
5481 for (p
= NULL
, i
= 0; i
< count
; i
++)
5483 s
= sections
[i
].sec
;
5485 if ((s
->flags
& SEC_LOAD
) != 0)
5488 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5490 /* Look for an overlap. We have sorted sections by lma, so
5491 we know that s_start >= p_start. Besides the obvious
5492 case of overlap when the current section starts before
5493 the previous one ends, we also must have overlap if the
5494 previous section wraps around the address space. */
5496 && (s_start
<= p_end
5497 || p_end
< p_start
))
5499 einfo (_("%X%P: section %s LMA [%V,%V]"
5500 " overlaps section %s LMA [%V,%V]\n"),
5501 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5502 sections
[i
].warned
= TRUE
;
5510 /* If any non-zero size allocated section (excluding tbss) starts at
5511 exactly the same VMA as another such section, then we have
5512 overlays. Overlays generated by the OVERLAY keyword will have
5513 this property. It is possible to intentionally generate overlays
5514 that fail this test, but it would be unusual. */
5515 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_vma
);
5517 p_start
= sections
[0].sec
->vma
;
5518 for (i
= 1; i
< count
; i
++)
5520 s_start
= sections
[i
].sec
->vma
;
5521 if (p_start
== s_start
)
5529 /* Now check section VMAs if no overlays were detected. */
5532 for (p
= NULL
, i
= 0; i
< count
; i
++)
5534 s
= sections
[i
].sec
;
5537 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5540 && !sections
[i
].warned
5541 && (s_start
<= p_end
5542 || p_end
< p_start
))
5543 einfo (_("%X%P: section %s VMA [%V,%V]"
5544 " overlaps section %s VMA [%V,%V]\n"),
5545 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5554 /* If any memory region has overflowed, report by how much.
5555 We do not issue this diagnostic for regions that had sections
5556 explicitly placed outside their bounds; os_region_check's
5557 diagnostics are adequate for that case.
5559 FIXME: It is conceivable that m->current - (m->origin + m->length)
5560 might overflow a 32-bit integer. There is, alas, no way to print
5561 a bfd_vma quantity in decimal. */
5562 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
5563 if (m
->had_full_message
)
5565 unsigned long over
= m
->current
- (m
->origin
+ m
->length
);
5566 einfo (ngettext ("%X%P: region `%s' overflowed by %lu byte\n",
5567 "%X%P: region `%s' overflowed by %lu bytes\n",
5569 m
->name_list
.name
, over
);
5573 /* Make sure the new address is within the region. We explicitly permit the
5574 current address to be at the exact end of the region when the address is
5575 non-zero, in case the region is at the end of addressable memory and the
5576 calculation wraps around. */
5579 os_region_check (lang_output_section_statement_type
*os
,
5580 lang_memory_region_type
*region
,
5584 if ((region
->current
< region
->origin
5585 || (region
->current
- region
->origin
> region
->length
))
5586 && ((region
->current
!= region
->origin
+ region
->length
)
5591 einfo (_("%X%P: address 0x%v of %pB section `%s'"
5592 " is not within region `%s'\n"),
5594 os
->bfd_section
->owner
,
5595 os
->bfd_section
->name
,
5596 region
->name_list
.name
);
5598 else if (!region
->had_full_message
)
5600 region
->had_full_message
= TRUE
;
5602 einfo (_("%X%P: %pB section `%s' will not fit in region `%s'\n"),
5603 os
->bfd_section
->owner
,
5604 os
->bfd_section
->name
,
5605 region
->name_list
.name
);
5611 ldlang_check_relro_region (lang_statement_union_type
*s
,
5612 seg_align_type
*seg
)
5614 if (seg
->relro
== exp_seg_relro_start
)
5616 if (!seg
->relro_start_stat
)
5617 seg
->relro_start_stat
= s
;
5620 ASSERT (seg
->relro_start_stat
== s
);
5623 else if (seg
->relro
== exp_seg_relro_end
)
5625 if (!seg
->relro_end_stat
)
5626 seg
->relro_end_stat
= s
;
5629 ASSERT (seg
->relro_end_stat
== s
);
5634 /* Set the sizes for all the output sections. */
5637 lang_size_sections_1
5638 (lang_statement_union_type
**prev
,
5639 lang_output_section_statement_type
*output_section_statement
,
5643 bfd_boolean check_regions
)
5645 lang_statement_union_type
*s
;
5646 lang_statement_union_type
*prev_s
= NULL
;
5647 bfd_boolean removed_prev_s
= FALSE
;
5649 /* Size up the sections from their constituent parts. */
5650 for (s
= *prev
; s
!= NULL
; prev_s
= s
, s
= s
->header
.next
)
5652 bfd_boolean removed
=FALSE
;
5654 switch (s
->header
.type
)
5656 case lang_output_section_statement_enum
:
5658 bfd_vma newdot
, after
, dotdelta
;
5659 lang_output_section_statement_type
*os
;
5660 lang_memory_region_type
*r
;
5661 int section_alignment
= 0;
5663 os
= &s
->output_section_statement
;
5664 init_opb (os
->bfd_section
);
5665 if (os
->constraint
== -1)
5668 /* FIXME: We shouldn't need to zero section vmas for ld -r
5669 here, in lang_insert_orphan, or in the default linker scripts.
5670 This is covering for coff backend linker bugs. See PR6945. */
5671 if (os
->addr_tree
== NULL
5672 && bfd_link_relocatable (&link_info
)
5673 && (bfd_get_flavour (link_info
.output_bfd
)
5674 == bfd_target_coff_flavour
))
5675 os
->addr_tree
= exp_intop (0);
5676 if (os
->addr_tree
!= NULL
)
5678 os
->processed_vma
= FALSE
;
5679 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
5681 if (expld
.result
.valid_p
)
5683 dot
= expld
.result
.value
;
5684 if (expld
.result
.section
!= NULL
)
5685 dot
+= expld
.result
.section
->vma
;
5687 else if (expld
.phase
!= lang_mark_phase_enum
)
5688 einfo (_("%F%P:%pS: non constant or forward reference"
5689 " address expression for section %s\n"),
5690 os
->addr_tree
, os
->name
);
5693 if (os
->bfd_section
== NULL
)
5694 /* This section was removed or never actually created. */
5697 /* If this is a COFF shared library section, use the size and
5698 address from the input section. FIXME: This is COFF
5699 specific; it would be cleaner if there were some other way
5700 to do this, but nothing simple comes to mind. */
5701 if (((bfd_get_flavour (link_info
.output_bfd
)
5702 == bfd_target_ecoff_flavour
)
5703 || (bfd_get_flavour (link_info
.output_bfd
)
5704 == bfd_target_coff_flavour
))
5705 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
5709 if (os
->children
.head
== NULL
5710 || os
->children
.head
->header
.next
!= NULL
5711 || (os
->children
.head
->header
.type
5712 != lang_input_section_enum
))
5713 einfo (_("%X%P: internal error on COFF shared library"
5714 " section %s\n"), os
->name
);
5716 input
= os
->children
.head
->input_section
.section
;
5717 bfd_set_section_vma (os
->bfd_section
,
5718 bfd_section_vma (input
));
5719 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5720 os
->bfd_section
->size
= input
->size
;
5726 if (bfd_is_abs_section (os
->bfd_section
))
5728 /* No matter what happens, an abs section starts at zero. */
5729 ASSERT (os
->bfd_section
->vma
== 0);
5733 if (os
->addr_tree
== NULL
)
5735 /* No address specified for this section, get one
5736 from the region specification. */
5737 if (os
->region
== NULL
5738 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
5739 && os
->region
->name_list
.name
[0] == '*'
5740 && strcmp (os
->region
->name_list
.name
,
5741 DEFAULT_MEMORY_REGION
) == 0))
5743 os
->region
= lang_memory_default (os
->bfd_section
);
5746 /* If a loadable section is using the default memory
5747 region, and some non default memory regions were
5748 defined, issue an error message. */
5750 && !IGNORE_SECTION (os
->bfd_section
)
5751 && !bfd_link_relocatable (&link_info
)
5753 && strcmp (os
->region
->name_list
.name
,
5754 DEFAULT_MEMORY_REGION
) == 0
5755 && lang_memory_region_list
!= NULL
5756 && (strcmp (lang_memory_region_list
->name_list
.name
,
5757 DEFAULT_MEMORY_REGION
) != 0
5758 || lang_memory_region_list
->next
!= NULL
)
5759 && lang_sizing_iteration
== 1)
5761 /* By default this is an error rather than just a
5762 warning because if we allocate the section to the
5763 default memory region we can end up creating an
5764 excessively large binary, or even seg faulting when
5765 attempting to perform a negative seek. See
5766 sources.redhat.com/ml/binutils/2003-04/msg00423.html
5767 for an example of this. This behaviour can be
5768 overridden by the using the --no-check-sections
5770 if (command_line
.check_section_addresses
)
5771 einfo (_("%F%P: error: no memory region specified"
5772 " for loadable section `%s'\n"),
5773 bfd_section_name (os
->bfd_section
));
5775 einfo (_("%P: warning: no memory region specified"
5776 " for loadable section `%s'\n"),
5777 bfd_section_name (os
->bfd_section
));
5780 newdot
= os
->region
->current
;
5781 section_alignment
= os
->bfd_section
->alignment_power
;
5784 section_alignment
= exp_get_power (os
->section_alignment
,
5785 "section alignment");
5787 /* Align to what the section needs. */
5788 if (section_alignment
> 0)
5790 bfd_vma savedot
= newdot
;
5793 newdot
= align_power (newdot
, section_alignment
);
5794 dotdelta
= newdot
- savedot
;
5796 if (lang_sizing_iteration
== 1)
5798 else if (lang_sizing_iteration
> 1)
5800 /* Only report adjustments that would change
5801 alignment from what we have already reported. */
5802 diff
= newdot
- os
->bfd_section
->vma
;
5803 if (!(diff
& (((bfd_vma
) 1 << section_alignment
) - 1)))
5807 && (config
.warn_section_align
5808 || os
->addr_tree
!= NULL
))
5809 einfo (_("%P: warning: "
5810 "start of section %s changed by %ld\n"),
5811 os
->name
, (long) diff
);
5814 bfd_set_section_vma (os
->bfd_section
, newdot
);
5816 os
->bfd_section
->output_offset
= 0;
5819 lang_size_sections_1 (&os
->children
.head
, os
,
5820 os
->fill
, newdot
, relax
, check_regions
);
5822 os
->processed_vma
= TRUE
;
5824 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5825 /* Except for some special linker created sections,
5826 no output section should change from zero size
5827 after strip_excluded_output_sections. A non-zero
5828 size on an ignored section indicates that some
5829 input section was not sized early enough. */
5830 ASSERT (os
->bfd_section
->size
== 0);
5833 dot
= os
->bfd_section
->vma
;
5835 /* Put the section within the requested block size, or
5836 align at the block boundary. */
5838 + TO_ADDR (os
->bfd_section
->size
)
5839 + os
->block_value
- 1)
5840 & - (bfd_vma
) os
->block_value
);
5842 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5843 os
->bfd_section
->size
= TO_SIZE (after
5844 - os
->bfd_section
->vma
);
5847 /* Set section lma. */
5850 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
5854 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
5855 os
->bfd_section
->lma
= lma
;
5857 else if (os
->lma_region
!= NULL
)
5859 bfd_vma lma
= os
->lma_region
->current
;
5861 if (os
->align_lma_with_input
)
5865 /* When LMA_REGION is the same as REGION, align the LMA
5866 as we did for the VMA, possibly including alignment
5867 from the bfd section. If a different region, then
5868 only align according to the value in the output
5870 if (os
->lma_region
!= os
->region
)
5871 section_alignment
= exp_get_power (os
->section_alignment
,
5872 "section alignment");
5873 if (section_alignment
> 0)
5874 lma
= align_power (lma
, section_alignment
);
5876 os
->bfd_section
->lma
= lma
;
5878 else if (r
->last_os
!= NULL
5879 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5884 last
= r
->last_os
->output_section_statement
.bfd_section
;
5886 /* A backwards move of dot should be accompanied by
5887 an explicit assignment to the section LMA (ie.
5888 os->load_base set) because backwards moves can
5889 create overlapping LMAs. */
5891 && os
->bfd_section
->size
!= 0
5892 && dot
+ TO_ADDR (os
->bfd_section
->size
) <= last
->vma
)
5894 /* If dot moved backwards then leave lma equal to
5895 vma. This is the old default lma, which might
5896 just happen to work when the backwards move is
5897 sufficiently large. Nag if this changes anything,
5898 so people can fix their linker scripts. */
5900 if (last
->vma
!= last
->lma
)
5901 einfo (_("%P: warning: dot moved backwards "
5902 "before `%s'\n"), os
->name
);
5906 /* If this is an overlay, set the current lma to that
5907 at the end of the previous section. */
5908 if (os
->sectype
== overlay_section
)
5909 lma
= last
->lma
+ TO_ADDR (last
->size
);
5911 /* Otherwise, keep the same lma to vma relationship
5912 as the previous section. */
5914 lma
= os
->bfd_section
->vma
+ last
->lma
- last
->vma
;
5916 if (section_alignment
> 0)
5917 lma
= align_power (lma
, section_alignment
);
5918 os
->bfd_section
->lma
= lma
;
5921 os
->processed_lma
= TRUE
;
5923 /* Keep track of normal sections using the default
5924 lma region. We use this to set the lma for
5925 following sections. Overlays or other linker
5926 script assignment to lma might mean that the
5927 default lma == vma is incorrect.
5928 To avoid warnings about dot moving backwards when using
5929 -Ttext, don't start tracking sections until we find one
5930 of non-zero size or with lma set differently to vma.
5931 Do this tracking before we short-cut the loop so that we
5932 track changes for the case where the section size is zero,
5933 but the lma is set differently to the vma. This is
5934 important, if an orphan section is placed after an
5935 otherwise empty output section that has an explicit lma
5936 set, we want that lma reflected in the orphans lma. */
5937 if (((!IGNORE_SECTION (os
->bfd_section
)
5938 && (os
->bfd_section
->size
!= 0
5939 || (r
->last_os
== NULL
5940 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
5941 || (r
->last_os
!= NULL
5942 && dot
>= (r
->last_os
->output_section_statement
5943 .bfd_section
->vma
))))
5944 || os
->sectype
== first_overlay_section
)
5945 && os
->lma_region
== NULL
5946 && !bfd_link_relocatable (&link_info
))
5949 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5952 /* .tbss sections effectively have zero size. */
5953 if (!IS_TBSS (os
->bfd_section
)
5954 || bfd_link_relocatable (&link_info
))
5955 dotdelta
= TO_ADDR (os
->bfd_section
->size
);
5960 if (os
->update_dot_tree
!= 0)
5961 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5963 /* Update dot in the region ?
5964 We only do this if the section is going to be allocated,
5965 since unallocated sections do not contribute to the region's
5966 overall size in memory. */
5967 if (os
->region
!= NULL
5968 && (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)))
5970 os
->region
->current
= dot
;
5973 /* Make sure the new address is within the region. */
5974 os_region_check (os
, os
->region
, os
->addr_tree
,
5975 os
->bfd_section
->vma
);
5977 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
5978 && ((os
->bfd_section
->flags
& SEC_LOAD
)
5979 || os
->align_lma_with_input
))
5981 os
->lma_region
->current
= os
->bfd_section
->lma
+ dotdelta
;
5984 os_region_check (os
, os
->lma_region
, NULL
,
5985 os
->bfd_section
->lma
);
5991 case lang_constructors_statement_enum
:
5992 dot
= lang_size_sections_1 (&constructor_list
.head
,
5993 output_section_statement
,
5994 fill
, dot
, relax
, check_regions
);
5997 case lang_data_statement_enum
:
5999 unsigned int size
= 0;
6001 s
->data_statement
.output_offset
=
6002 dot
- output_section_statement
->bfd_section
->vma
;
6003 s
->data_statement
.output_section
=
6004 output_section_statement
->bfd_section
;
6006 /* We might refer to provided symbols in the expression, and
6007 need to mark them as needed. */
6008 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
6010 switch (s
->data_statement
.type
)
6028 if (size
< TO_SIZE ((unsigned) 1))
6029 size
= TO_SIZE ((unsigned) 1);
6030 dot
+= TO_ADDR (size
);
6031 if (!(output_section_statement
->bfd_section
->flags
6033 output_section_statement
->bfd_section
->size
6034 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
6039 case lang_reloc_statement_enum
:
6043 s
->reloc_statement
.output_offset
=
6044 dot
- output_section_statement
->bfd_section
->vma
;
6045 s
->reloc_statement
.output_section
=
6046 output_section_statement
->bfd_section
;
6047 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
6048 dot
+= TO_ADDR (size
);
6049 if (!(output_section_statement
->bfd_section
->flags
6051 output_section_statement
->bfd_section
->size
6052 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
6056 case lang_wild_statement_enum
:
6057 dot
= lang_size_sections_1 (&s
->wild_statement
.children
.head
,
6058 output_section_statement
,
6059 fill
, dot
, relax
, check_regions
);
6062 case lang_object_symbols_statement_enum
:
6063 link_info
.create_object_symbols_section
6064 = output_section_statement
->bfd_section
;
6065 output_section_statement
->bfd_section
->flags
|= SEC_KEEP
;
6068 case lang_output_statement_enum
:
6069 case lang_target_statement_enum
:
6072 case lang_input_section_enum
:
6076 i
= s
->input_section
.section
;
6081 if (!bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
6082 einfo (_("%F%P: can't relax section: %E\n"));
6086 dot
= size_input_section (prev
, output_section_statement
,
6087 fill
, &removed
, dot
);
6091 case lang_input_statement_enum
:
6094 case lang_fill_statement_enum
:
6095 s
->fill_statement
.output_section
=
6096 output_section_statement
->bfd_section
;
6098 fill
= s
->fill_statement
.fill
;
6101 case lang_assignment_statement_enum
:
6103 bfd_vma newdot
= dot
;
6104 etree_type
*tree
= s
->assignment_statement
.exp
;
6106 expld
.dataseg
.relro
= exp_seg_relro_none
;
6108 exp_fold_tree (tree
,
6109 output_section_statement
->bfd_section
,
6112 ldlang_check_relro_region (s
, &expld
.dataseg
);
6114 expld
.dataseg
.relro
= exp_seg_relro_none
;
6116 /* This symbol may be relative to this section. */
6117 if ((tree
->type
.node_class
== etree_provided
6118 || tree
->type
.node_class
== etree_assign
)
6119 && (tree
->assign
.dst
[0] != '.'
6120 || tree
->assign
.dst
[1] != '\0'))
6121 output_section_statement
->update_dot
= 1;
6123 if (!output_section_statement
->ignored
)
6125 if (output_section_statement
== abs_output_section
)
6127 /* If we don't have an output section, then just adjust
6128 the default memory address. */
6129 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
6130 FALSE
)->current
= newdot
;
6132 else if (newdot
!= dot
)
6134 /* Insert a pad after this statement. We can't
6135 put the pad before when relaxing, in case the
6136 assignment references dot. */
6137 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
6138 output_section_statement
->bfd_section
, dot
);
6140 /* Don't neuter the pad below when relaxing. */
6143 /* If dot is advanced, this implies that the section
6144 should have space allocated to it, unless the
6145 user has explicitly stated that the section
6146 should not be allocated. */
6147 if (output_section_statement
->sectype
!= noalloc_section
6148 && (output_section_statement
->sectype
!= noload_section
6149 || (bfd_get_flavour (link_info
.output_bfd
)
6150 == bfd_target_elf_flavour
)))
6151 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
6158 case lang_padding_statement_enum
:
6159 /* If this is the first time lang_size_sections is called,
6160 we won't have any padding statements. If this is the
6161 second or later passes when relaxing, we should allow
6162 padding to shrink. If padding is needed on this pass, it
6163 will be added back in. */
6164 s
->padding_statement
.size
= 0;
6166 /* Make sure output_offset is valid. If relaxation shrinks
6167 the section and this pad isn't needed, it's possible to
6168 have output_offset larger than the final size of the
6169 section. bfd_set_section_contents will complain even for
6170 a pad size of zero. */
6171 s
->padding_statement
.output_offset
6172 = dot
- output_section_statement
->bfd_section
->vma
;
6175 case lang_group_statement_enum
:
6176 dot
= lang_size_sections_1 (&s
->group_statement
.children
.head
,
6177 output_section_statement
,
6178 fill
, dot
, relax
, check_regions
);
6181 case lang_insert_statement_enum
:
6184 /* We can only get here when relaxing is turned on. */
6185 case lang_address_statement_enum
:
6193 /* If an input section doesn't fit in the current output
6194 section, remove it from the list. Handle the case where we
6195 have to remove an input_section statement here: there is a
6196 special case to remove the first element of the list. */
6197 if (link_info
.non_contiguous_regions
&& removed
)
6199 /* If we removed the first element during the previous
6200 iteration, override the loop assignment of prev_s. */
6206 /* If there was a real previous input section, just skip
6208 prev_s
->header
.next
=s
->header
.next
;
6210 removed_prev_s
= FALSE
;
6214 /* Remove the first input section of the list. */
6215 *prev
= s
->header
.next
;
6216 removed_prev_s
= TRUE
;
6219 /* Move to next element, unless we removed the head of the
6221 if (!removed_prev_s
)
6222 prev
= &s
->header
.next
;
6226 prev
= &s
->header
.next
;
6227 removed_prev_s
= FALSE
;
6233 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
6234 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
6235 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
6236 segments. We are allowed an opportunity to override this decision. */
6239 ldlang_override_segment_assignment (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6240 bfd
*abfd ATTRIBUTE_UNUSED
,
6241 asection
*current_section
,
6242 asection
*previous_section
,
6243 bfd_boolean new_segment
)
6245 lang_output_section_statement_type
*cur
;
6246 lang_output_section_statement_type
*prev
;
6248 /* The checks below are only necessary when the BFD library has decided
6249 that the two sections ought to be placed into the same segment. */
6253 /* Paranoia checks. */
6254 if (current_section
== NULL
|| previous_section
== NULL
)
6257 /* If this flag is set, the target never wants code and non-code
6258 sections comingled in the same segment. */
6259 if (config
.separate_code
6260 && ((current_section
->flags
^ previous_section
->flags
) & SEC_CODE
))
6263 /* Find the memory regions associated with the two sections.
6264 We call lang_output_section_find() here rather than scanning the list
6265 of output sections looking for a matching section pointer because if
6266 we have a large number of sections then a hash lookup is faster. */
6267 cur
= lang_output_section_find (current_section
->name
);
6268 prev
= lang_output_section_find (previous_section
->name
);
6270 /* More paranoia. */
6271 if (cur
== NULL
|| prev
== NULL
)
6274 /* If the regions are different then force the sections to live in
6275 different segments. See the email thread starting at the following
6276 URL for the reasons why this is necessary:
6277 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
6278 return cur
->region
!= prev
->region
;
6282 one_lang_size_sections_pass (bfd_boolean
*relax
, bfd_boolean check_regions
)
6284 lang_statement_iteration
++;
6285 if (expld
.phase
!= lang_mark_phase_enum
)
6286 lang_sizing_iteration
++;
6287 lang_size_sections_1 (&statement_list
.head
, abs_output_section
,
6288 0, 0, relax
, check_regions
);
6292 lang_size_segment (seg_align_type
*seg
)
6294 /* If XXX_SEGMENT_ALIGN XXX_SEGMENT_END pair was seen, check whether
6295 a page could be saved in the data segment. */
6296 bfd_vma first
, last
;
6298 first
= -seg
->base
& (seg
->pagesize
- 1);
6299 last
= seg
->end
& (seg
->pagesize
- 1);
6301 && ((seg
->base
& ~(seg
->pagesize
- 1))
6302 != (seg
->end
& ~(seg
->pagesize
- 1)))
6303 && first
+ last
<= seg
->pagesize
)
6305 seg
->phase
= exp_seg_adjust
;
6309 seg
->phase
= exp_seg_done
;
6314 lang_size_relro_segment_1 (seg_align_type
*seg
)
6316 bfd_vma relro_end
, desired_end
;
6319 /* Compute the expected PT_GNU_RELRO/PT_LOAD segment end. */
6320 relro_end
= ((seg
->relro_end
+ seg
->pagesize
- 1)
6321 & ~(seg
->pagesize
- 1));
6323 /* Adjust by the offset arg of XXX_SEGMENT_RELRO_END. */
6324 desired_end
= relro_end
- seg
->relro_offset
;
6326 /* For sections in the relro segment.. */
6327 for (sec
= link_info
.output_bfd
->section_last
; sec
; sec
= sec
->prev
)
6328 if ((sec
->flags
& SEC_ALLOC
) != 0
6329 && sec
->vma
>= seg
->base
6330 && sec
->vma
< seg
->relro_end
- seg
->relro_offset
)
6332 /* Where do we want to put this section so that it ends as
6334 bfd_vma start
, end
, bump
;
6336 end
= start
= sec
->vma
;
6338 end
+= TO_ADDR (sec
->size
);
6339 bump
= desired_end
- end
;
6340 /* We'd like to increase START by BUMP, but we must heed
6341 alignment so the increase might be less than optimum. */
6343 start
&= ~(((bfd_vma
) 1 << sec
->alignment_power
) - 1);
6344 /* This is now the desired end for the previous section. */
6345 desired_end
= start
;
6348 seg
->phase
= exp_seg_relro_adjust
;
6349 ASSERT (desired_end
>= seg
->base
);
6350 seg
->base
= desired_end
;
6355 lang_size_relro_segment (bfd_boolean
*relax
, bfd_boolean check_regions
)
6357 bfd_boolean do_reset
= FALSE
;
6358 bfd_boolean do_data_relro
;
6359 bfd_vma data_initial_base
, data_relro_end
;
6361 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
6363 do_data_relro
= TRUE
;
6364 data_initial_base
= expld
.dataseg
.base
;
6365 data_relro_end
= lang_size_relro_segment_1 (&expld
.dataseg
);
6369 do_data_relro
= FALSE
;
6370 data_initial_base
= data_relro_end
= 0;
6375 lang_reset_memory_regions ();
6376 one_lang_size_sections_pass (relax
, check_regions
);
6378 /* Assignments to dot, or to output section address in a user
6379 script have increased padding over the original. Revert. */
6380 if (do_data_relro
&& expld
.dataseg
.relro_end
> data_relro_end
)
6382 expld
.dataseg
.base
= data_initial_base
;;
6387 if (!do_data_relro
&& lang_size_segment (&expld
.dataseg
))
6394 lang_size_sections (bfd_boolean
*relax
, bfd_boolean check_regions
)
6396 expld
.phase
= lang_allocating_phase_enum
;
6397 expld
.dataseg
.phase
= exp_seg_none
;
6399 one_lang_size_sections_pass (relax
, check_regions
);
6401 if (expld
.dataseg
.phase
!= exp_seg_end_seen
)
6402 expld
.dataseg
.phase
= exp_seg_done
;
6404 if (expld
.dataseg
.phase
== exp_seg_end_seen
)
6406 bfd_boolean do_reset
6407 = lang_size_relro_segment (relax
, check_regions
);
6411 lang_reset_memory_regions ();
6412 one_lang_size_sections_pass (relax
, check_regions
);
6415 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
6417 link_info
.relro_start
= expld
.dataseg
.base
;
6418 link_info
.relro_end
= expld
.dataseg
.relro_end
;
6423 static lang_output_section_statement_type
*current_section
;
6424 static lang_assignment_statement_type
*current_assign
;
6425 static bfd_boolean prefer_next_section
;
6427 /* Worker function for lang_do_assignments. Recursiveness goes here. */
6430 lang_do_assignments_1 (lang_statement_union_type
*s
,
6431 lang_output_section_statement_type
*current_os
,
6434 bfd_boolean
*found_end
)
6436 for (; s
!= NULL
; s
= s
->header
.next
)
6438 switch (s
->header
.type
)
6440 case lang_constructors_statement_enum
:
6441 dot
= lang_do_assignments_1 (constructor_list
.head
,
6442 current_os
, fill
, dot
, found_end
);
6445 case lang_output_section_statement_enum
:
6447 lang_output_section_statement_type
*os
;
6450 os
= &(s
->output_section_statement
);
6451 os
->after_end
= *found_end
;
6452 init_opb (os
->bfd_section
);
6453 if (os
->bfd_section
!= NULL
&& !os
->ignored
)
6455 if ((os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
6457 current_section
= os
;
6458 prefer_next_section
= FALSE
;
6460 dot
= os
->bfd_section
->vma
;
6462 newdot
= lang_do_assignments_1 (os
->children
.head
,
6463 os
, os
->fill
, dot
, found_end
);
6466 if (os
->bfd_section
!= NULL
)
6468 /* .tbss sections effectively have zero size. */
6469 if (!IS_TBSS (os
->bfd_section
)
6470 || bfd_link_relocatable (&link_info
))
6471 dot
+= TO_ADDR (os
->bfd_section
->size
);
6473 if (os
->update_dot_tree
!= NULL
)
6474 exp_fold_tree (os
->update_dot_tree
,
6475 bfd_abs_section_ptr
, &dot
);
6483 case lang_wild_statement_enum
:
6485 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
6486 current_os
, fill
, dot
, found_end
);
6489 case lang_object_symbols_statement_enum
:
6490 case lang_output_statement_enum
:
6491 case lang_target_statement_enum
:
6494 case lang_data_statement_enum
:
6495 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
6496 if (expld
.result
.valid_p
)
6498 s
->data_statement
.value
= expld
.result
.value
;
6499 if (expld
.result
.section
!= NULL
)
6500 s
->data_statement
.value
+= expld
.result
.section
->vma
;
6502 else if (expld
.phase
== lang_final_phase_enum
)
6503 einfo (_("%F%P: invalid data statement\n"));
6506 switch (s
->data_statement
.type
)
6524 if (size
< TO_SIZE ((unsigned) 1))
6525 size
= TO_SIZE ((unsigned) 1);
6526 dot
+= TO_ADDR (size
);
6530 case lang_reloc_statement_enum
:
6531 exp_fold_tree (s
->reloc_statement
.addend_exp
,
6532 bfd_abs_section_ptr
, &dot
);
6533 if (expld
.result
.valid_p
)
6534 s
->reloc_statement
.addend_value
= expld
.result
.value
;
6535 else if (expld
.phase
== lang_final_phase_enum
)
6536 einfo (_("%F%P: invalid reloc statement\n"));
6537 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
6540 case lang_input_section_enum
:
6542 asection
*in
= s
->input_section
.section
;
6544 if ((in
->flags
& SEC_EXCLUDE
) == 0)
6545 dot
+= TO_ADDR (in
->size
);
6549 case lang_input_statement_enum
:
6552 case lang_fill_statement_enum
:
6553 fill
= s
->fill_statement
.fill
;
6556 case lang_assignment_statement_enum
:
6557 current_assign
= &s
->assignment_statement
;
6558 if (current_assign
->exp
->type
.node_class
!= etree_assert
)
6560 const char *p
= current_assign
->exp
->assign
.dst
;
6562 if (current_os
== abs_output_section
&& p
[0] == '.' && p
[1] == 0)
6563 prefer_next_section
= TRUE
;
6567 if (strcmp (p
, "end") == 0)
6570 exp_fold_tree (s
->assignment_statement
.exp
,
6571 (current_os
->bfd_section
!= NULL
6572 ? current_os
->bfd_section
: bfd_und_section_ptr
),
6576 case lang_padding_statement_enum
:
6577 dot
+= TO_ADDR (s
->padding_statement
.size
);
6580 case lang_group_statement_enum
:
6581 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
6582 current_os
, fill
, dot
, found_end
);
6585 case lang_insert_statement_enum
:
6588 case lang_address_statement_enum
:
6600 lang_do_assignments (lang_phase_type phase
)
6602 bfd_boolean found_end
= FALSE
;
6604 current_section
= NULL
;
6605 prefer_next_section
= FALSE
;
6606 expld
.phase
= phase
;
6607 lang_statement_iteration
++;
6608 lang_do_assignments_1 (statement_list
.head
,
6609 abs_output_section
, NULL
, 0, &found_end
);
6612 /* For an assignment statement outside of an output section statement,
6613 choose the best of neighbouring output sections to use for values
6617 section_for_dot (void)
6621 /* Assignments belong to the previous output section, unless there
6622 has been an assignment to "dot", in which case following
6623 assignments belong to the next output section. (The assumption
6624 is that an assignment to "dot" is setting up the address for the
6625 next output section.) Except that past the assignment to "_end"
6626 we always associate with the previous section. This exception is
6627 for targets like SH that define an alloc .stack or other
6628 weirdness after non-alloc sections. */
6629 if (current_section
== NULL
|| prefer_next_section
)
6631 lang_statement_union_type
*stmt
;
6632 lang_output_section_statement_type
*os
;
6634 for (stmt
= (lang_statement_union_type
*) current_assign
;
6636 stmt
= stmt
->header
.next
)
6637 if (stmt
->header
.type
== lang_output_section_statement_enum
)
6640 os
= &stmt
->output_section_statement
;
6643 && (os
->bfd_section
== NULL
6644 || (os
->bfd_section
->flags
& SEC_EXCLUDE
) != 0
6645 || bfd_section_removed_from_list (link_info
.output_bfd
,
6649 if (current_section
== NULL
|| os
== NULL
|| !os
->after_end
)
6652 s
= os
->bfd_section
;
6654 s
= link_info
.output_bfd
->section_last
;
6656 && ((s
->flags
& SEC_ALLOC
) == 0
6657 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6662 return bfd_abs_section_ptr
;
6666 s
= current_section
->bfd_section
;
6668 /* The section may have been stripped. */
6670 && ((s
->flags
& SEC_EXCLUDE
) != 0
6671 || (s
->flags
& SEC_ALLOC
) == 0
6672 || (s
->flags
& SEC_THREAD_LOCAL
) != 0
6673 || bfd_section_removed_from_list (link_info
.output_bfd
, s
)))
6676 s
= link_info
.output_bfd
->sections
;
6678 && ((s
->flags
& SEC_ALLOC
) == 0
6679 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6684 return bfd_abs_section_ptr
;
6687 /* Array of __start/__stop/.startof./.sizeof/ symbols. */
6689 static struct bfd_link_hash_entry
**start_stop_syms
;
6690 static size_t start_stop_count
= 0;
6691 static size_t start_stop_alloc
= 0;
6693 /* Give start/stop SYMBOL for SEC a preliminary definition, and add it
6694 to start_stop_syms. */
6697 lang_define_start_stop (const char *symbol
, asection
*sec
)
6699 struct bfd_link_hash_entry
*h
;
6701 h
= bfd_define_start_stop (link_info
.output_bfd
, &link_info
, symbol
, sec
);
6704 if (start_stop_count
== start_stop_alloc
)
6706 start_stop_alloc
= 2 * start_stop_alloc
+ 10;
6708 = xrealloc (start_stop_syms
,
6709 start_stop_alloc
* sizeof (*start_stop_syms
));
6711 start_stop_syms
[start_stop_count
++] = h
;
6715 /* Check for input sections whose names match references to
6716 __start_SECNAME or __stop_SECNAME symbols. Give the symbols
6717 preliminary definitions. */
6720 lang_init_start_stop (void)
6724 char leading_char
= bfd_get_symbol_leading_char (link_info
.output_bfd
);
6726 for (abfd
= link_info
.input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6727 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6730 const char *secname
= s
->name
;
6732 for (ps
= secname
; *ps
!= '\0'; ps
++)
6733 if (!ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
6737 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6739 symbol
[0] = leading_char
;
6740 sprintf (symbol
+ (leading_char
!= 0), "__start_%s", secname
);
6741 lang_define_start_stop (symbol
, s
);
6743 symbol
[1] = leading_char
;
6744 memcpy (symbol
+ 1 + (leading_char
!= 0), "__stop", 6);
6745 lang_define_start_stop (symbol
+ 1, s
);
6752 /* Iterate over start_stop_syms. */
6755 foreach_start_stop (void (*func
) (struct bfd_link_hash_entry
*))
6759 for (i
= 0; i
< start_stop_count
; ++i
)
6760 func (start_stop_syms
[i
]);
6763 /* __start and __stop symbols are only supposed to be defined by the
6764 linker for orphan sections, but we now extend that to sections that
6765 map to an output section of the same name. The symbols were
6766 defined early for --gc-sections, before we mapped input to output
6767 sections, so undo those that don't satisfy this rule. */
6770 undef_start_stop (struct bfd_link_hash_entry
*h
)
6772 if (h
->ldscript_def
)
6775 if (h
->u
.def
.section
->output_section
== NULL
6776 || h
->u
.def
.section
->output_section
->owner
!= link_info
.output_bfd
6777 || strcmp (h
->u
.def
.section
->name
,
6778 h
->u
.def
.section
->output_section
->name
) != 0)
6780 asection
*sec
= bfd_get_section_by_name (link_info
.output_bfd
,
6781 h
->u
.def
.section
->name
);
6784 /* When there are more than one input sections with the same
6785 section name, SECNAME, linker picks the first one to define
6786 __start_SECNAME and __stop_SECNAME symbols. When the first
6787 input section is removed by comdat group, we need to check
6788 if there is still an output section with section name
6791 for (i
= sec
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
6792 if (strcmp (h
->u
.def
.section
->name
, i
->name
) == 0)
6794 h
->u
.def
.section
= i
;
6798 h
->type
= bfd_link_hash_undefined
;
6799 h
->u
.undef
.abfd
= NULL
;
6804 lang_undef_start_stop (void)
6806 foreach_start_stop (undef_start_stop
);
6809 /* Check for output sections whose names match references to
6810 .startof.SECNAME or .sizeof.SECNAME symbols. Give the symbols
6811 preliminary definitions. */
6814 lang_init_startof_sizeof (void)
6818 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6820 const char *secname
= s
->name
;
6821 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6823 sprintf (symbol
, ".startof.%s", secname
);
6824 lang_define_start_stop (symbol
, s
);
6826 memcpy (symbol
+ 1, ".size", 5);
6827 lang_define_start_stop (symbol
+ 1, s
);
6832 /* Set .startof., .sizeof., __start and __stop symbols final values. */
6835 set_start_stop (struct bfd_link_hash_entry
*h
)
6838 || h
->type
!= bfd_link_hash_defined
)
6841 if (h
->root
.string
[0] == '.')
6843 /* .startof. or .sizeof. symbol.
6844 .startof. already has final value. */
6845 if (h
->root
.string
[2] == 'i')
6848 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6849 h
->u
.def
.section
= bfd_abs_section_ptr
;
6854 /* __start or __stop symbol. */
6855 int has_lead
= bfd_get_symbol_leading_char (link_info
.output_bfd
) != 0;
6857 h
->u
.def
.section
= h
->u
.def
.section
->output_section
;
6858 if (h
->root
.string
[4 + has_lead
] == 'o')
6861 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6867 lang_finalize_start_stop (void)
6869 foreach_start_stop (set_start_stop
);
6875 struct bfd_link_hash_entry
*h
;
6878 if ((bfd_link_relocatable (&link_info
) && !link_info
.gc_sections
)
6879 || bfd_link_dll (&link_info
))
6880 warn
= entry_from_cmdline
;
6884 /* Force the user to specify a root when generating a relocatable with
6885 --gc-sections, unless --gc-keep-exported was also given. */
6886 if (bfd_link_relocatable (&link_info
)
6887 && link_info
.gc_sections
6888 && !link_info
.gc_keep_exported
)
6890 struct bfd_sym_chain
*sym
;
6892 for (sym
= link_info
.gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
6894 h
= bfd_link_hash_lookup (link_info
.hash
, sym
->name
,
6895 FALSE
, FALSE
, FALSE
);
6897 && (h
->type
== bfd_link_hash_defined
6898 || h
->type
== bfd_link_hash_defweak
)
6899 && !bfd_is_const_section (h
->u
.def
.section
))
6903 einfo (_("%F%P: --gc-sections requires a defined symbol root "
6904 "specified by -e or -u\n"));
6907 if (entry_symbol
.name
== NULL
)
6909 /* No entry has been specified. Look for the default entry, but
6910 don't warn if we don't find it. */
6911 entry_symbol
.name
= entry_symbol_default
;
6915 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
6916 FALSE
, FALSE
, TRUE
);
6918 && (h
->type
== bfd_link_hash_defined
6919 || h
->type
== bfd_link_hash_defweak
)
6920 && h
->u
.def
.section
->output_section
!= NULL
)
6924 val
= (h
->u
.def
.value
6925 + bfd_section_vma (h
->u
.def
.section
->output_section
)
6926 + h
->u
.def
.section
->output_offset
);
6927 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6928 einfo (_("%F%P: %s: can't set start address\n"), entry_symbol
.name
);
6935 /* We couldn't find the entry symbol. Try parsing it as a
6937 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
6940 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6941 einfo (_("%F%P: can't set start address\n"));
6947 /* Can't find the entry symbol, and it's not a number. Use
6948 the first address in the text section. */
6949 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
6953 einfo (_("%P: warning: cannot find entry symbol %s;"
6954 " defaulting to %V\n"),
6956 bfd_section_vma (ts
));
6957 if (!bfd_set_start_address (link_info
.output_bfd
,
6958 bfd_section_vma (ts
)))
6959 einfo (_("%F%P: can't set start address\n"));
6964 einfo (_("%P: warning: cannot find entry symbol %s;"
6965 " not setting start address\n"),
6972 /* This is a small function used when we want to ignore errors from
6976 ignore_bfd_errors (const char *fmt ATTRIBUTE_UNUSED
,
6977 va_list ap ATTRIBUTE_UNUSED
)
6979 /* Don't do anything. */
6982 /* Check that the architecture of all the input files is compatible
6983 with the output file. Also call the backend to let it do any
6984 other checking that is needed. */
6989 lang_input_statement_type
*file
;
6991 const bfd_arch_info_type
*compatible
;
6993 for (file
= (void *) file_chain
.head
;
6997 #if BFD_SUPPORTS_PLUGINS
6998 /* Don't check format of files claimed by plugin. */
6999 if (file
->flags
.claimed
)
7001 #endif /* BFD_SUPPORTS_PLUGINS */
7002 input_bfd
= file
->the_bfd
;
7004 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
7005 command_line
.accept_unknown_input_arch
);
7007 /* In general it is not possible to perform a relocatable
7008 link between differing object formats when the input
7009 file has relocations, because the relocations in the
7010 input format may not have equivalent representations in
7011 the output format (and besides BFD does not translate
7012 relocs for other link purposes than a final link). */
7013 if (!file
->flags
.just_syms
7014 && (bfd_link_relocatable (&link_info
)
7015 || link_info
.emitrelocations
)
7016 && (compatible
== NULL
7017 || (bfd_get_flavour (input_bfd
)
7018 != bfd_get_flavour (link_info
.output_bfd
)))
7019 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
7021 einfo (_("%F%P: relocatable linking with relocations from"
7022 " format %s (%pB) to format %s (%pB) is not supported\n"),
7023 bfd_get_target (input_bfd
), input_bfd
,
7024 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
7025 /* einfo with %F exits. */
7028 if (compatible
== NULL
)
7030 if (command_line
.warn_mismatch
)
7031 einfo (_("%X%P: %s architecture of input file `%pB'"
7032 " is incompatible with %s output\n"),
7033 bfd_printable_name (input_bfd
), input_bfd
,
7034 bfd_printable_name (link_info
.output_bfd
));
7037 /* If the input bfd has no contents, it shouldn't set the
7038 private data of the output bfd. */
7039 else if (!file
->flags
.just_syms
7040 && ((input_bfd
->flags
& DYNAMIC
) != 0
7041 || bfd_count_sections (input_bfd
) != 0))
7043 bfd_error_handler_type pfn
= NULL
;
7045 /* If we aren't supposed to warn about mismatched input
7046 files, temporarily set the BFD error handler to a
7047 function which will do nothing. We still want to call
7048 bfd_merge_private_bfd_data, since it may set up
7049 information which is needed in the output file. */
7050 if (!command_line
.warn_mismatch
)
7051 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
7052 if (!bfd_merge_private_bfd_data (input_bfd
, &link_info
))
7054 if (command_line
.warn_mismatch
)
7055 einfo (_("%X%P: failed to merge target specific data"
7056 " of file %pB\n"), input_bfd
);
7058 if (!command_line
.warn_mismatch
)
7059 bfd_set_error_handler (pfn
);
7064 /* Look through all the global common symbols and attach them to the
7065 correct section. The -sort-common command line switch may be used
7066 to roughly sort the entries by alignment. */
7071 if (link_info
.inhibit_common_definition
)
7073 if (bfd_link_relocatable (&link_info
)
7074 && !command_line
.force_common_definition
)
7077 if (!config
.sort_common
)
7078 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
7083 if (config
.sort_common
== sort_descending
)
7085 for (power
= 4; power
> 0; power
--)
7086 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7089 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7093 for (power
= 0; power
<= 4; power
++)
7094 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7096 power
= (unsigned int) -1;
7097 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7102 /* Place one common symbol in the correct section. */
7105 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
7107 unsigned int power_of_two
;
7111 if (h
->type
!= bfd_link_hash_common
)
7115 power_of_two
= h
->u
.c
.p
->alignment_power
;
7117 if (config
.sort_common
== sort_descending
7118 && power_of_two
< *(unsigned int *) info
)
7120 else if (config
.sort_common
== sort_ascending
7121 && power_of_two
> *(unsigned int *) info
)
7124 section
= h
->u
.c
.p
->section
;
7125 if (!bfd_define_common_symbol (link_info
.output_bfd
, &link_info
, h
))
7126 einfo (_("%F%P: could not define common symbol `%pT': %E\n"),
7129 if (config
.map_file
!= NULL
)
7131 static bfd_boolean header_printed
;
7136 if (!header_printed
)
7138 minfo (_("\nAllocating common symbols\n"));
7139 minfo (_("Common symbol size file\n\n"));
7140 header_printed
= TRUE
;
7143 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
7144 DMGL_ANSI
| DMGL_PARAMS
);
7147 minfo ("%s", h
->root
.string
);
7148 len
= strlen (h
->root
.string
);
7153 len
= strlen (name
);
7169 if (size
<= 0xffffffff)
7170 sprintf (buf
, "%lx", (unsigned long) size
);
7172 sprintf_vma (buf
, size
);
7182 minfo ("%pB\n", section
->owner
);
7188 /* Handle a single orphan section S, placing the orphan into an appropriate
7189 output section. The effects of the --orphan-handling command line
7190 option are handled here. */
7193 ldlang_place_orphan (asection
*s
)
7195 if (config
.orphan_handling
== orphan_handling_discard
)
7197 lang_output_section_statement_type
*os
;
7198 os
= lang_output_section_statement_lookup (DISCARD_SECTION_NAME
, 0,
7200 if (os
->addr_tree
== NULL
7201 && (bfd_link_relocatable (&link_info
)
7202 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
7203 os
->addr_tree
= exp_intop (0);
7204 lang_add_section (&os
->children
, s
, NULL
, os
);
7208 lang_output_section_statement_type
*os
;
7209 const char *name
= s
->name
;
7212 if (config
.orphan_handling
== orphan_handling_error
)
7213 einfo (_("%X%P: error: unplaced orphan section `%pA' from `%pB'\n"),
7216 if (config
.unique_orphan_sections
|| unique_section_p (s
, NULL
))
7217 constraint
= SPECIAL
;
7219 os
= ldemul_place_orphan (s
, name
, constraint
);
7222 os
= lang_output_section_statement_lookup (name
, constraint
, TRUE
);
7223 if (os
->addr_tree
== NULL
7224 && (bfd_link_relocatable (&link_info
)
7225 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
7226 os
->addr_tree
= exp_intop (0);
7227 lang_add_section (&os
->children
, s
, NULL
, os
);
7230 if (config
.orphan_handling
== orphan_handling_warn
)
7231 einfo (_("%P: warning: orphan section `%pA' from `%pB' being "
7232 "placed in section `%s'\n"),
7233 s
, s
->owner
, os
->name
);
7237 /* Run through the input files and ensure that every input section has
7238 somewhere to go. If one is found without a destination then create
7239 an input request and place it into the statement tree. */
7242 lang_place_orphans (void)
7244 LANG_FOR_EACH_INPUT_STATEMENT (file
)
7248 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
7250 if (s
->output_section
== NULL
)
7252 /* This section of the file is not attached, root
7253 around for a sensible place for it to go. */
7255 if (file
->flags
.just_syms
)
7256 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
7257 else if (lang_discard_section_p (s
))
7258 s
->output_section
= bfd_abs_section_ptr
;
7259 else if (strcmp (s
->name
, "COMMON") == 0)
7261 /* This is a lonely common section which must have
7262 come from an archive. We attach to the section
7263 with the wildcard. */
7264 if (!bfd_link_relocatable (&link_info
)
7265 || command_line
.force_common_definition
)
7267 if (default_common_section
== NULL
)
7268 default_common_section
7269 = lang_output_section_statement_lookup (".bss", 0,
7271 lang_add_section (&default_common_section
->children
, s
,
7272 NULL
, default_common_section
);
7276 ldlang_place_orphan (s
);
7283 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
7285 flagword
*ptr_flags
;
7287 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
7293 /* PR 17900: An exclamation mark in the attributes reverses
7294 the sense of any of the attributes that follow. */
7297 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
7301 *ptr_flags
|= SEC_ALLOC
;
7305 *ptr_flags
|= SEC_READONLY
;
7309 *ptr_flags
|= SEC_DATA
;
7313 *ptr_flags
|= SEC_CODE
;
7318 *ptr_flags
|= SEC_LOAD
;
7322 einfo (_("%F%P: invalid character %c (%d) in flags\n"),
7330 /* Call a function on each real input file. This function will be
7331 called on an archive, but not on the elements. */
7334 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
7336 lang_input_statement_type
*f
;
7338 for (f
= (void *) input_file_chain
.head
;
7340 f
= f
->next_real_file
)
7345 /* Call a function on each real file. The function will be called on
7346 all the elements of an archive which are included in the link, but
7347 will not be called on the archive file itself. */
7350 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
7352 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7360 ldlang_add_file (lang_input_statement_type
*entry
)
7362 lang_statement_append (&file_chain
, entry
, &entry
->next
);
7364 /* The BFD linker needs to have a list of all input BFDs involved in
7366 ASSERT (link_info
.input_bfds_tail
!= &entry
->the_bfd
->link
.next
7367 && entry
->the_bfd
->link
.next
== NULL
);
7368 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
7370 *link_info
.input_bfds_tail
= entry
->the_bfd
;
7371 link_info
.input_bfds_tail
= &entry
->the_bfd
->link
.next
;
7372 bfd_set_usrdata (entry
->the_bfd
, entry
);
7373 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
7375 /* Look through the sections and check for any which should not be
7376 included in the link. We need to do this now, so that we can
7377 notice when the backend linker tries to report multiple
7378 definition errors for symbols which are in sections we aren't
7379 going to link. FIXME: It might be better to entirely ignore
7380 symbols which are defined in sections which are going to be
7381 discarded. This would require modifying the backend linker for
7382 each backend which might set the SEC_LINK_ONCE flag. If we do
7383 this, we should probably handle SEC_EXCLUDE in the same way. */
7385 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
7389 lang_add_output (const char *name
, int from_script
)
7391 /* Make -o on command line override OUTPUT in script. */
7392 if (!had_output_filename
|| !from_script
)
7394 output_filename
= name
;
7395 had_output_filename
= TRUE
;
7399 lang_output_section_statement_type
*
7400 lang_enter_output_section_statement (const char *output_section_statement_name
,
7401 etree_type
*address_exp
,
7402 enum section_type sectype
,
7404 etree_type
*subalign
,
7407 int align_with_input
)
7409 lang_output_section_statement_type
*os
;
7411 os
= lang_output_section_statement_lookup (output_section_statement_name
,
7413 current_section
= os
;
7415 if (os
->addr_tree
== NULL
)
7417 os
->addr_tree
= address_exp
;
7419 os
->sectype
= sectype
;
7420 if (sectype
!= noload_section
)
7421 os
->flags
= SEC_NO_FLAGS
;
7423 os
->flags
= SEC_NEVER_LOAD
;
7424 os
->block_value
= 1;
7426 /* Make next things chain into subchain of this. */
7427 push_stat_ptr (&os
->children
);
7429 os
->align_lma_with_input
= align_with_input
== ALIGN_WITH_INPUT
;
7430 if (os
->align_lma_with_input
&& align
!= NULL
)
7431 einfo (_("%F%P:%pS: error: align with input and explicit align specified\n"),
7434 os
->subsection_alignment
= subalign
;
7435 os
->section_alignment
= align
;
7437 os
->load_base
= ebase
;
7444 lang_output_statement_type
*new_stmt
;
7446 new_stmt
= new_stat (lang_output_statement
, stat_ptr
);
7447 new_stmt
->name
= output_filename
;
7450 /* Reset the current counters in the regions. */
7453 lang_reset_memory_regions (void)
7455 lang_memory_region_type
*p
= lang_memory_region_list
;
7457 lang_output_section_statement_type
*os
;
7459 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
7461 p
->current
= p
->origin
;
7465 for (os
= (void *) lang_os_list
.head
;
7469 os
->processed_vma
= FALSE
;
7470 os
->processed_lma
= FALSE
;
7473 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
7475 /* Save the last size for possible use by bfd_relax_section. */
7476 o
->rawsize
= o
->size
;
7477 if (!(o
->flags
& SEC_FIXED_SIZE
))
7482 /* Worker for lang_gc_sections_1. */
7485 gc_section_callback (lang_wild_statement_type
*ptr
,
7486 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7488 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
7489 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7490 void *data ATTRIBUTE_UNUSED
)
7492 /* If the wild pattern was marked KEEP, the member sections
7493 should be as well. */
7494 if (ptr
->keep_sections
)
7495 section
->flags
|= SEC_KEEP
;
7498 /* Iterate over sections marking them against GC. */
7501 lang_gc_sections_1 (lang_statement_union_type
*s
)
7503 for (; s
!= NULL
; s
= s
->header
.next
)
7505 switch (s
->header
.type
)
7507 case lang_wild_statement_enum
:
7508 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
7510 case lang_constructors_statement_enum
:
7511 lang_gc_sections_1 (constructor_list
.head
);
7513 case lang_output_section_statement_enum
:
7514 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
7516 case lang_group_statement_enum
:
7517 lang_gc_sections_1 (s
->group_statement
.children
.head
);
7526 lang_gc_sections (void)
7528 /* Keep all sections so marked in the link script. */
7529 lang_gc_sections_1 (statement_list
.head
);
7531 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
7532 the special case of debug info. (See bfd/stabs.c)
7533 Twiddle the flag here, to simplify later linker code. */
7534 if (bfd_link_relocatable (&link_info
))
7536 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7539 #if BFD_SUPPORTS_PLUGINS
7540 if (f
->flags
.claimed
)
7543 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7544 if ((sec
->flags
& SEC_DEBUGGING
) == 0)
7545 sec
->flags
&= ~SEC_EXCLUDE
;
7549 if (link_info
.gc_sections
)
7550 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
7553 /* Worker for lang_find_relro_sections_1. */
7556 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
7557 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7559 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
7560 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7563 /* Discarded, excluded and ignored sections effectively have zero
7565 if (section
->output_section
!= NULL
7566 && section
->output_section
->owner
== link_info
.output_bfd
7567 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
7568 && !IGNORE_SECTION (section
)
7569 && section
->size
!= 0)
7571 bfd_boolean
*has_relro_section
= (bfd_boolean
*) data
;
7572 *has_relro_section
= TRUE
;
7576 /* Iterate over sections for relro sections. */
7579 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
7580 seg_align_type
*seg
,
7581 bfd_boolean
*has_relro_section
)
7583 if (*has_relro_section
)
7586 for (; s
!= NULL
; s
= s
->header
.next
)
7588 if (s
== seg
->relro_end_stat
)
7591 switch (s
->header
.type
)
7593 case lang_wild_statement_enum
:
7594 walk_wild (&s
->wild_statement
,
7595 find_relro_section_callback
,
7598 case lang_constructors_statement_enum
:
7599 lang_find_relro_sections_1 (constructor_list
.head
,
7600 seg
, has_relro_section
);
7602 case lang_output_section_statement_enum
:
7603 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
7604 seg
, has_relro_section
);
7606 case lang_group_statement_enum
:
7607 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
7608 seg
, has_relro_section
);
7617 lang_find_relro_sections (void)
7619 bfd_boolean has_relro_section
= FALSE
;
7621 /* Check all sections in the link script. */
7623 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
7624 &expld
.dataseg
, &has_relro_section
);
7626 if (!has_relro_section
)
7627 link_info
.relro
= FALSE
;
7630 /* Relax all sections until bfd_relax_section gives up. */
7633 lang_relax_sections (bfd_boolean need_layout
)
7635 if (RELAXATION_ENABLED
)
7637 /* We may need more than one relaxation pass. */
7638 int i
= link_info
.relax_pass
;
7640 /* The backend can use it to determine the current pass. */
7641 link_info
.relax_pass
= 0;
7645 /* Keep relaxing until bfd_relax_section gives up. */
7646 bfd_boolean relax_again
;
7648 link_info
.relax_trip
= -1;
7651 link_info
.relax_trip
++;
7653 /* Note: pe-dll.c does something like this also. If you find
7654 you need to change this code, you probably need to change
7655 pe-dll.c also. DJ */
7657 /* Do all the assignments with our current guesses as to
7659 lang_do_assignments (lang_assigning_phase_enum
);
7661 /* We must do this after lang_do_assignments, because it uses
7663 lang_reset_memory_regions ();
7665 /* Perform another relax pass - this time we know where the
7666 globals are, so can make a better guess. */
7667 relax_again
= FALSE
;
7668 lang_size_sections (&relax_again
, FALSE
);
7670 while (relax_again
);
7672 link_info
.relax_pass
++;
7679 /* Final extra sizing to report errors. */
7680 lang_do_assignments (lang_assigning_phase_enum
);
7681 lang_reset_memory_regions ();
7682 lang_size_sections (NULL
, TRUE
);
7686 #if BFD_SUPPORTS_PLUGINS
7687 /* Find the insert point for the plugin's replacement files. We
7688 place them after the first claimed real object file, or if the
7689 first claimed object is an archive member, after the last real
7690 object file immediately preceding the archive. In the event
7691 no objects have been claimed at all, we return the first dummy
7692 object file on the list as the insert point; that works, but
7693 the callee must be careful when relinking the file_chain as it
7694 is not actually on that chain, only the statement_list and the
7695 input_file list; in that case, the replacement files must be
7696 inserted at the head of the file_chain. */
7698 static lang_input_statement_type
*
7699 find_replacements_insert_point (bfd_boolean
*before
)
7701 lang_input_statement_type
*claim1
, *lastobject
;
7702 lastobject
= (void *) input_file_chain
.head
;
7703 for (claim1
= (void *) file_chain
.head
;
7705 claim1
= claim1
->next
)
7707 if (claim1
->flags
.claimed
)
7709 *before
= claim1
->flags
.claim_archive
;
7710 return claim1
->flags
.claim_archive
? lastobject
: claim1
;
7712 /* Update lastobject if this is a real object file. */
7713 if (claim1
->the_bfd
!= NULL
&& claim1
->the_bfd
->my_archive
== NULL
)
7714 lastobject
= claim1
;
7716 /* No files were claimed by the plugin. Choose the last object
7717 file found on the list (maybe the first, dummy entry) as the
7723 /* Find where to insert ADD, an archive element or shared library
7724 added during a rescan. */
7726 static lang_input_statement_type
**
7727 find_rescan_insertion (lang_input_statement_type
*add
)
7729 bfd
*add_bfd
= add
->the_bfd
;
7730 lang_input_statement_type
*f
;
7731 lang_input_statement_type
*last_loaded
= NULL
;
7732 lang_input_statement_type
*before
= NULL
;
7733 lang_input_statement_type
**iter
= NULL
;
7735 if (add_bfd
->my_archive
!= NULL
)
7736 add_bfd
= add_bfd
->my_archive
;
7738 /* First look through the input file chain, to find an object file
7739 before the one we've rescanned. Normal object files always
7740 appear on both the input file chain and the file chain, so this
7741 lets us get quickly to somewhere near the correct place on the
7742 file chain if it is full of archive elements. Archives don't
7743 appear on the file chain, but if an element has been extracted
7744 then their input_statement->next points at it. */
7745 for (f
= (void *) input_file_chain
.head
;
7747 f
= f
->next_real_file
)
7749 if (f
->the_bfd
== add_bfd
)
7751 before
= last_loaded
;
7752 if (f
->next
!= NULL
)
7753 return &f
->next
->next
;
7755 if (f
->the_bfd
!= NULL
&& f
->next
!= NULL
)
7759 for (iter
= before
? &before
->next
: &file_chain
.head
->input_statement
.next
;
7761 iter
= &(*iter
)->next
)
7762 if (!(*iter
)->flags
.claim_archive
7763 && (*iter
)->the_bfd
->my_archive
== NULL
)
7769 /* Insert SRCLIST into DESTLIST after given element by chaining
7770 on FIELD as the next-pointer. (Counterintuitively does not need
7771 a pointer to the actual after-node itself, just its chain field.) */
7774 lang_list_insert_after (lang_statement_list_type
*destlist
,
7775 lang_statement_list_type
*srclist
,
7776 lang_statement_union_type
**field
)
7778 *(srclist
->tail
) = *field
;
7779 *field
= srclist
->head
;
7780 if (destlist
->tail
== field
)
7781 destlist
->tail
= srclist
->tail
;
7784 /* Detach new nodes added to DESTLIST since the time ORIGLIST
7785 was taken as a copy of it and leave them in ORIGLIST. */
7788 lang_list_remove_tail (lang_statement_list_type
*destlist
,
7789 lang_statement_list_type
*origlist
)
7791 union lang_statement_union
**savetail
;
7792 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
7793 ASSERT (origlist
->head
== destlist
->head
);
7794 savetail
= origlist
->tail
;
7795 origlist
->head
= *(savetail
);
7796 origlist
->tail
= destlist
->tail
;
7797 destlist
->tail
= savetail
;
7801 static lang_statement_union_type
**
7802 find_next_input_statement (lang_statement_union_type
**s
)
7804 for ( ; *s
; s
= &(*s
)->header
.next
)
7806 lang_statement_union_type
**t
;
7807 switch ((*s
)->header
.type
)
7809 case lang_input_statement_enum
:
7811 case lang_wild_statement_enum
:
7812 t
= &(*s
)->wild_statement
.children
.head
;
7814 case lang_group_statement_enum
:
7815 t
= &(*s
)->group_statement
.children
.head
;
7817 case lang_output_section_statement_enum
:
7818 t
= &(*s
)->output_section_statement
.children
.head
;
7823 t
= find_next_input_statement (t
);
7829 #endif /* BFD_SUPPORTS_PLUGINS */
7831 /* Add NAME to the list of garbage collection entry points. */
7834 lang_add_gc_name (const char *name
)
7836 struct bfd_sym_chain
*sym
;
7841 sym
= stat_alloc (sizeof (*sym
));
7843 sym
->next
= link_info
.gc_sym_list
;
7845 link_info
.gc_sym_list
= sym
;
7848 /* Check relocations. */
7851 lang_check_relocs (void)
7853 if (link_info
.check_relocs_after_open_input
)
7857 for (abfd
= link_info
.input_bfds
;
7858 abfd
!= (bfd
*) NULL
; abfd
= abfd
->link
.next
)
7859 if (!bfd_link_check_relocs (abfd
, &link_info
))
7861 /* No object output, fail return. */
7862 config
.make_executable
= FALSE
;
7863 /* Note: we do not abort the loop, but rather
7864 continue the scan in case there are other
7865 bad relocations to report. */
7870 /* Look through all output sections looking for places where we can
7871 propagate forward the lma region. */
7874 lang_propagate_lma_regions (void)
7876 lang_output_section_statement_type
*os
;
7878 for (os
= (void *) lang_os_list
.head
;
7882 if (os
->prev
!= NULL
7883 && os
->lma_region
== NULL
7884 && os
->load_base
== NULL
7885 && os
->addr_tree
== NULL
7886 && os
->region
== os
->prev
->region
)
7887 os
->lma_region
= os
->prev
->lma_region
;
7894 /* Finalize dynamic list. */
7895 if (link_info
.dynamic_list
)
7896 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
7898 current_target
= default_target
;
7900 /* Open the output file. */
7901 lang_for_each_statement (ldlang_open_output
);
7904 ldemul_create_output_section_statements ();
7906 /* Add to the hash table all undefineds on the command line. */
7907 lang_place_undefineds ();
7909 if (!bfd_section_already_linked_table_init ())
7910 einfo (_("%F%P: can not create hash table: %E\n"));
7912 /* A first pass through the memory regions ensures that if any region
7913 references a symbol for its origin or length then this symbol will be
7914 added to the symbol table. Having these symbols in the symbol table
7915 means that when we call open_input_bfds PROVIDE statements will
7916 trigger to provide any needed symbols. The regions origins and
7917 lengths are not assigned as a result of this call. */
7918 lang_do_memory_regions (FALSE
);
7920 /* Create a bfd for each input file. */
7921 current_target
= default_target
;
7922 lang_statement_iteration
++;
7923 open_input_bfds (statement_list
.head
, OPEN_BFD_NORMAL
);
7925 /* Now that open_input_bfds has processed assignments and provide
7926 statements we can give values to symbolic origin/length now. */
7927 lang_do_memory_regions (TRUE
);
7929 #if BFD_SUPPORTS_PLUGINS
7930 if (link_info
.lto_plugin_active
)
7932 lang_statement_list_type added
;
7933 lang_statement_list_type files
, inputfiles
;
7935 /* Now all files are read, let the plugin(s) decide if there
7936 are any more to be added to the link before we call the
7937 emulation's after_open hook. We create a private list of
7938 input statements for this purpose, which we will eventually
7939 insert into the global statement list after the first claimed
7942 /* We need to manipulate all three chains in synchrony. */
7944 inputfiles
= input_file_chain
;
7945 if (plugin_call_all_symbols_read ())
7946 einfo (_("%F%P: %s: plugin reported error after all symbols read\n"),
7947 plugin_error_plugin ());
7948 link_info
.lto_all_symbols_read
= TRUE
;
7949 /* Open any newly added files, updating the file chains. */
7950 plugin_undefs
= link_info
.hash
->undefs_tail
;
7951 open_input_bfds (*added
.tail
, OPEN_BFD_NORMAL
);
7952 if (plugin_undefs
== link_info
.hash
->undefs_tail
)
7953 plugin_undefs
= NULL
;
7954 /* Restore the global list pointer now they have all been added. */
7955 lang_list_remove_tail (stat_ptr
, &added
);
7956 /* And detach the fresh ends of the file lists. */
7957 lang_list_remove_tail (&file_chain
, &files
);
7958 lang_list_remove_tail (&input_file_chain
, &inputfiles
);
7959 /* Were any new files added? */
7960 if (added
.head
!= NULL
)
7962 /* If so, we will insert them into the statement list immediately
7963 after the first input file that was claimed by the plugin,
7964 unless that file was an archive in which case it is inserted
7965 immediately before. */
7967 lang_statement_union_type
**prev
;
7968 plugin_insert
= find_replacements_insert_point (&before
);
7969 /* If a plugin adds input files without having claimed any, we
7970 don't really have a good idea where to place them. Just putting
7971 them at the start or end of the list is liable to leave them
7972 outside the crtbegin...crtend range. */
7973 ASSERT (plugin_insert
!= NULL
);
7974 /* Splice the new statement list into the old one. */
7975 prev
= &plugin_insert
->header
.next
;
7978 prev
= find_next_input_statement (prev
);
7979 if (*prev
!= (void *) plugin_insert
->next_real_file
)
7981 /* We didn't find the expected input statement.
7982 Fall back to adding after plugin_insert. */
7983 prev
= &plugin_insert
->header
.next
;
7986 lang_list_insert_after (stat_ptr
, &added
, prev
);
7987 /* Likewise for the file chains. */
7988 lang_list_insert_after (&input_file_chain
, &inputfiles
,
7989 (void *) &plugin_insert
->next_real_file
);
7990 /* We must be careful when relinking file_chain; we may need to
7991 insert the new files at the head of the list if the insert
7992 point chosen is the dummy first input file. */
7993 if (plugin_insert
->filename
)
7994 lang_list_insert_after (&file_chain
, &files
,
7995 (void *) &plugin_insert
->next
);
7997 lang_list_insert_after (&file_chain
, &files
, &file_chain
.head
);
7999 /* Rescan archives in case new undefined symbols have appeared. */
8001 lang_statement_iteration
++;
8002 open_input_bfds (statement_list
.head
, OPEN_BFD_RESCAN
);
8003 lang_list_remove_tail (&file_chain
, &files
);
8004 while (files
.head
!= NULL
)
8006 lang_input_statement_type
**insert
;
8007 lang_input_statement_type
**iter
, *temp
;
8010 insert
= find_rescan_insertion (&files
.head
->input_statement
);
8011 /* All elements from an archive can be added at once. */
8012 iter
= &files
.head
->input_statement
.next
;
8013 my_arch
= files
.head
->input_statement
.the_bfd
->my_archive
;
8014 if (my_arch
!= NULL
)
8015 for (; *iter
!= NULL
; iter
= &(*iter
)->next
)
8016 if ((*iter
)->the_bfd
->my_archive
!= my_arch
)
8019 *insert
= &files
.head
->input_statement
;
8020 files
.head
= (lang_statement_union_type
*) *iter
;
8022 if (my_arch
!= NULL
)
8024 lang_input_statement_type
*parent
= bfd_usrdata (my_arch
);
8026 parent
->next
= (lang_input_statement_type
*)
8028 - offsetof (lang_input_statement_type
, next
));
8033 #endif /* BFD_SUPPORTS_PLUGINS */
8035 /* Make sure that nobody has tried to add a symbol to this list
8037 ASSERT (link_info
.gc_sym_list
== NULL
);
8039 link_info
.gc_sym_list
= &entry_symbol
;
8041 if (entry_symbol
.name
== NULL
)
8043 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
8045 /* entry_symbol is normally initialied by a ENTRY definition in the
8046 linker script or the -e command line option. But if neither of
8047 these have been used, the target specific backend may still have
8048 provided an entry symbol via a call to lang_default_entry().
8049 Unfortunately this value will not be processed until lang_end()
8050 is called, long after this function has finished. So detect this
8051 case here and add the target's entry symbol to the list of starting
8052 points for garbage collection resolution. */
8053 lang_add_gc_name (entry_symbol_default
);
8056 lang_add_gc_name (link_info
.init_function
);
8057 lang_add_gc_name (link_info
.fini_function
);
8059 ldemul_after_open ();
8060 if (config
.map_file
!= NULL
)
8061 lang_print_asneeded ();
8065 bfd_section_already_linked_table_free ();
8067 /* Make sure that we're not mixing architectures. We call this
8068 after all the input files have been opened, but before we do any
8069 other processing, so that any operations merge_private_bfd_data
8070 does on the output file will be known during the rest of the
8074 /* Handle .exports instead of a version script if we're told to do so. */
8075 if (command_line
.version_exports_section
)
8076 lang_do_version_exports_section ();
8078 /* Build all sets based on the information gathered from the input
8080 ldctor_build_sets ();
8082 /* Give initial values for __start and __stop symbols, so that ELF
8083 gc_sections will keep sections referenced by these symbols. Must
8084 be done before lang_do_assignments below. */
8085 if (config
.build_constructors
)
8086 lang_init_start_stop ();
8088 /* PR 13683: We must rerun the assignments prior to running garbage
8089 collection in order to make sure that all symbol aliases are resolved. */
8090 lang_do_assignments (lang_mark_phase_enum
);
8091 expld
.phase
= lang_first_phase_enum
;
8093 /* Size up the common data. */
8096 /* Remove unreferenced sections if asked to. */
8097 lang_gc_sections ();
8099 /* Check relocations. */
8100 lang_check_relocs ();
8102 ldemul_after_check_relocs ();
8104 /* Update wild statements. */
8105 update_wild_statements (statement_list
.head
);
8107 /* Run through the contours of the script and attach input sections
8108 to the correct output sections. */
8109 lang_statement_iteration
++;
8110 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
8112 /* Start at the statement immediately after the special abs_section
8113 output statement, so that it isn't reordered. */
8114 process_insert_statements (&lang_os_list
.head
->header
.next
);
8116 ldemul_before_place_orphans ();
8118 /* Find any sections not attached explicitly and handle them. */
8119 lang_place_orphans ();
8121 if (!bfd_link_relocatable (&link_info
))
8125 /* Merge SEC_MERGE sections. This has to be done after GC of
8126 sections, so that GCed sections are not merged, but before
8127 assigning dynamic symbols, since removing whole input sections
8129 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
8131 /* Look for a text section and set the readonly attribute in it. */
8132 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
8136 if (config
.text_read_only
)
8137 found
->flags
|= SEC_READONLY
;
8139 found
->flags
&= ~SEC_READONLY
;
8143 /* Merge together CTF sections. After this, only the symtab-dependent
8144 function and data object sections need adjustment. */
8147 /* Emit the CTF, iff the emulation doesn't need to do late emission after
8148 examining things laid out late, like the strtab. */
8151 /* Copy forward lma regions for output sections in same lma region. */
8152 lang_propagate_lma_regions ();
8154 /* Defining __start/__stop symbols early for --gc-sections to work
8155 around a glibc build problem can result in these symbols being
8156 defined when they should not be. Fix them now. */
8157 if (config
.build_constructors
)
8158 lang_undef_start_stop ();
8160 /* Define .startof./.sizeof. symbols with preliminary values before
8161 dynamic symbols are created. */
8162 if (!bfd_link_relocatable (&link_info
))
8163 lang_init_startof_sizeof ();
8165 /* Do anything special before sizing sections. This is where ELF
8166 and other back-ends size dynamic sections. */
8167 ldemul_before_allocation ();
8169 /* We must record the program headers before we try to fix the
8170 section positions, since they will affect SIZEOF_HEADERS. */
8171 lang_record_phdrs ();
8173 /* Check relro sections. */
8174 if (link_info
.relro
&& !bfd_link_relocatable (&link_info
))
8175 lang_find_relro_sections ();
8177 /* Size up the sections. */
8178 lang_size_sections (NULL
, !RELAXATION_ENABLED
);
8180 /* See if anything special should be done now we know how big
8181 everything is. This is where relaxation is done. */
8182 ldemul_after_allocation ();
8184 /* Fix any __start, __stop, .startof. or .sizeof. symbols. */
8185 lang_finalize_start_stop ();
8187 /* Do all the assignments again, to report errors. Assignment
8188 statements are processed multiple times, updating symbols; In
8189 open_input_bfds, lang_do_assignments, and lang_size_sections.
8190 Since lang_relax_sections calls lang_do_assignments, symbols are
8191 also updated in ldemul_after_allocation. */
8192 lang_do_assignments (lang_final_phase_enum
);
8196 /* Convert absolute symbols to section relative. */
8197 ldexp_finalize_syms ();
8199 /* Make sure that the section addresses make sense. */
8200 if (command_line
.check_section_addresses
)
8201 lang_check_section_addresses ();
8203 /* Check any required symbols are known. */
8204 ldlang_check_require_defined_symbols ();
8209 /* EXPORTED TO YACC */
8212 lang_add_wild (struct wildcard_spec
*filespec
,
8213 struct wildcard_list
*section_list
,
8214 bfd_boolean keep_sections
)
8216 struct wildcard_list
*curr
, *next
;
8217 lang_wild_statement_type
*new_stmt
;
8219 /* Reverse the list as the parser puts it back to front. */
8220 for (curr
= section_list
, section_list
= NULL
;
8222 section_list
= curr
, curr
= next
)
8225 curr
->next
= section_list
;
8228 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
8230 if (strcmp (filespec
->name
, "*") == 0)
8231 filespec
->name
= NULL
;
8232 else if (!wildcardp (filespec
->name
))
8233 lang_has_input_file
= TRUE
;
8236 new_stmt
= new_stat (lang_wild_statement
, stat_ptr
);
8237 new_stmt
->filename
= NULL
;
8238 new_stmt
->filenames_sorted
= FALSE
;
8239 new_stmt
->section_flag_list
= NULL
;
8240 new_stmt
->exclude_name_list
= NULL
;
8241 if (filespec
!= NULL
)
8243 new_stmt
->filename
= filespec
->name
;
8244 new_stmt
->filenames_sorted
= filespec
->sorted
== by_name
;
8245 new_stmt
->section_flag_list
= filespec
->section_flag_list
;
8246 new_stmt
->exclude_name_list
= filespec
->exclude_name_list
;
8248 new_stmt
->section_list
= section_list
;
8249 new_stmt
->keep_sections
= keep_sections
;
8250 lang_list_init (&new_stmt
->children
);
8251 analyze_walk_wild_section_handler (new_stmt
);
8255 lang_section_start (const char *name
, etree_type
*address
,
8256 const segment_type
*segment
)
8258 lang_address_statement_type
*ad
;
8260 ad
= new_stat (lang_address_statement
, stat_ptr
);
8261 ad
->section_name
= name
;
8262 ad
->address
= address
;
8263 ad
->segment
= segment
;
8266 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
8267 because of a -e argument on the command line, or zero if this is
8268 called by ENTRY in a linker script. Command line arguments take
8272 lang_add_entry (const char *name
, bfd_boolean cmdline
)
8274 if (entry_symbol
.name
== NULL
8276 || !entry_from_cmdline
)
8278 entry_symbol
.name
= name
;
8279 entry_from_cmdline
= cmdline
;
8283 /* Set the default start symbol to NAME. .em files should use this,
8284 not lang_add_entry, to override the use of "start" if neither the
8285 linker script nor the command line specifies an entry point. NAME
8286 must be permanently allocated. */
8288 lang_default_entry (const char *name
)
8290 entry_symbol_default
= name
;
8294 lang_add_target (const char *name
)
8296 lang_target_statement_type
*new_stmt
;
8298 new_stmt
= new_stat (lang_target_statement
, stat_ptr
);
8299 new_stmt
->target
= name
;
8303 lang_add_map (const char *name
)
8310 map_option_f
= TRUE
;
8318 lang_add_fill (fill_type
*fill
)
8320 lang_fill_statement_type
*new_stmt
;
8322 new_stmt
= new_stat (lang_fill_statement
, stat_ptr
);
8323 new_stmt
->fill
= fill
;
8327 lang_add_data (int type
, union etree_union
*exp
)
8329 lang_data_statement_type
*new_stmt
;
8331 new_stmt
= new_stat (lang_data_statement
, stat_ptr
);
8332 new_stmt
->exp
= exp
;
8333 new_stmt
->type
= type
;
8336 /* Create a new reloc statement. RELOC is the BFD relocation type to
8337 generate. HOWTO is the corresponding howto structure (we could
8338 look this up, but the caller has already done so). SECTION is the
8339 section to generate a reloc against, or NAME is the name of the
8340 symbol to generate a reloc against. Exactly one of SECTION and
8341 NAME must be NULL. ADDEND is an expression for the addend. */
8344 lang_add_reloc (bfd_reloc_code_real_type reloc
,
8345 reloc_howto_type
*howto
,
8348 union etree_union
*addend
)
8350 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
8354 p
->section
= section
;
8356 p
->addend_exp
= addend
;
8358 p
->addend_value
= 0;
8359 p
->output_section
= NULL
;
8360 p
->output_offset
= 0;
8363 lang_assignment_statement_type
*
8364 lang_add_assignment (etree_type
*exp
)
8366 lang_assignment_statement_type
*new_stmt
;
8368 new_stmt
= new_stat (lang_assignment_statement
, stat_ptr
);
8369 new_stmt
->exp
= exp
;
8374 lang_add_attribute (enum statement_enum attribute
)
8376 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
8380 lang_startup (const char *name
)
8382 if (first_file
->filename
!= NULL
)
8384 einfo (_("%F%P: multiple STARTUP files\n"));
8386 first_file
->filename
= name
;
8387 first_file
->local_sym_name
= name
;
8388 first_file
->flags
.real
= TRUE
;
8392 lang_float (bfd_boolean maybe
)
8394 lang_float_flag
= maybe
;
8398 /* Work out the load- and run-time regions from a script statement, and
8399 store them in *LMA_REGION and *REGION respectively.
8401 MEMSPEC is the name of the run-time region, or the value of
8402 DEFAULT_MEMORY_REGION if the statement didn't specify one.
8403 LMA_MEMSPEC is the name of the load-time region, or null if the
8404 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
8405 had an explicit load address.
8407 It is an error to specify both a load region and a load address. */
8410 lang_get_regions (lang_memory_region_type
**region
,
8411 lang_memory_region_type
**lma_region
,
8412 const char *memspec
,
8413 const char *lma_memspec
,
8414 bfd_boolean have_lma
,
8415 bfd_boolean have_vma
)
8417 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
8419 /* If no runtime region or VMA has been specified, but the load region
8420 has been specified, then use the load region for the runtime region
8422 if (lma_memspec
!= NULL
8424 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
8425 *region
= *lma_region
;
8427 *region
= lang_memory_region_lookup (memspec
, FALSE
);
8429 if (have_lma
&& lma_memspec
!= 0)
8430 einfo (_("%X%P:%pS: section has both a load address and a load region\n"),
8435 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
8436 lang_output_section_phdr_list
*phdrs
,
8437 const char *lma_memspec
)
8439 lang_get_regions (¤t_section
->region
,
8440 ¤t_section
->lma_region
,
8441 memspec
, lma_memspec
,
8442 current_section
->load_base
!= NULL
,
8443 current_section
->addr_tree
!= NULL
);
8445 current_section
->fill
= fill
;
8446 current_section
->phdrs
= phdrs
;
8450 /* Set the output format type. -oformat overrides scripts. */
8453 lang_add_output_format (const char *format
,
8458 if (output_target
== NULL
|| !from_script
)
8460 if (command_line
.endian
== ENDIAN_BIG
8463 else if (command_line
.endian
== ENDIAN_LITTLE
8467 output_target
= format
;
8472 lang_add_insert (const char *where
, int is_before
)
8474 lang_insert_statement_type
*new_stmt
;
8476 new_stmt
= new_stat (lang_insert_statement
, stat_ptr
);
8477 new_stmt
->where
= where
;
8478 new_stmt
->is_before
= is_before
;
8479 saved_script_handle
= previous_script_handle
;
8482 /* Enter a group. This creates a new lang_group_statement, and sets
8483 stat_ptr to build new statements within the group. */
8486 lang_enter_group (void)
8488 lang_group_statement_type
*g
;
8490 g
= new_stat (lang_group_statement
, stat_ptr
);
8491 lang_list_init (&g
->children
);
8492 push_stat_ptr (&g
->children
);
8495 /* Leave a group. This just resets stat_ptr to start writing to the
8496 regular list of statements again. Note that this will not work if
8497 groups can occur inside anything else which can adjust stat_ptr,
8498 but currently they can't. */
8501 lang_leave_group (void)
8506 /* Add a new program header. This is called for each entry in a PHDRS
8507 command in a linker script. */
8510 lang_new_phdr (const char *name
,
8512 bfd_boolean filehdr
,
8517 struct lang_phdr
*n
, **pp
;
8520 n
= stat_alloc (sizeof (struct lang_phdr
));
8523 n
->type
= exp_get_vma (type
, 0, "program header type");
8524 n
->filehdr
= filehdr
;
8529 hdrs
= n
->type
== 1 && (phdrs
|| filehdr
);
8531 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
8534 && !((*pp
)->filehdr
|| (*pp
)->phdrs
))
8536 einfo (_("%X%P:%pS: PHDRS and FILEHDR are not supported"
8537 " when prior PT_LOAD headers lack them\n"), NULL
);
8544 /* Record the program header information in the output BFD. FIXME: We
8545 should not be calling an ELF specific function here. */
8548 lang_record_phdrs (void)
8552 lang_output_section_phdr_list
*last
;
8553 struct lang_phdr
*l
;
8554 lang_output_section_statement_type
*os
;
8557 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
8560 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
8567 for (os
= (void *) lang_os_list
.head
;
8571 lang_output_section_phdr_list
*pl
;
8573 if (os
->constraint
< 0)
8581 if (os
->sectype
== noload_section
8582 || os
->bfd_section
== NULL
8583 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
8586 /* Don't add orphans to PT_INTERP header. */
8592 lang_output_section_statement_type
*tmp_os
;
8594 /* If we have not run across a section with a program
8595 header assigned to it yet, then scan forwards to find
8596 one. This prevents inconsistencies in the linker's
8597 behaviour when a script has specified just a single
8598 header and there are sections in that script which are
8599 not assigned to it, and which occur before the first
8600 use of that header. See here for more details:
8601 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
8602 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
8605 last
= tmp_os
->phdrs
;
8609 einfo (_("%F%P: no sections assigned to phdrs\n"));
8614 if (os
->bfd_section
== NULL
)
8617 for (; pl
!= NULL
; pl
= pl
->next
)
8619 if (strcmp (pl
->name
, l
->name
) == 0)
8624 secs
= (asection
**) xrealloc (secs
,
8625 alc
* sizeof (asection
*));
8627 secs
[c
] = os
->bfd_section
;
8634 if (l
->flags
== NULL
)
8637 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
8642 at
= exp_get_vma (l
->at
, 0, "phdr load address");
8644 if (!bfd_record_phdr (link_info
.output_bfd
, l
->type
,
8645 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
8646 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
8647 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
8652 /* Make sure all the phdr assignments succeeded. */
8653 for (os
= (void *) lang_os_list
.head
;
8657 lang_output_section_phdr_list
*pl
;
8659 if (os
->constraint
< 0
8660 || os
->bfd_section
== NULL
)
8663 for (pl
= os
->phdrs
;
8666 if (!pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
8667 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
8668 os
->name
, pl
->name
);
8672 /* Record a list of sections which may not be cross referenced. */
8675 lang_add_nocrossref (lang_nocrossref_type
*l
)
8677 struct lang_nocrossrefs
*n
;
8679 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
8680 n
->next
= nocrossref_list
;
8682 n
->onlyfirst
= FALSE
;
8683 nocrossref_list
= n
;
8685 /* Set notice_all so that we get informed about all symbols. */
8686 link_info
.notice_all
= TRUE
;
8689 /* Record a section that cannot be referenced from a list of sections. */
8692 lang_add_nocrossref_to (lang_nocrossref_type
*l
)
8694 lang_add_nocrossref (l
);
8695 nocrossref_list
->onlyfirst
= TRUE
;
8698 /* Overlay handling. We handle overlays with some static variables. */
8700 /* The overlay virtual address. */
8701 static etree_type
*overlay_vma
;
8702 /* And subsection alignment. */
8703 static etree_type
*overlay_subalign
;
8705 /* An expression for the maximum section size seen so far. */
8706 static etree_type
*overlay_max
;
8708 /* A list of all the sections in this overlay. */
8710 struct overlay_list
{
8711 struct overlay_list
*next
;
8712 lang_output_section_statement_type
*os
;
8715 static struct overlay_list
*overlay_list
;
8717 /* Start handling an overlay. */
8720 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
8722 /* The grammar should prevent nested overlays from occurring. */
8723 ASSERT (overlay_vma
== NULL
8724 && overlay_subalign
== NULL
8725 && overlay_max
== NULL
);
8727 overlay_vma
= vma_expr
;
8728 overlay_subalign
= subalign
;
8731 /* Start a section in an overlay. We handle this by calling
8732 lang_enter_output_section_statement with the correct VMA.
8733 lang_leave_overlay sets up the LMA and memory regions. */
8736 lang_enter_overlay_section (const char *name
)
8738 struct overlay_list
*n
;
8741 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
8742 0, overlay_subalign
, 0, 0, 0);
8744 /* If this is the first section, then base the VMA of future
8745 sections on this one. This will work correctly even if `.' is
8746 used in the addresses. */
8747 if (overlay_list
== NULL
)
8748 overlay_vma
= exp_nameop (ADDR
, name
);
8750 /* Remember the section. */
8751 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
8752 n
->os
= current_section
;
8753 n
->next
= overlay_list
;
8756 size
= exp_nameop (SIZEOF
, name
);
8758 /* Arrange to work out the maximum section end address. */
8759 if (overlay_max
== NULL
)
8762 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
8765 /* Finish a section in an overlay. There isn't any special to do
8769 lang_leave_overlay_section (fill_type
*fill
,
8770 lang_output_section_phdr_list
*phdrs
)
8777 name
= current_section
->name
;
8779 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
8780 region and that no load-time region has been specified. It doesn't
8781 really matter what we say here, since lang_leave_overlay will
8783 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
8785 /* Define the magic symbols. */
8787 clean
= (char *) xmalloc (strlen (name
) + 1);
8789 for (s1
= name
; *s1
!= '\0'; s1
++)
8790 if (ISALNUM (*s1
) || *s1
== '_')
8794 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_start_");
8795 sprintf (buf
, "__load_start_%s", clean
);
8796 lang_add_assignment (exp_provide (buf
,
8797 exp_nameop (LOADADDR
, name
),
8800 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_stop_");
8801 sprintf (buf
, "__load_stop_%s", clean
);
8802 lang_add_assignment (exp_provide (buf
,
8804 exp_nameop (LOADADDR
, name
),
8805 exp_nameop (SIZEOF
, name
)),
8811 /* Finish an overlay. If there are any overlay wide settings, this
8812 looks through all the sections in the overlay and sets them. */
8815 lang_leave_overlay (etree_type
*lma_expr
,
8818 const char *memspec
,
8819 lang_output_section_phdr_list
*phdrs
,
8820 const char *lma_memspec
)
8822 lang_memory_region_type
*region
;
8823 lang_memory_region_type
*lma_region
;
8824 struct overlay_list
*l
;
8825 lang_nocrossref_type
*nocrossref
;
8827 lang_get_regions (®ion
, &lma_region
,
8828 memspec
, lma_memspec
,
8829 lma_expr
!= NULL
, FALSE
);
8833 /* After setting the size of the last section, set '.' to end of the
8835 if (overlay_list
!= NULL
)
8837 overlay_list
->os
->update_dot
= 1;
8838 overlay_list
->os
->update_dot_tree
8839 = exp_assign (".", exp_binop ('+', overlay_vma
, overlay_max
), FALSE
);
8845 struct overlay_list
*next
;
8847 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
8850 l
->os
->region
= region
;
8851 l
->os
->lma_region
= lma_region
;
8853 /* The first section has the load address specified in the
8854 OVERLAY statement. The rest are worked out from that.
8855 The base address is not needed (and should be null) if
8856 an LMA region was specified. */
8859 l
->os
->load_base
= lma_expr
;
8860 l
->os
->sectype
= first_overlay_section
;
8862 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
8863 l
->os
->phdrs
= phdrs
;
8867 lang_nocrossref_type
*nc
;
8869 nc
= (lang_nocrossref_type
*) xmalloc (sizeof *nc
);
8870 nc
->name
= l
->os
->name
;
8871 nc
->next
= nocrossref
;
8880 if (nocrossref
!= NULL
)
8881 lang_add_nocrossref (nocrossref
);
8884 overlay_list
= NULL
;
8886 overlay_subalign
= NULL
;
8889 /* Version handling. This is only useful for ELF. */
8891 /* If PREV is NULL, return first version pattern matching particular symbol.
8892 If PREV is non-NULL, return first version pattern matching particular
8893 symbol after PREV (previously returned by lang_vers_match). */
8895 static struct bfd_elf_version_expr
*
8896 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
8897 struct bfd_elf_version_expr
*prev
,
8901 const char *cxx_sym
= sym
;
8902 const char *java_sym
= sym
;
8903 struct bfd_elf_version_expr
*expr
= NULL
;
8904 enum demangling_styles curr_style
;
8906 curr_style
= CURRENT_DEMANGLING_STYLE
;
8907 cplus_demangle_set_style (no_demangling
);
8908 c_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_NO_OPTS
);
8911 cplus_demangle_set_style (curr_style
);
8913 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8915 cxx_sym
= bfd_demangle (link_info
.output_bfd
, sym
,
8916 DMGL_PARAMS
| DMGL_ANSI
);
8920 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8922 java_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_JAVA
);
8927 if (head
->htab
&& (prev
== NULL
|| prev
->literal
))
8929 struct bfd_elf_version_expr e
;
8931 switch (prev
? prev
->mask
: 0)
8934 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
8937 expr
= (struct bfd_elf_version_expr
*)
8938 htab_find ((htab_t
) head
->htab
, &e
);
8939 while (expr
&& strcmp (expr
->pattern
, c_sym
) == 0)
8940 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
8946 case BFD_ELF_VERSION_C_TYPE
:
8947 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8949 e
.pattern
= cxx_sym
;
8950 expr
= (struct bfd_elf_version_expr
*)
8951 htab_find ((htab_t
) head
->htab
, &e
);
8952 while (expr
&& strcmp (expr
->pattern
, cxx_sym
) == 0)
8953 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
8959 case BFD_ELF_VERSION_CXX_TYPE
:
8960 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8962 e
.pattern
= java_sym
;
8963 expr
= (struct bfd_elf_version_expr
*)
8964 htab_find ((htab_t
) head
->htab
, &e
);
8965 while (expr
&& strcmp (expr
->pattern
, java_sym
) == 0)
8966 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8977 /* Finally, try the wildcards. */
8978 if (prev
== NULL
|| prev
->literal
)
8979 expr
= head
->remaining
;
8982 for (; expr
; expr
= expr
->next
)
8989 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
8992 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8994 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
8998 if (fnmatch (expr
->pattern
, s
, 0) == 0)
9004 free ((char *) c_sym
);
9006 free ((char *) cxx_sym
);
9007 if (java_sym
!= sym
)
9008 free ((char *) java_sym
);
9012 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
9013 return a pointer to the symbol name with any backslash quotes removed. */
9016 realsymbol (const char *pattern
)
9019 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
9020 char *s
, *symbol
= (char *) xmalloc (strlen (pattern
) + 1);
9022 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
9024 /* It is a glob pattern only if there is no preceding
9028 /* Remove the preceding backslash. */
9035 if (*p
== '?' || *p
== '*' || *p
== '[')
9042 backslash
= *p
== '\\';
9058 /* This is called for each variable name or match expression. NEW_NAME is
9059 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
9060 pattern to be matched against symbol names. */
9062 struct bfd_elf_version_expr
*
9063 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
9064 const char *new_name
,
9066 bfd_boolean literal_p
)
9068 struct bfd_elf_version_expr
*ret
;
9070 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
9074 ret
->literal
= TRUE
;
9075 ret
->pattern
= literal_p
? new_name
: realsymbol (new_name
);
9076 if (ret
->pattern
== NULL
)
9078 ret
->pattern
= new_name
;
9079 ret
->literal
= FALSE
;
9082 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
9083 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
9084 else if (strcasecmp (lang
, "C++") == 0)
9085 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
9086 else if (strcasecmp (lang
, "Java") == 0)
9087 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
9090 einfo (_("%X%P: unknown language `%s' in version information\n"),
9092 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
9095 return ldemul_new_vers_pattern (ret
);
9098 /* This is called for each set of variable names and match
9101 struct bfd_elf_version_tree
*
9102 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
9103 struct bfd_elf_version_expr
*locals
)
9105 struct bfd_elf_version_tree
*ret
;
9107 ret
= (struct bfd_elf_version_tree
*) xcalloc (1, sizeof *ret
);
9108 ret
->globals
.list
= globals
;
9109 ret
->locals
.list
= locals
;
9110 ret
->match
= lang_vers_match
;
9111 ret
->name_indx
= (unsigned int) -1;
9115 /* This static variable keeps track of version indices. */
9117 static int version_index
;
9120 version_expr_head_hash (const void *p
)
9122 const struct bfd_elf_version_expr
*e
=
9123 (const struct bfd_elf_version_expr
*) p
;
9125 return htab_hash_string (e
->pattern
);
9129 version_expr_head_eq (const void *p1
, const void *p2
)
9131 const struct bfd_elf_version_expr
*e1
=
9132 (const struct bfd_elf_version_expr
*) p1
;
9133 const struct bfd_elf_version_expr
*e2
=
9134 (const struct bfd_elf_version_expr
*) p2
;
9136 return strcmp (e1
->pattern
, e2
->pattern
) == 0;
9140 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
9143 struct bfd_elf_version_expr
*e
, *next
;
9144 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
9146 for (e
= head
->list
; e
; e
= e
->next
)
9150 head
->mask
|= e
->mask
;
9155 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
9156 version_expr_head_eq
, NULL
);
9157 list_loc
= &head
->list
;
9158 remaining_loc
= &head
->remaining
;
9159 for (e
= head
->list
; e
; e
= next
)
9165 remaining_loc
= &e
->next
;
9169 void **loc
= htab_find_slot ((htab_t
) head
->htab
, e
, INSERT
);
9173 struct bfd_elf_version_expr
*e1
, *last
;
9175 e1
= (struct bfd_elf_version_expr
*) *loc
;
9179 if (e1
->mask
== e
->mask
)
9187 while (e1
&& strcmp (e1
->pattern
, e
->pattern
) == 0);
9191 /* This is a duplicate. */
9192 /* FIXME: Memory leak. Sometimes pattern is not
9193 xmalloced alone, but in larger chunk of memory. */
9194 /* free (e->pattern); */
9199 e
->next
= last
->next
;
9207 list_loc
= &e
->next
;
9211 *remaining_loc
= NULL
;
9212 *list_loc
= head
->remaining
;
9215 head
->remaining
= head
->list
;
9218 /* This is called when we know the name and dependencies of the
9222 lang_register_vers_node (const char *name
,
9223 struct bfd_elf_version_tree
*version
,
9224 struct bfd_elf_version_deps
*deps
)
9226 struct bfd_elf_version_tree
*t
, **pp
;
9227 struct bfd_elf_version_expr
*e1
;
9232 if (link_info
.version_info
!= NULL
9233 && (name
[0] == '\0' || link_info
.version_info
->name
[0] == '\0'))
9235 einfo (_("%X%P: anonymous version tag cannot be combined"
9236 " with other version tags\n"));
9241 /* Make sure this node has a unique name. */
9242 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9243 if (strcmp (t
->name
, name
) == 0)
9244 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
9246 lang_finalize_version_expr_head (&version
->globals
);
9247 lang_finalize_version_expr_head (&version
->locals
);
9249 /* Check the global and local match names, and make sure there
9250 aren't any duplicates. */
9252 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
9254 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9256 struct bfd_elf_version_expr
*e2
;
9258 if (t
->locals
.htab
&& e1
->literal
)
9260 e2
= (struct bfd_elf_version_expr
*)
9261 htab_find ((htab_t
) t
->locals
.htab
, e1
);
9262 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
9264 if (e1
->mask
== e2
->mask
)
9265 einfo (_("%X%P: duplicate expression `%s'"
9266 " in version information\n"), e1
->pattern
);
9270 else if (!e1
->literal
)
9271 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
9272 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
9273 && e1
->mask
== e2
->mask
)
9274 einfo (_("%X%P: duplicate expression `%s'"
9275 " in version information\n"), e1
->pattern
);
9279 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
9281 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9283 struct bfd_elf_version_expr
*e2
;
9285 if (t
->globals
.htab
&& e1
->literal
)
9287 e2
= (struct bfd_elf_version_expr
*)
9288 htab_find ((htab_t
) t
->globals
.htab
, e1
);
9289 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
9291 if (e1
->mask
== e2
->mask
)
9292 einfo (_("%X%P: duplicate expression `%s'"
9293 " in version information\n"),
9298 else if (!e1
->literal
)
9299 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
9300 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
9301 && e1
->mask
== e2
->mask
)
9302 einfo (_("%X%P: duplicate expression `%s'"
9303 " in version information\n"), e1
->pattern
);
9307 version
->deps
= deps
;
9308 version
->name
= name
;
9309 if (name
[0] != '\0')
9312 version
->vernum
= version_index
;
9315 version
->vernum
= 0;
9317 for (pp
= &link_info
.version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
9322 /* This is called when we see a version dependency. */
9324 struct bfd_elf_version_deps
*
9325 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
9327 struct bfd_elf_version_deps
*ret
;
9328 struct bfd_elf_version_tree
*t
;
9330 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
9333 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9335 if (strcmp (t
->name
, name
) == 0)
9337 ret
->version_needed
= t
;
9342 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
9344 ret
->version_needed
= NULL
;
9349 lang_do_version_exports_section (void)
9351 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
9353 LANG_FOR_EACH_INPUT_STATEMENT (is
)
9355 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
9363 contents
= (char *) xmalloc (len
);
9364 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
9365 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
9368 while (p
< contents
+ len
)
9370 greg
= lang_new_vers_pattern (greg
, p
, NULL
, FALSE
);
9371 p
= strchr (p
, '\0') + 1;
9374 /* Do not free the contents, as we used them creating the regex. */
9376 /* Do not include this section in the link. */
9377 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
9380 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, FALSE
);
9381 lang_register_vers_node (command_line
.version_exports_section
,
9382 lang_new_vers_node (greg
, lreg
), NULL
);
9385 /* Evaluate LENGTH and ORIGIN parts of MEMORY spec. This is initially
9386 called with UPDATE_REGIONS_P set to FALSE, in this case no errors are
9387 thrown, however, references to symbols in the origin and length fields
9388 will be pushed into the symbol table, this allows PROVIDE statements to
9389 then provide these symbols. This function is called a second time with
9390 UPDATE_REGIONS_P set to TRUE, this time the we update the actual region
9391 data structures, and throw errors if missing symbols are encountered. */
9394 lang_do_memory_regions (bfd_boolean update_regions_p
)
9396 lang_memory_region_type
*r
= lang_memory_region_list
;
9398 for (; r
!= NULL
; r
= r
->next
)
9402 exp_fold_tree_no_dot (r
->origin_exp
);
9403 if (update_regions_p
)
9405 if (expld
.result
.valid_p
)
9407 r
->origin
= expld
.result
.value
;
9408 r
->current
= r
->origin
;
9411 einfo (_("%P: invalid origin for memory region %s\n"),
9417 exp_fold_tree_no_dot (r
->length_exp
);
9418 if (update_regions_p
)
9420 if (expld
.result
.valid_p
)
9421 r
->length
= expld
.result
.value
;
9423 einfo (_("%P: invalid length for memory region %s\n"),
9431 lang_add_unique (const char *name
)
9433 struct unique_sections
*ent
;
9435 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
9436 if (strcmp (ent
->name
, name
) == 0)
9439 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
9440 ent
->name
= xstrdup (name
);
9441 ent
->next
= unique_section_list
;
9442 unique_section_list
= ent
;
9445 /* Append the list of dynamic symbols to the existing one. */
9448 lang_append_dynamic_list (struct bfd_elf_dynamic_list
**list_p
,
9449 struct bfd_elf_version_expr
*dynamic
)
9453 struct bfd_elf_version_expr
*tail
;
9454 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
9456 tail
->next
= (*list_p
)->head
.list
;
9457 (*list_p
)->head
.list
= dynamic
;
9461 struct bfd_elf_dynamic_list
*d
;
9463 d
= (struct bfd_elf_dynamic_list
*) xcalloc (1, sizeof *d
);
9464 d
->head
.list
= dynamic
;
9465 d
->match
= lang_vers_match
;
9470 /* Append the list of C++ typeinfo dynamic symbols to the existing
9474 lang_append_dynamic_list_cpp_typeinfo (void)
9476 const char *symbols
[] =
9478 "typeinfo name for*",
9481 struct bfd_elf_version_expr
*dynamic
= NULL
;
9484 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9485 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9488 lang_append_dynamic_list (&link_info
.dynamic_list
, dynamic
);
9491 /* Append the list of C++ operator new and delete dynamic symbols to the
9495 lang_append_dynamic_list_cpp_new (void)
9497 const char *symbols
[] =
9502 struct bfd_elf_version_expr
*dynamic
= NULL
;
9505 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9506 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9509 lang_append_dynamic_list (&link_info
.dynamic_list
, dynamic
);
9512 /* Scan a space and/or comma separated string of features. */
9515 lang_ld_feature (char *str
)
9523 while (*p
== ',' || ISSPACE (*p
))
9528 while (*q
&& *q
!= ',' && !ISSPACE (*q
))
9532 if (strcasecmp (p
, "SANE_EXPR") == 0)
9533 config
.sane_expr
= TRUE
;
9535 einfo (_("%X%P: unknown feature `%s'\n"), p
);
9541 /* Pretty print memory amount. */
9544 lang_print_memory_size (bfd_vma sz
)
9546 if ((sz
& 0x3fffffff) == 0)
9547 printf ("%10" BFD_VMA_FMT
"u GB", sz
>> 30);
9548 else if ((sz
& 0xfffff) == 0)
9549 printf ("%10" BFD_VMA_FMT
"u MB", sz
>> 20);
9550 else if ((sz
& 0x3ff) == 0)
9551 printf ("%10" BFD_VMA_FMT
"u KB", sz
>> 10);
9553 printf (" %10" BFD_VMA_FMT
"u B", sz
);
9556 /* Implement --print-memory-usage: disply per region memory usage. */
9559 lang_print_memory_usage (void)
9561 lang_memory_region_type
*r
;
9563 printf ("Memory region Used Size Region Size %%age Used\n");
9564 for (r
= lang_memory_region_list
; r
->next
!= NULL
; r
= r
->next
)
9566 bfd_vma used_length
= r
->current
- r
->origin
;
9568 printf ("%16s: ",r
->name_list
.name
);
9569 lang_print_memory_size (used_length
);
9570 lang_print_memory_size ((bfd_vma
) r
->length
);
9574 double percent
= used_length
* 100.0 / r
->length
;
9575 printf (" %6.2f%%", percent
);