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, 1);
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 is 0 return NULL when
1468 no match exists. If CREATE is 1, create an output_section_statement
1469 when no match exists or if CONSTRAINT is SPECIAL. If CREATE is 2,
1470 always make a new output_section_statement. */
1472 lang_output_section_statement_type
*
1473 lang_output_section_statement_lookup (const char *name
,
1477 struct out_section_hash_entry
*entry
;
1479 entry
= ((struct out_section_hash_entry
*)
1480 bfd_hash_lookup (&output_section_statement_table
, name
,
1481 create
!= 0, FALSE
));
1485 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1489 if (entry
->s
.output_section_statement
.name
!= NULL
)
1491 /* We have a section of this name, but it might not have the correct
1493 struct out_section_hash_entry
*last_ent
;
1495 name
= entry
->s
.output_section_statement
.name
;
1499 && !(create
&& constraint
== SPECIAL
)
1500 && (constraint
== entry
->s
.output_section_statement
.constraint
1502 && entry
->s
.output_section_statement
.constraint
>= 0)))
1503 return &entry
->s
.output_section_statement
;
1505 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1507 while (entry
!= NULL
1508 && name
== entry
->s
.output_section_statement
.name
);
1514 = ((struct out_section_hash_entry
*)
1515 output_section_statement_newfunc (NULL
,
1516 &output_section_statement_table
,
1520 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1523 entry
->root
= last_ent
->root
;
1524 last_ent
->root
.next
= &entry
->root
;
1527 entry
->s
.output_section_statement
.name
= name
;
1528 entry
->s
.output_section_statement
.constraint
= constraint
;
1529 return &entry
->s
.output_section_statement
;
1532 /* Find the next output_section_statement with the same name as OS.
1533 If CONSTRAINT is non-zero, find one with that constraint otherwise
1534 match any non-negative constraint. */
1536 lang_output_section_statement_type
*
1537 next_matching_output_section_statement (lang_output_section_statement_type
*os
,
1540 /* All output_section_statements are actually part of a
1541 struct out_section_hash_entry. */
1542 struct out_section_hash_entry
*entry
= (struct out_section_hash_entry
*)
1544 - offsetof (struct out_section_hash_entry
, s
.output_section_statement
));
1545 const char *name
= os
->name
;
1547 ASSERT (name
== entry
->root
.string
);
1550 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1552 || name
!= entry
->s
.output_section_statement
.name
)
1555 while (constraint
!= entry
->s
.output_section_statement
.constraint
1557 || entry
->s
.output_section_statement
.constraint
< 0));
1559 return &entry
->s
.output_section_statement
;
1562 /* A variant of lang_output_section_find used by place_orphan.
1563 Returns the output statement that should precede a new output
1564 statement for SEC. If an exact match is found on certain flags,
1567 lang_output_section_statement_type
*
1568 lang_output_section_find_by_flags (const asection
*sec
,
1570 lang_output_section_statement_type
**exact
,
1571 lang_match_sec_type_func match_type
)
1573 lang_output_section_statement_type
*first
, *look
, *found
;
1574 flagword look_flags
, differ
;
1576 /* We know the first statement on this list is *ABS*. May as well
1578 first
= (void *) lang_os_list
.head
;
1579 first
= first
->next
;
1581 /* First try for an exact match. */
1583 for (look
= first
; look
; look
= look
->next
)
1585 look_flags
= look
->flags
;
1586 if (look
->bfd_section
!= NULL
)
1588 look_flags
= look
->bfd_section
->flags
;
1589 if (match_type
&& !match_type (link_info
.output_bfd
,
1594 differ
= look_flags
^ sec_flags
;
1595 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1596 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1606 if ((sec_flags
& SEC_CODE
) != 0
1607 && (sec_flags
& SEC_ALLOC
) != 0)
1609 /* Try for a rw code section. */
1610 for (look
= first
; look
; look
= look
->next
)
1612 look_flags
= look
->flags
;
1613 if (look
->bfd_section
!= NULL
)
1615 look_flags
= look
->bfd_section
->flags
;
1616 if (match_type
&& !match_type (link_info
.output_bfd
,
1621 differ
= look_flags
^ sec_flags
;
1622 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1623 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1627 else if ((sec_flags
& SEC_READONLY
) != 0
1628 && (sec_flags
& SEC_ALLOC
) != 0)
1630 /* .rodata can go after .text, .sdata2 after .rodata. */
1631 for (look
= first
; look
; look
= look
->next
)
1633 look_flags
= look
->flags
;
1634 if (look
->bfd_section
!= NULL
)
1636 look_flags
= look
->bfd_section
->flags
;
1637 if (match_type
&& !match_type (link_info
.output_bfd
,
1642 differ
= look_flags
^ sec_flags
;
1643 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1644 | SEC_READONLY
| SEC_SMALL_DATA
))
1645 || (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1647 && !(look_flags
& SEC_SMALL_DATA
)))
1651 else if ((sec_flags
& SEC_THREAD_LOCAL
) != 0
1652 && (sec_flags
& SEC_ALLOC
) != 0)
1654 /* .tdata can go after .data, .tbss after .tdata. Treat .tbss
1655 as if it were a loaded section, and don't use match_type. */
1656 bfd_boolean seen_thread_local
= FALSE
;
1659 for (look
= first
; look
; look
= look
->next
)
1661 look_flags
= look
->flags
;
1662 if (look
->bfd_section
!= NULL
)
1663 look_flags
= look
->bfd_section
->flags
;
1665 differ
= look_flags
^ (sec_flags
| SEC_LOAD
| SEC_HAS_CONTENTS
);
1666 if (!(differ
& (SEC_THREAD_LOCAL
| SEC_ALLOC
)))
1668 /* .tdata and .tbss must be adjacent and in that order. */
1669 if (!(look_flags
& SEC_LOAD
)
1670 && (sec_flags
& SEC_LOAD
))
1671 /* ..so if we're at a .tbss section and we're placing
1672 a .tdata section stop looking and return the
1673 previous section. */
1676 seen_thread_local
= TRUE
;
1678 else if (seen_thread_local
)
1680 else if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
)))
1684 else if ((sec_flags
& SEC_SMALL_DATA
) != 0
1685 && (sec_flags
& SEC_ALLOC
) != 0)
1687 /* .sdata goes after .data, .sbss after .sdata. */
1688 for (look
= first
; look
; look
= look
->next
)
1690 look_flags
= look
->flags
;
1691 if (look
->bfd_section
!= NULL
)
1693 look_flags
= look
->bfd_section
->flags
;
1694 if (match_type
&& !match_type (link_info
.output_bfd
,
1699 differ
= look_flags
^ sec_flags
;
1700 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1701 | SEC_THREAD_LOCAL
))
1702 || ((look_flags
& SEC_SMALL_DATA
)
1703 && !(sec_flags
& SEC_HAS_CONTENTS
)))
1707 else if ((sec_flags
& SEC_HAS_CONTENTS
) != 0
1708 && (sec_flags
& SEC_ALLOC
) != 0)
1710 /* .data goes after .rodata. */
1711 for (look
= first
; look
; look
= look
->next
)
1713 look_flags
= look
->flags
;
1714 if (look
->bfd_section
!= NULL
)
1716 look_flags
= look
->bfd_section
->flags
;
1717 if (match_type
&& !match_type (link_info
.output_bfd
,
1722 differ
= look_flags
^ sec_flags
;
1723 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1724 | SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1728 else if ((sec_flags
& SEC_ALLOC
) != 0)
1730 /* .bss goes after any other alloc section. */
1731 for (look
= first
; look
; look
= look
->next
)
1733 look_flags
= look
->flags
;
1734 if (look
->bfd_section
!= NULL
)
1736 look_flags
= look
->bfd_section
->flags
;
1737 if (match_type
&& !match_type (link_info
.output_bfd
,
1742 differ
= look_flags
^ sec_flags
;
1743 if (!(differ
& SEC_ALLOC
))
1749 /* non-alloc go last. */
1750 for (look
= first
; look
; look
= look
->next
)
1752 look_flags
= look
->flags
;
1753 if (look
->bfd_section
!= NULL
)
1754 look_flags
= look
->bfd_section
->flags
;
1755 differ
= look_flags
^ sec_flags
;
1756 if (!(differ
& SEC_DEBUGGING
))
1762 if (found
|| !match_type
)
1765 return lang_output_section_find_by_flags (sec
, sec_flags
, NULL
, NULL
);
1768 /* Find the last output section before given output statement.
1769 Used by place_orphan. */
1772 output_prev_sec_find (lang_output_section_statement_type
*os
)
1774 lang_output_section_statement_type
*lookup
;
1776 for (lookup
= os
->prev
; lookup
!= NULL
; lookup
= lookup
->prev
)
1778 if (lookup
->constraint
< 0)
1781 if (lookup
->bfd_section
!= NULL
&& lookup
->bfd_section
->owner
!= NULL
)
1782 return lookup
->bfd_section
;
1788 /* Look for a suitable place for a new output section statement. The
1789 idea is to skip over anything that might be inside a SECTIONS {}
1790 statement in a script, before we find another output section
1791 statement. Assignments to "dot" before an output section statement
1792 are assumed to belong to it, except in two cases; The first
1793 assignment to dot, and assignments before non-alloc sections.
1794 Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
1795 similar assignments that set the initial address, or we might
1796 insert non-alloc note sections among assignments setting end of
1799 static lang_statement_union_type
**
1800 insert_os_after (lang_output_section_statement_type
*after
)
1802 lang_statement_union_type
**where
;
1803 lang_statement_union_type
**assign
= NULL
;
1804 bfd_boolean ignore_first
;
1806 ignore_first
= after
== (void *) lang_os_list
.head
;
1808 for (where
= &after
->header
.next
;
1810 where
= &(*where
)->header
.next
)
1812 switch ((*where
)->header
.type
)
1814 case lang_assignment_statement_enum
:
1817 lang_assignment_statement_type
*ass
;
1819 ass
= &(*where
)->assignment_statement
;
1820 if (ass
->exp
->type
.node_class
!= etree_assert
1821 && ass
->exp
->assign
.dst
[0] == '.'
1822 && ass
->exp
->assign
.dst
[1] == 0)
1826 ignore_first
= FALSE
;
1830 case lang_wild_statement_enum
:
1831 case lang_input_section_enum
:
1832 case lang_object_symbols_statement_enum
:
1833 case lang_fill_statement_enum
:
1834 case lang_data_statement_enum
:
1835 case lang_reloc_statement_enum
:
1836 case lang_padding_statement_enum
:
1837 case lang_constructors_statement_enum
:
1839 ignore_first
= FALSE
;
1841 case lang_output_section_statement_enum
:
1844 asection
*s
= (*where
)->output_section_statement
.bfd_section
;
1847 || s
->map_head
.s
== NULL
1848 || (s
->flags
& SEC_ALLOC
) != 0)
1852 case lang_input_statement_enum
:
1853 case lang_address_statement_enum
:
1854 case lang_target_statement_enum
:
1855 case lang_output_statement_enum
:
1856 case lang_group_statement_enum
:
1857 case lang_insert_statement_enum
:
1866 lang_output_section_statement_type
*
1867 lang_insert_orphan (asection
*s
,
1868 const char *secname
,
1870 lang_output_section_statement_type
*after
,
1871 struct orphan_save
*place
,
1872 etree_type
*address
,
1873 lang_statement_list_type
*add_child
)
1875 lang_statement_list_type add
;
1876 lang_output_section_statement_type
*os
;
1877 lang_output_section_statement_type
**os_tail
;
1879 /* If we have found an appropriate place for the output section
1880 statements for this orphan, add them to our own private list,
1881 inserting them later into the global statement list. */
1884 lang_list_init (&add
);
1885 push_stat_ptr (&add
);
1888 if (bfd_link_relocatable (&link_info
)
1889 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
1890 address
= exp_intop (0);
1892 os_tail
= (lang_output_section_statement_type
**) lang_os_list
.tail
;
1893 os
= lang_enter_output_section_statement (secname
, address
, normal_section
,
1894 NULL
, NULL
, NULL
, constraint
, 0);
1896 if (add_child
== NULL
)
1897 add_child
= &os
->children
;
1898 lang_add_section (add_child
, s
, NULL
, os
);
1900 if (after
&& (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) != 0)
1902 const char *region
= (after
->region
1903 ? after
->region
->name_list
.name
1904 : DEFAULT_MEMORY_REGION
);
1905 const char *lma_region
= (after
->lma_region
1906 ? after
->lma_region
->name_list
.name
1908 lang_leave_output_section_statement (NULL
, region
, after
->phdrs
,
1912 lang_leave_output_section_statement (NULL
, DEFAULT_MEMORY_REGION
, NULL
,
1915 /* Restore the global list pointer. */
1919 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
1921 asection
*snew
, *as
;
1922 bfd_boolean place_after
= place
->stmt
== NULL
;
1923 bfd_boolean insert_after
= TRUE
;
1925 snew
= os
->bfd_section
;
1927 /* Shuffle the bfd section list to make the output file look
1928 neater. This is really only cosmetic. */
1929 if (place
->section
== NULL
1930 && after
!= (void *) lang_os_list
.head
)
1932 asection
*bfd_section
= after
->bfd_section
;
1934 /* If the output statement hasn't been used to place any input
1935 sections (and thus doesn't have an output bfd_section),
1936 look for the closest prior output statement having an
1938 if (bfd_section
== NULL
)
1939 bfd_section
= output_prev_sec_find (after
);
1941 if (bfd_section
!= NULL
&& bfd_section
!= snew
)
1942 place
->section
= &bfd_section
->next
;
1945 if (place
->section
== NULL
)
1946 place
->section
= &link_info
.output_bfd
->sections
;
1948 as
= *place
->section
;
1952 /* Put the section at the end of the list. */
1954 /* Unlink the section. */
1955 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1957 /* Now tack it back on in the right place. */
1958 bfd_section_list_append (link_info
.output_bfd
, snew
);
1960 else if ((bfd_get_flavour (link_info
.output_bfd
)
1961 == bfd_target_elf_flavour
)
1962 && (bfd_get_flavour (s
->owner
)
1963 == bfd_target_elf_flavour
)
1964 && ((elf_section_type (s
) == SHT_NOTE
1965 && (s
->flags
& SEC_LOAD
) != 0)
1966 || (elf_section_type (as
) == SHT_NOTE
1967 && (as
->flags
& SEC_LOAD
) != 0)))
1969 /* Make sure that output note sections are grouped and sorted
1970 by alignments when inserting a note section or insert a
1971 section after a note section, */
1973 /* A specific section after which the output note section
1974 should be placed. */
1975 asection
*after_sec
;
1976 /* True if we need to insert the orphan section after a
1977 specific section to maintain output note section order. */
1978 bfd_boolean after_sec_note
= FALSE
;
1980 static asection
*first_orphan_note
= NULL
;
1982 /* Group and sort output note section by alignments in
1985 if (elf_section_type (s
) == SHT_NOTE
1986 && (s
->flags
& SEC_LOAD
) != 0)
1988 /* Search from the beginning for the last output note
1989 section with equal or larger alignments. NB: Don't
1990 place orphan note section after non-note sections. */
1992 first_orphan_note
= NULL
;
1993 for (sec
= link_info
.output_bfd
->sections
;
1995 && !bfd_is_abs_section (sec
));
1998 && elf_section_type (sec
) == SHT_NOTE
1999 && (sec
->flags
& SEC_LOAD
) != 0)
2001 if (!first_orphan_note
)
2002 first_orphan_note
= sec
;
2003 if (sec
->alignment_power
>= s
->alignment_power
)
2006 else if (first_orphan_note
)
2008 /* Stop if there is non-note section after the first
2009 orphan note section. */
2013 /* If this will be the first orphan note section, it can
2014 be placed at the default location. */
2015 after_sec_note
= first_orphan_note
!= NULL
;
2016 if (after_sec
== NULL
&& after_sec_note
)
2018 /* If all output note sections have smaller
2019 alignments, place the section before all
2020 output orphan note sections. */
2021 after_sec
= first_orphan_note
;
2022 insert_after
= FALSE
;
2025 else if (first_orphan_note
)
2027 /* Don't place non-note sections in the middle of orphan
2029 after_sec_note
= TRUE
;
2031 for (sec
= as
->next
;
2033 && !bfd_is_abs_section (sec
));
2035 if (elf_section_type (sec
) == SHT_NOTE
2036 && (sec
->flags
& SEC_LOAD
) != 0)
2044 /* Search forward to insert OS after AFTER_SEC output
2046 lang_output_section_statement_type
*stmt
, *next
;
2047 bfd_boolean found
= FALSE
;
2048 for (stmt
= after
; stmt
!= NULL
; stmt
= next
)
2053 if (stmt
->bfd_section
== after_sec
)
2063 /* If INSERT_AFTER is FALSE, place OS before
2064 AFTER_SEC output statement. */
2065 if (next
&& next
->bfd_section
== after_sec
)
2075 /* Search backward to insert OS after AFTER_SEC output
2078 for (stmt
= after
; stmt
!= NULL
; stmt
= stmt
->prev
)
2082 if (stmt
->bfd_section
== after_sec
)
2091 /* If INSERT_AFTER is FALSE, place OS before
2092 AFTER_SEC output statement. */
2093 if (stmt
->next
->bfd_section
== after_sec
)
2103 if (after_sec
== NULL
2104 || (insert_after
&& after_sec
->next
!= snew
)
2105 || (!insert_after
&& after_sec
->prev
!= snew
))
2107 /* Unlink the section. */
2108 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2110 /* Place SNEW after AFTER_SEC. If AFTER_SEC is NULL,
2115 bfd_section_list_insert_after (link_info
.output_bfd
,
2118 bfd_section_list_insert_before (link_info
.output_bfd
,
2122 bfd_section_list_prepend (link_info
.output_bfd
, snew
);
2125 else if (as
!= snew
&& as
->prev
!= snew
)
2127 /* Unlink the section. */
2128 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2130 /* Now tack it back on in the right place. */
2131 bfd_section_list_insert_before (link_info
.output_bfd
,
2135 else if (as
!= snew
&& as
->prev
!= snew
)
2137 /* Unlink the section. */
2138 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2140 /* Now tack it back on in the right place. */
2141 bfd_section_list_insert_before (link_info
.output_bfd
, as
, snew
);
2144 /* Save the end of this list. Further ophans of this type will
2145 follow the one we've just added. */
2146 place
->section
= &snew
->next
;
2148 /* The following is non-cosmetic. We try to put the output
2149 statements in some sort of reasonable order here, because they
2150 determine the final load addresses of the orphan sections.
2151 In addition, placing output statements in the wrong order may
2152 require extra segments. For instance, given a typical
2153 situation of all read-only sections placed in one segment and
2154 following that a segment containing all the read-write
2155 sections, we wouldn't want to place an orphan read/write
2156 section before or amongst the read-only ones. */
2157 if (add
.head
!= NULL
)
2159 lang_output_section_statement_type
*newly_added_os
;
2161 /* Place OS after AFTER if AFTER_NOTE is TRUE. */
2164 lang_statement_union_type
**where
= insert_os_after (after
);
2169 place
->os_tail
= &after
->next
;
2173 /* Put it after the last orphan statement we added. */
2174 *add
.tail
= *place
->stmt
;
2175 *place
->stmt
= add
.head
;
2178 /* Fix the global list pointer if we happened to tack our
2179 new list at the tail. */
2180 if (*stat_ptr
->tail
== add
.head
)
2181 stat_ptr
->tail
= add
.tail
;
2183 /* Save the end of this list. */
2184 place
->stmt
= add
.tail
;
2186 /* Do the same for the list of output section statements. */
2187 newly_added_os
= *os_tail
;
2189 newly_added_os
->prev
= (lang_output_section_statement_type
*)
2190 ((char *) place
->os_tail
2191 - offsetof (lang_output_section_statement_type
, next
));
2192 newly_added_os
->next
= *place
->os_tail
;
2193 if (newly_added_os
->next
!= NULL
)
2194 newly_added_os
->next
->prev
= newly_added_os
;
2195 *place
->os_tail
= newly_added_os
;
2196 place
->os_tail
= &newly_added_os
->next
;
2198 /* Fixing the global list pointer here is a little different.
2199 We added to the list in lang_enter_output_section_statement,
2200 trimmed off the new output_section_statment above when
2201 assigning *os_tail = NULL, but possibly added it back in
2202 the same place when assigning *place->os_tail. */
2203 if (*os_tail
== NULL
)
2204 lang_os_list
.tail
= (lang_statement_union_type
**) os_tail
;
2211 lang_print_asneeded (void)
2213 struct asneeded_minfo
*m
;
2215 if (asneeded_list_head
== NULL
)
2218 minfo (_("\nAs-needed library included to satisfy reference by file (symbol)\n\n"));
2220 for (m
= asneeded_list_head
; m
!= NULL
; m
= m
->next
)
2224 minfo ("%s", m
->soname
);
2225 len
= strlen (m
->soname
);
2239 minfo ("%pB ", m
->ref
);
2240 minfo ("(%pT)\n", m
->name
);
2245 lang_map_flags (flagword flag
)
2247 if (flag
& SEC_ALLOC
)
2250 if (flag
& SEC_CODE
)
2253 if (flag
& SEC_READONLY
)
2256 if (flag
& SEC_DATA
)
2259 if (flag
& SEC_LOAD
)
2266 lang_memory_region_type
*m
;
2267 bfd_boolean dis_header_printed
= FALSE
;
2269 LANG_FOR_EACH_INPUT_STATEMENT (file
)
2273 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
2274 || file
->flags
.just_syms
)
2277 if (config
.print_map_discarded
)
2278 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2279 if ((s
->output_section
== NULL
2280 || s
->output_section
->owner
!= link_info
.output_bfd
)
2281 && (s
->flags
& (SEC_LINKER_CREATED
| SEC_KEEP
)) == 0)
2283 if (! dis_header_printed
)
2285 fprintf (config
.map_file
, _("\nDiscarded input sections\n\n"));
2286 dis_header_printed
= TRUE
;
2289 print_input_section (s
, TRUE
);
2293 minfo (_("\nMemory Configuration\n\n"));
2294 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
2295 _("Name"), _("Origin"), _("Length"), _("Attributes"));
2297 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
2302 fprintf (config
.map_file
, "%-16s ", m
->name_list
.name
);
2304 sprintf_vma (buf
, m
->origin
);
2305 minfo ("0x%s ", buf
);
2313 minfo ("0x%V", m
->length
);
2314 if (m
->flags
|| m
->not_flags
)
2322 lang_map_flags (m
->flags
);
2328 lang_map_flags (m
->not_flags
);
2335 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
2337 if (!link_info
.reduce_memory_overheads
)
2339 obstack_begin (&map_obstack
, 1000);
2340 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
2342 expld
.phase
= lang_fixed_phase_enum
;
2343 lang_statement_iteration
++;
2344 print_statements ();
2346 ldemul_extra_map_file_text (link_info
.output_bfd
, &link_info
,
2351 sort_def_symbol (struct bfd_link_hash_entry
*hash_entry
,
2352 void *info ATTRIBUTE_UNUSED
)
2354 if ((hash_entry
->type
== bfd_link_hash_defined
2355 || hash_entry
->type
== bfd_link_hash_defweak
)
2356 && hash_entry
->u
.def
.section
->owner
!= link_info
.output_bfd
2357 && hash_entry
->u
.def
.section
->owner
!= NULL
)
2359 input_section_userdata_type
*ud
;
2360 struct map_symbol_def
*def
;
2362 ud
= bfd_section_userdata (hash_entry
->u
.def
.section
);
2365 ud
= stat_alloc (sizeof (*ud
));
2366 bfd_set_section_userdata (hash_entry
->u
.def
.section
, ud
);
2367 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2368 ud
->map_symbol_def_count
= 0;
2370 else if (!ud
->map_symbol_def_tail
)
2371 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2373 def
= (struct map_symbol_def
*) obstack_alloc (&map_obstack
, sizeof *def
);
2374 def
->entry
= hash_entry
;
2375 *(ud
->map_symbol_def_tail
) = def
;
2376 ud
->map_symbol_def_tail
= &def
->next
;
2377 ud
->map_symbol_def_count
++;
2382 /* Initialize an output section. */
2385 init_os (lang_output_section_statement_type
*s
, flagword flags
)
2387 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
2388 einfo (_("%F%P: illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
2390 if (s
->constraint
!= SPECIAL
)
2391 s
->bfd_section
= bfd_get_section_by_name (link_info
.output_bfd
, s
->name
);
2392 if (s
->bfd_section
== NULL
)
2393 s
->bfd_section
= bfd_make_section_anyway_with_flags (link_info
.output_bfd
,
2395 if (s
->bfd_section
== NULL
)
2397 einfo (_("%F%P: output format %s cannot represent section"
2398 " called %s: %E\n"),
2399 link_info
.output_bfd
->xvec
->name
, s
->name
);
2401 s
->bfd_section
->output_section
= s
->bfd_section
;
2402 s
->bfd_section
->output_offset
= 0;
2404 /* Set the userdata of the output section to the output section
2405 statement to avoid lookup. */
2406 bfd_set_section_userdata (s
->bfd_section
, s
);
2408 /* If there is a base address, make sure that any sections it might
2409 mention are initialized. */
2410 if (s
->addr_tree
!= NULL
)
2411 exp_init_os (s
->addr_tree
);
2413 if (s
->load_base
!= NULL
)
2414 exp_init_os (s
->load_base
);
2416 /* If supplied an alignment, set it. */
2417 if (s
->section_alignment
!= NULL
)
2418 s
->bfd_section
->alignment_power
= exp_get_power (s
->section_alignment
,
2419 "section alignment");
2422 /* Make sure that all output sections mentioned in an expression are
2426 exp_init_os (etree_type
*exp
)
2428 switch (exp
->type
.node_class
)
2432 case etree_provided
:
2433 exp_init_os (exp
->assign
.src
);
2437 exp_init_os (exp
->binary
.lhs
);
2438 exp_init_os (exp
->binary
.rhs
);
2442 exp_init_os (exp
->trinary
.cond
);
2443 exp_init_os (exp
->trinary
.lhs
);
2444 exp_init_os (exp
->trinary
.rhs
);
2448 exp_init_os (exp
->assert_s
.child
);
2452 exp_init_os (exp
->unary
.child
);
2456 switch (exp
->type
.node_code
)
2462 lang_output_section_statement_type
*os
;
2464 os
= lang_output_section_find (exp
->name
.name
);
2465 if (os
!= NULL
&& os
->bfd_section
== NULL
)
2477 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
2479 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
2481 /* If we are only reading symbols from this object, then we want to
2482 discard all sections. */
2483 if (entry
->flags
.just_syms
)
2485 bfd_link_just_syms (abfd
, sec
, &link_info
);
2489 /* Deal with SHF_EXCLUDE ELF sections. */
2490 if (!bfd_link_relocatable (&link_info
)
2491 && (abfd
->flags
& BFD_PLUGIN
) == 0
2492 && (sec
->flags
& (SEC_GROUP
| SEC_KEEP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
2493 sec
->output_section
= bfd_abs_section_ptr
;
2495 if (!(abfd
->flags
& DYNAMIC
))
2496 bfd_section_already_linked (abfd
, sec
, &link_info
);
2500 /* Returns true if SECTION is one we know will be discarded based on its
2501 section flags, otherwise returns false. */
2504 lang_discard_section_p (asection
*section
)
2506 bfd_boolean discard
;
2507 flagword flags
= section
->flags
;
2509 /* Discard sections marked with SEC_EXCLUDE. */
2510 discard
= (flags
& SEC_EXCLUDE
) != 0;
2512 /* Discard the group descriptor sections when we're finally placing the
2513 sections from within the group. */
2514 if ((flags
& SEC_GROUP
) != 0
2515 && link_info
.resolve_section_groups
)
2518 /* Discard debugging sections if we are stripping debugging
2520 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
2521 && (flags
& SEC_DEBUGGING
) != 0)
2527 /* The wild routines.
2529 These expand statements like *(.text) and foo.o to a list of
2530 explicit actions, like foo.o(.text), bar.o(.text) and
2531 foo.o(.text, .data). */
2533 /* Add SECTION to the output section OUTPUT. Do this by creating a
2534 lang_input_section statement which is placed at PTR. */
2537 lang_add_section (lang_statement_list_type
*ptr
,
2539 struct flag_info
*sflag_info
,
2540 lang_output_section_statement_type
*output
)
2542 flagword flags
= section
->flags
;
2544 bfd_boolean discard
;
2545 lang_input_section_type
*new_section
;
2546 bfd
*abfd
= link_info
.output_bfd
;
2548 /* Is this section one we know should be discarded? */
2549 discard
= lang_discard_section_p (section
);
2551 /* Discard input sections which are assigned to a section named
2552 DISCARD_SECTION_NAME. */
2553 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
2558 if (section
->output_section
== NULL
)
2560 /* This prevents future calls from assigning this section. */
2561 section
->output_section
= bfd_abs_section_ptr
;
2563 else if (link_info
.non_contiguous_regions_warnings
)
2564 einfo (_("%P:%pS: warning: --enable-non-contiguous-regions makes "
2565 "section `%pA' from '%pB' match /DISCARD/ clause.\n"),
2566 NULL
, section
, section
->owner
);
2575 keep
= bfd_lookup_section_flags (&link_info
, sflag_info
, section
);
2580 if (section
->output_section
!= NULL
)
2582 if (!link_info
.non_contiguous_regions
)
2585 /* SECTION has already been handled in a special way
2586 (eg. LINK_ONCE): skip it. */
2587 if (bfd_is_abs_section (section
->output_section
))
2590 /* Already assigned to the same output section, do not process
2591 it again, to avoid creating loops between duplicate sections
2593 if (section
->output_section
== output
->bfd_section
)
2596 if (link_info
.non_contiguous_regions_warnings
&& output
->bfd_section
)
2597 einfo (_("%P:%pS: warning: --enable-non-contiguous-regions may "
2598 "change behaviour for section `%pA' from '%pB' (assigned to "
2599 "%pA, but additional match: %pA)\n"),
2600 NULL
, section
, section
->owner
, section
->output_section
,
2601 output
->bfd_section
);
2603 /* SECTION has already been assigned to an output section, but
2604 the user allows it to be mapped to another one in case it
2605 overflows. We'll later update the actual output section in
2606 size_input_section as appropriate. */
2609 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2610 to an output section, because we want to be able to include a
2611 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2612 section (I don't know why we want to do this, but we do).
2613 build_link_order in ldwrite.c handles this case by turning
2614 the embedded SEC_NEVER_LOAD section into a fill. */
2615 flags
&= ~ SEC_NEVER_LOAD
;
2617 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2618 already been processed. One reason to do this is that on pe
2619 format targets, .text$foo sections go into .text and it's odd
2620 to see .text with SEC_LINK_ONCE set. */
2621 if ((flags
& (SEC_LINK_ONCE
| SEC_GROUP
)) == (SEC_LINK_ONCE
| SEC_GROUP
))
2623 if (link_info
.resolve_section_groups
)
2624 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2626 flags
&= ~(SEC_LINK_DUPLICATES
| SEC_RELOC
);
2628 else if (!bfd_link_relocatable (&link_info
))
2629 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2631 switch (output
->sectype
)
2633 case normal_section
:
2634 case overlay_section
:
2635 case first_overlay_section
:
2637 case noalloc_section
:
2638 flags
&= ~SEC_ALLOC
;
2640 case noload_section
:
2642 flags
|= SEC_NEVER_LOAD
;
2643 /* Unfortunately GNU ld has managed to evolve two different
2644 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2645 alloc, no contents section. All others get a noload, noalloc
2647 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
2648 flags
&= ~SEC_HAS_CONTENTS
;
2650 flags
&= ~SEC_ALLOC
;
2654 if (output
->bfd_section
== NULL
)
2655 init_os (output
, flags
);
2657 /* If SEC_READONLY is not set in the input section, then clear
2658 it from the output section. */
2659 output
->bfd_section
->flags
&= flags
| ~SEC_READONLY
;
2661 if (output
->bfd_section
->linker_has_input
)
2663 /* Only set SEC_READONLY flag on the first input section. */
2664 flags
&= ~ SEC_READONLY
;
2666 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2667 if ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2668 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2669 || ((flags
& SEC_MERGE
) != 0
2670 && output
->bfd_section
->entsize
!= section
->entsize
))
2672 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2673 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2676 output
->bfd_section
->flags
|= flags
;
2678 if (!output
->bfd_section
->linker_has_input
)
2680 output
->bfd_section
->linker_has_input
= 1;
2681 /* This must happen after flags have been updated. The output
2682 section may have been created before we saw its first input
2683 section, eg. for a data statement. */
2684 bfd_init_private_section_data (section
->owner
, section
,
2685 link_info
.output_bfd
,
2686 output
->bfd_section
,
2688 if ((flags
& SEC_MERGE
) != 0)
2689 output
->bfd_section
->entsize
= section
->entsize
;
2692 if ((flags
& SEC_TIC54X_BLOCK
) != 0
2693 && bfd_get_arch (section
->owner
) == bfd_arch_tic54x
)
2695 /* FIXME: This value should really be obtained from the bfd... */
2696 output
->block_value
= 128;
2699 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2700 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2702 section
->output_section
= output
->bfd_section
;
2704 if (!map_head_is_link_order
)
2706 asection
*s
= output
->bfd_section
->map_tail
.s
;
2707 output
->bfd_section
->map_tail
.s
= section
;
2708 section
->map_head
.s
= NULL
;
2709 section
->map_tail
.s
= s
;
2711 s
->map_head
.s
= section
;
2713 output
->bfd_section
->map_head
.s
= section
;
2716 /* Add a section reference to the list. */
2717 new_section
= new_stat (lang_input_section
, ptr
);
2718 new_section
->section
= section
;
2721 /* Handle wildcard sorting. This returns the lang_input_section which
2722 should follow the one we are going to create for SECTION and FILE,
2723 based on the sorting requirements of WILD. It returns NULL if the
2724 new section should just go at the end of the current list. */
2726 static lang_statement_union_type
*
2727 wild_sort (lang_wild_statement_type
*wild
,
2728 struct wildcard_list
*sec
,
2729 lang_input_statement_type
*file
,
2732 lang_statement_union_type
*l
;
2734 if (!wild
->filenames_sorted
2735 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
2738 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
2740 lang_input_section_type
*ls
;
2742 if (l
->header
.type
!= lang_input_section_enum
)
2744 ls
= &l
->input_section
;
2746 /* Sorting by filename takes precedence over sorting by section
2749 if (wild
->filenames_sorted
)
2751 const char *fn
, *ln
;
2755 /* The PE support for the .idata section as generated by
2756 dlltool assumes that files will be sorted by the name of
2757 the archive and then the name of the file within the
2760 if (file
->the_bfd
!= NULL
2761 && file
->the_bfd
->my_archive
!= NULL
)
2763 fn
= bfd_get_filename (file
->the_bfd
->my_archive
);
2768 fn
= file
->filename
;
2772 if (ls
->section
->owner
->my_archive
!= NULL
)
2774 ln
= bfd_get_filename (ls
->section
->owner
->my_archive
);
2779 ln
= bfd_get_filename (ls
->section
->owner
);
2783 i
= filename_cmp (fn
, ln
);
2792 fn
= file
->filename
;
2794 ln
= bfd_get_filename (ls
->section
->owner
);
2796 i
= filename_cmp (fn
, ln
);
2804 /* Here either the files are not sorted by name, or we are
2805 looking at the sections for this file. */
2808 && sec
->spec
.sorted
!= none
2809 && sec
->spec
.sorted
!= by_none
)
2810 if (compare_section (sec
->spec
.sorted
, section
, ls
->section
) < 0)
2817 /* Expand a wild statement for a particular FILE. SECTION may be
2818 NULL, in which case it is a wild card. */
2821 output_section_callback (lang_wild_statement_type
*ptr
,
2822 struct wildcard_list
*sec
,
2824 struct flag_info
*sflag_info
,
2825 lang_input_statement_type
*file
,
2828 lang_statement_union_type
*before
;
2829 lang_output_section_statement_type
*os
;
2831 os
= (lang_output_section_statement_type
*) output
;
2833 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2834 if (unique_section_p (section
, os
))
2837 before
= wild_sort (ptr
, sec
, file
, section
);
2839 /* Here BEFORE points to the lang_input_section which
2840 should follow the one we are about to add. If BEFORE
2841 is NULL, then the section should just go at the end
2842 of the current list. */
2845 lang_add_section (&ptr
->children
, section
, sflag_info
, os
);
2848 lang_statement_list_type list
;
2849 lang_statement_union_type
**pp
;
2851 lang_list_init (&list
);
2852 lang_add_section (&list
, section
, sflag_info
, os
);
2854 /* If we are discarding the section, LIST.HEAD will
2856 if (list
.head
!= NULL
)
2858 ASSERT (list
.head
->header
.next
== NULL
);
2860 for (pp
= &ptr
->children
.head
;
2862 pp
= &(*pp
)->header
.next
)
2863 ASSERT (*pp
!= NULL
);
2865 list
.head
->header
.next
= *pp
;
2871 /* Check if all sections in a wild statement for a particular FILE
2875 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2876 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2878 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
2879 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2882 lang_output_section_statement_type
*os
;
2884 os
= (lang_output_section_statement_type
*) output
;
2886 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2887 if (unique_section_p (section
, os
))
2890 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2891 os
->all_input_readonly
= FALSE
;
2894 /* This is passed a file name which must have been seen already and
2895 added to the statement tree. We will see if it has been opened
2896 already and had its symbols read. If not then we'll read it. */
2898 static lang_input_statement_type
*
2899 lookup_name (const char *name
)
2901 lang_input_statement_type
*search
;
2903 for (search
= (void *) input_file_chain
.head
;
2905 search
= search
->next_real_file
)
2907 /* Use the local_sym_name as the name of the file that has
2908 already been loaded as filename might have been transformed
2909 via the search directory lookup mechanism. */
2910 const char *filename
= search
->local_sym_name
;
2912 if (filename
!= NULL
2913 && filename_cmp (filename
, name
) == 0)
2919 /* Arrange to splice the input statement added by new_afile into
2920 statement_list after the current input_file_chain tail.
2921 We know input_file_chain is not an empty list, and that
2922 lookup_name was called via open_input_bfds. Later calls to
2923 lookup_name should always match an existing input_statement. */
2924 lang_statement_union_type
**tail
= stat_ptr
->tail
;
2925 lang_statement_union_type
**after
2926 = (void *) ((char *) input_file_chain
.tail
2927 - offsetof (lang_input_statement_type
, next_real_file
)
2928 + offsetof (lang_input_statement_type
, header
.next
));
2929 lang_statement_union_type
*rest
= *after
;
2930 stat_ptr
->tail
= after
;
2931 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2932 default_target
, NULL
);
2933 *stat_ptr
->tail
= rest
;
2935 stat_ptr
->tail
= tail
;
2938 /* If we have already added this file, or this file is not real
2939 don't add this file. */
2940 if (search
->flags
.loaded
|| !search
->flags
.real
)
2943 if (!load_symbols (search
, NULL
))
2949 /* Save LIST as a list of libraries whose symbols should not be exported. */
2954 struct excluded_lib
*next
;
2956 static struct excluded_lib
*excluded_libs
;
2959 add_excluded_libs (const char *list
)
2961 const char *p
= list
, *end
;
2965 struct excluded_lib
*entry
;
2966 end
= strpbrk (p
, ",:");
2968 end
= p
+ strlen (p
);
2969 entry
= (struct excluded_lib
*) xmalloc (sizeof (*entry
));
2970 entry
->next
= excluded_libs
;
2971 entry
->name
= (char *) xmalloc (end
- p
+ 1);
2972 memcpy (entry
->name
, p
, end
- p
);
2973 entry
->name
[end
- p
] = '\0';
2974 excluded_libs
= entry
;
2982 check_excluded_libs (bfd
*abfd
)
2984 struct excluded_lib
*lib
= excluded_libs
;
2988 int len
= strlen (lib
->name
);
2989 const char *filename
= lbasename (bfd_get_filename (abfd
));
2991 if (strcmp (lib
->name
, "ALL") == 0)
2993 abfd
->no_export
= TRUE
;
2997 if (filename_ncmp (lib
->name
, filename
, len
) == 0
2998 && (filename
[len
] == '\0'
2999 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
3000 && filename
[len
+ 2] == '\0')))
3002 abfd
->no_export
= TRUE
;
3010 /* Get the symbols for an input file. */
3013 load_symbols (lang_input_statement_type
*entry
,
3014 lang_statement_list_type
*place
)
3018 if (entry
->flags
.loaded
)
3021 ldfile_open_file (entry
);
3023 /* Do not process further if the file was missing. */
3024 if (entry
->flags
.missing_file
)
3027 if (trace_files
|| verbose
)
3028 info_msg ("%pI\n", entry
);
3030 if (!bfd_check_format (entry
->the_bfd
, bfd_archive
)
3031 && !bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
3034 struct lang_input_statement_flags save_flags
;
3037 err
= bfd_get_error ();
3039 /* See if the emulation has some special knowledge. */
3040 if (ldemul_unrecognized_file (entry
))
3043 if (err
== bfd_error_file_ambiguously_recognized
)
3047 einfo (_("%P: %pB: file not recognized: %E;"
3048 " matching formats:"), entry
->the_bfd
);
3049 for (p
= matching
; *p
!= NULL
; p
++)
3053 else if (err
!= bfd_error_file_not_recognized
3055 einfo (_("%F%P: %pB: file not recognized: %E\n"), entry
->the_bfd
);
3057 bfd_close (entry
->the_bfd
);
3058 entry
->the_bfd
= NULL
;
3060 /* Try to interpret the file as a linker script. */
3061 save_flags
= input_flags
;
3062 ldfile_open_command_file (entry
->filename
);
3064 push_stat_ptr (place
);
3065 input_flags
.add_DT_NEEDED_for_regular
3066 = entry
->flags
.add_DT_NEEDED_for_regular
;
3067 input_flags
.add_DT_NEEDED_for_dynamic
3068 = entry
->flags
.add_DT_NEEDED_for_dynamic
;
3069 input_flags
.whole_archive
= entry
->flags
.whole_archive
;
3070 input_flags
.dynamic
= entry
->flags
.dynamic
;
3072 ldfile_assumed_script
= TRUE
;
3073 parser_input
= input_script
;
3074 current_input_file
= entry
->filename
;
3076 current_input_file
= NULL
;
3077 ldfile_assumed_script
= FALSE
;
3079 /* missing_file is sticky. sysrooted will already have been
3080 restored when seeing EOF in yyparse, but no harm to restore
3082 save_flags
.missing_file
|= input_flags
.missing_file
;
3083 input_flags
= save_flags
;
3087 entry
->flags
.loaded
= TRUE
;
3092 if (ldemul_recognized_file (entry
))
3095 /* We don't call ldlang_add_file for an archive. Instead, the
3096 add_symbols entry point will call ldlang_add_file, via the
3097 add_archive_element callback, for each element of the archive
3099 switch (bfd_get_format (entry
->the_bfd
))
3105 if (!entry
->flags
.reload
)
3106 ldlang_add_file (entry
);
3110 check_excluded_libs (entry
->the_bfd
);
3112 bfd_set_usrdata (entry
->the_bfd
, entry
);
3113 if (entry
->flags
.whole_archive
)
3116 bfd_boolean loaded
= TRUE
;
3121 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
3126 if (!bfd_check_format (member
, bfd_object
))
3128 einfo (_("%F%P: %pB: member %pB in archive is not an object\n"),
3129 entry
->the_bfd
, member
);
3134 if (!(*link_info
.callbacks
3135 ->add_archive_element
) (&link_info
, member
,
3136 "--whole-archive", &subsbfd
))
3139 /* Potentially, the add_archive_element hook may have set a
3140 substitute BFD for us. */
3141 if (!bfd_link_add_symbols (subsbfd
, &link_info
))
3143 einfo (_("%F%P: %pB: error adding symbols: %E\n"), member
);
3148 entry
->flags
.loaded
= loaded
;
3154 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
3155 entry
->flags
.loaded
= TRUE
;
3157 einfo (_("%F%P: %pB: error adding symbols: %E\n"), entry
->the_bfd
);
3159 return entry
->flags
.loaded
;
3162 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
3163 may be NULL, indicating that it is a wildcard. Separate
3164 lang_input_section statements are created for each part of the
3165 expansion; they are added after the wild statement S. OUTPUT is
3166 the output section. */
3169 wild (lang_wild_statement_type
*s
,
3170 const char *target ATTRIBUTE_UNUSED
,
3171 lang_output_section_statement_type
*output
)
3173 struct wildcard_list
*sec
;
3175 if (s
->handler_data
[0]
3176 && s
->handler_data
[0]->spec
.sorted
== by_name
3177 && !s
->filenames_sorted
)
3179 lang_section_bst_type
*tree
;
3181 walk_wild (s
, output_section_callback_fast
, output
);
3186 output_section_callback_tree_to_list (s
, tree
, output
);
3191 walk_wild (s
, output_section_callback
, output
);
3193 if (default_common_section
== NULL
)
3194 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
3195 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
3197 /* Remember the section that common is going to in case we
3198 later get something which doesn't know where to put it. */
3199 default_common_section
= output
;
3204 /* Return TRUE iff target is the sought target. */
3207 get_target (const bfd_target
*target
, void *data
)
3209 const char *sought
= (const char *) data
;
3211 return strcmp (target
->name
, sought
) == 0;
3214 /* Like strcpy() but convert to lower case as well. */
3217 stricpy (char *dest
, const char *src
)
3221 while ((c
= *src
++) != 0)
3222 *dest
++ = TOLOWER (c
);
3227 /* Remove the first occurrence of needle (if any) in haystack
3231 strcut (char *haystack
, const char *needle
)
3233 haystack
= strstr (haystack
, needle
);
3239 for (src
= haystack
+ strlen (needle
); *src
;)
3240 *haystack
++ = *src
++;
3246 /* Compare two target format name strings.
3247 Return a value indicating how "similar" they are. */
3250 name_compare (const char *first
, const char *second
)
3256 copy1
= (char *) xmalloc (strlen (first
) + 1);
3257 copy2
= (char *) xmalloc (strlen (second
) + 1);
3259 /* Convert the names to lower case. */
3260 stricpy (copy1
, first
);
3261 stricpy (copy2
, second
);
3263 /* Remove size and endian strings from the name. */
3264 strcut (copy1
, "big");
3265 strcut (copy1
, "little");
3266 strcut (copy2
, "big");
3267 strcut (copy2
, "little");
3269 /* Return a value based on how many characters match,
3270 starting from the beginning. If both strings are
3271 the same then return 10 * their length. */
3272 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
3273 if (copy1
[result
] == 0)
3285 /* Set by closest_target_match() below. */
3286 static const bfd_target
*winner
;
3288 /* Scan all the valid bfd targets looking for one that has the endianness
3289 requirement that was specified on the command line, and is the nearest
3290 match to the original output target. */
3293 closest_target_match (const bfd_target
*target
, void *data
)
3295 const bfd_target
*original
= (const bfd_target
*) data
;
3297 if (command_line
.endian
== ENDIAN_BIG
3298 && target
->byteorder
!= BFD_ENDIAN_BIG
)
3301 if (command_line
.endian
== ENDIAN_LITTLE
3302 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
3305 /* Must be the same flavour. */
3306 if (target
->flavour
!= original
->flavour
)
3309 /* Ignore generic big and little endian elf vectors. */
3310 if (strcmp (target
->name
, "elf32-big") == 0
3311 || strcmp (target
->name
, "elf64-big") == 0
3312 || strcmp (target
->name
, "elf32-little") == 0
3313 || strcmp (target
->name
, "elf64-little") == 0)
3316 /* If we have not found a potential winner yet, then record this one. */
3323 /* Oh dear, we now have two potential candidates for a successful match.
3324 Compare their names and choose the better one. */
3325 if (name_compare (target
->name
, original
->name
)
3326 > name_compare (winner
->name
, original
->name
))
3329 /* Keep on searching until wqe have checked them all. */
3333 /* Return the BFD target format of the first input file. */
3336 get_first_input_target (void)
3338 const char *target
= NULL
;
3340 LANG_FOR_EACH_INPUT_STATEMENT (s
)
3342 if (s
->header
.type
== lang_input_statement_enum
3345 ldfile_open_file (s
);
3347 if (s
->the_bfd
!= NULL
3348 && bfd_check_format (s
->the_bfd
, bfd_object
))
3350 target
= bfd_get_target (s
->the_bfd
);
3362 lang_get_output_target (void)
3366 /* Has the user told us which output format to use? */
3367 if (output_target
!= NULL
)
3368 return output_target
;
3370 /* No - has the current target been set to something other than
3372 if (current_target
!= default_target
&& current_target
!= NULL
)
3373 return current_target
;
3375 /* No - can we determine the format of the first input file? */
3376 target
= get_first_input_target ();
3380 /* Failed - use the default output target. */
3381 return default_target
;
3384 /* Open the output file. */
3387 open_output (const char *name
)
3389 output_target
= lang_get_output_target ();
3391 /* Has the user requested a particular endianness on the command
3393 if (command_line
.endian
!= ENDIAN_UNSET
)
3395 /* Get the chosen target. */
3396 const bfd_target
*target
3397 = bfd_iterate_over_targets (get_target
, (void *) output_target
);
3399 /* If the target is not supported, we cannot do anything. */
3402 enum bfd_endian desired_endian
;
3404 if (command_line
.endian
== ENDIAN_BIG
)
3405 desired_endian
= BFD_ENDIAN_BIG
;
3407 desired_endian
= BFD_ENDIAN_LITTLE
;
3409 /* See if the target has the wrong endianness. This should
3410 not happen if the linker script has provided big and
3411 little endian alternatives, but some scrips don't do
3413 if (target
->byteorder
!= desired_endian
)
3415 /* If it does, then see if the target provides
3416 an alternative with the correct endianness. */
3417 if (target
->alternative_target
!= NULL
3418 && (target
->alternative_target
->byteorder
== desired_endian
))
3419 output_target
= target
->alternative_target
->name
;
3422 /* Try to find a target as similar as possible to
3423 the default target, but which has the desired
3424 endian characteristic. */
3425 bfd_iterate_over_targets (closest_target_match
,
3428 /* Oh dear - we could not find any targets that
3429 satisfy our requirements. */
3431 einfo (_("%P: warning: could not find any targets"
3432 " that match endianness requirement\n"));
3434 output_target
= winner
->name
;
3440 link_info
.output_bfd
= bfd_openw (name
, output_target
);
3442 if (link_info
.output_bfd
== NULL
)
3444 if (bfd_get_error () == bfd_error_invalid_target
)
3445 einfo (_("%F%P: target %s not found\n"), output_target
);
3447 einfo (_("%F%P: cannot open output file %s: %E\n"), name
);
3450 delete_output_file_on_failure
= TRUE
;
3452 if (!bfd_set_format (link_info
.output_bfd
, bfd_object
))
3453 einfo (_("%F%P: %s: can not make object file: %E\n"), name
);
3454 if (!bfd_set_arch_mach (link_info
.output_bfd
,
3455 ldfile_output_architecture
,
3456 ldfile_output_machine
))
3457 einfo (_("%F%P: %s: can not set architecture: %E\n"), name
);
3459 link_info
.hash
= bfd_link_hash_table_create (link_info
.output_bfd
);
3460 if (link_info
.hash
== NULL
)
3461 einfo (_("%F%P: can not create hash table: %E\n"));
3463 bfd_set_gp_size (link_info
.output_bfd
, g_switch_value
);
3467 ldlang_open_output (lang_statement_union_type
*statement
)
3469 switch (statement
->header
.type
)
3471 case lang_output_statement_enum
:
3472 ASSERT (link_info
.output_bfd
== NULL
);
3473 open_output (statement
->output_statement
.name
);
3474 ldemul_set_output_arch ();
3475 if (config
.magic_demand_paged
3476 && !bfd_link_relocatable (&link_info
))
3477 link_info
.output_bfd
->flags
|= D_PAGED
;
3479 link_info
.output_bfd
->flags
&= ~D_PAGED
;
3480 if (config
.text_read_only
)
3481 link_info
.output_bfd
->flags
|= WP_TEXT
;
3483 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
3484 if (link_info
.traditional_format
)
3485 link_info
.output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
3487 link_info
.output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
3490 case lang_target_statement_enum
:
3491 current_target
= statement
->target_statement
.target
;
3499 init_opb (asection
*s
)
3504 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
3506 && (s
->flags
& SEC_ELF_OCTETS
) != 0)
3509 x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3510 ldfile_output_machine
);
3512 while ((x
& 1) == 0)
3520 /* Open all the input files. */
3524 OPEN_BFD_NORMAL
= 0,
3528 #if BFD_SUPPORTS_PLUGINS
3529 static lang_input_statement_type
*plugin_insert
= NULL
;
3530 static struct bfd_link_hash_entry
*plugin_undefs
= NULL
;
3534 open_input_bfds (lang_statement_union_type
*s
, enum open_bfd_mode mode
)
3536 for (; s
!= NULL
; s
= s
->header
.next
)
3538 switch (s
->header
.type
)
3540 case lang_constructors_statement_enum
:
3541 open_input_bfds (constructor_list
.head
, mode
);
3543 case lang_output_section_statement_enum
:
3544 open_input_bfds (s
->output_section_statement
.children
.head
, mode
);
3546 case lang_wild_statement_enum
:
3547 /* Maybe we should load the file's symbols. */
3548 if ((mode
& OPEN_BFD_RESCAN
) == 0
3549 && s
->wild_statement
.filename
3550 && !wildcardp (s
->wild_statement
.filename
)
3551 && !archive_path (s
->wild_statement
.filename
))
3552 lookup_name (s
->wild_statement
.filename
);
3553 open_input_bfds (s
->wild_statement
.children
.head
, mode
);
3555 case lang_group_statement_enum
:
3557 struct bfd_link_hash_entry
*undefs
;
3558 #if BFD_SUPPORTS_PLUGINS
3559 lang_input_statement_type
*plugin_insert_save
;
3562 /* We must continually search the entries in the group
3563 until no new symbols are added to the list of undefined
3568 #if BFD_SUPPORTS_PLUGINS
3569 plugin_insert_save
= plugin_insert
;
3571 undefs
= link_info
.hash
->undefs_tail
;
3572 open_input_bfds (s
->group_statement
.children
.head
,
3573 mode
| OPEN_BFD_FORCE
);
3575 while (undefs
!= link_info
.hash
->undefs_tail
3576 #if BFD_SUPPORTS_PLUGINS
3577 /* Objects inserted by a plugin, which are loaded
3578 before we hit this loop, may have added new
3580 || (plugin_insert
!= plugin_insert_save
&& plugin_undefs
)
3585 case lang_target_statement_enum
:
3586 current_target
= s
->target_statement
.target
;
3588 case lang_input_statement_enum
:
3589 if (s
->input_statement
.flags
.real
)
3591 lang_statement_union_type
**os_tail
;
3592 lang_statement_list_type add
;
3595 s
->input_statement
.target
= current_target
;
3597 /* If we are being called from within a group, and this
3598 is an archive which has already been searched, then
3599 force it to be researched unless the whole archive
3600 has been loaded already. Do the same for a rescan.
3601 Likewise reload --as-needed shared libs. */
3602 if (mode
!= OPEN_BFD_NORMAL
3603 #if BFD_SUPPORTS_PLUGINS
3604 && ((mode
& OPEN_BFD_RESCAN
) == 0
3605 || plugin_insert
== NULL
)
3607 && s
->input_statement
.flags
.loaded
3608 && (abfd
= s
->input_statement
.the_bfd
) != NULL
3609 && ((bfd_get_format (abfd
) == bfd_archive
3610 && !s
->input_statement
.flags
.whole_archive
)
3611 || (bfd_get_format (abfd
) == bfd_object
3612 && ((abfd
->flags
) & DYNAMIC
) != 0
3613 && s
->input_statement
.flags
.add_DT_NEEDED_for_regular
3614 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3615 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)))
3617 s
->input_statement
.flags
.loaded
= FALSE
;
3618 s
->input_statement
.flags
.reload
= TRUE
;
3621 os_tail
= lang_os_list
.tail
;
3622 lang_list_init (&add
);
3624 if (!load_symbols (&s
->input_statement
, &add
))
3625 config
.make_executable
= FALSE
;
3627 if (add
.head
!= NULL
)
3629 /* If this was a script with output sections then
3630 tack any added statements on to the end of the
3631 list. This avoids having to reorder the output
3632 section statement list. Very likely the user
3633 forgot -T, and whatever we do here will not meet
3634 naive user expectations. */
3635 if (os_tail
!= lang_os_list
.tail
)
3637 einfo (_("%P: warning: %s contains output sections;"
3638 " did you forget -T?\n"),
3639 s
->input_statement
.filename
);
3640 *stat_ptr
->tail
= add
.head
;
3641 stat_ptr
->tail
= add
.tail
;
3645 *add
.tail
= s
->header
.next
;
3646 s
->header
.next
= add
.head
;
3650 #if BFD_SUPPORTS_PLUGINS
3651 /* If we have found the point at which a plugin added new
3652 files, clear plugin_insert to enable archive rescan. */
3653 if (&s
->input_statement
== plugin_insert
)
3654 plugin_insert
= NULL
;
3657 case lang_assignment_statement_enum
:
3658 if (s
->assignment_statement
.exp
->type
.node_class
!= etree_assert
)
3659 exp_fold_tree_no_dot (s
->assignment_statement
.exp
);
3666 /* Exit if any of the files were missing. */
3667 if (input_flags
.missing_file
)
3671 #ifdef ENABLE_LIBCTF
3672 /* Emit CTF errors and warnings. fp can be NULL to report errors/warnings
3673 that happened specifically at CTF open time. */
3675 lang_ctf_errs_warnings (ctf_dict_t
*fp
)
3677 ctf_next_t
*i
= NULL
;
3682 while ((text
= ctf_errwarning_next (fp
, &i
, &is_warning
, &err
)) != NULL
)
3684 einfo (_("%s: %s\n"), is_warning
? _("CTF warning"): _("CTF error"),
3688 if (err
!= ECTF_NEXT_END
)
3690 einfo (_("CTF error: cannot get CTF errors: `%s'\n"),
3694 /* `err' returns errors from the error/warning iterator in particular.
3695 These never assert. But if we have an fp, that could have recorded
3696 an assertion failure: assert if it has done so. */
3697 ASSERT (!fp
|| ctf_errno (fp
) != ECTF_INTERNAL
);
3700 /* Open the CTF sections in the input files with libctf: if any were opened,
3701 create a fake input file that we'll write the merged CTF data to later
3705 ldlang_open_ctf (void)
3710 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3714 /* Incoming files from the compiler have a single ctf_dict_t in them
3715 (which is presented to us by the libctf API in a ctf_archive_t
3716 wrapper): files derived from a previous relocatable link have a CTF
3717 archive containing possibly many CTF files. */
3719 if ((file
->the_ctf
= ctf_bfdopen (file
->the_bfd
, &err
)) == NULL
)
3721 if (err
!= ECTF_NOCTFDATA
)
3723 lang_ctf_errs_warnings (NULL
);
3724 einfo (_("%P: warning: CTF section in %pB not loaded; "
3725 "its types will be discarded: %s\n"), file
->the_bfd
,
3731 /* Prevent the contents of this section from being written, while
3732 requiring the section itself to be duplicated in the output, but only
3734 /* This section must exist if ctf_bfdopen() succeeded. */
3735 sect
= bfd_get_section_by_name (file
->the_bfd
, ".ctf");
3737 sect
->flags
|= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
| SEC_LINKER_CREATED
;
3740 sect
->flags
|= SEC_EXCLUDE
;
3750 if ((ctf_output
= ctf_create (&err
)) != NULL
)
3753 einfo (_("%P: warning: CTF output not created: `%s'\n"),
3756 LANG_FOR_EACH_INPUT_STATEMENT (errfile
)
3757 ctf_close (errfile
->the_ctf
);
3760 /* Merge together CTF sections. After this, only the symtab-dependent
3761 function and data object sections need adjustment. */
3764 lang_merge_ctf (void)
3766 asection
*output_sect
;
3772 output_sect
= bfd_get_section_by_name (link_info
.output_bfd
, ".ctf");
3774 /* If the section was discarded, don't waste time merging. */
3775 if (output_sect
== NULL
)
3777 ctf_dict_close (ctf_output
);
3780 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3782 ctf_close (file
->the_ctf
);
3783 file
->the_ctf
= NULL
;
3788 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3793 /* Takes ownership of file->the_ctf. */
3794 if (ctf_link_add_ctf (ctf_output
, file
->the_ctf
, file
->filename
) < 0)
3796 einfo (_("%P: warning: CTF section in %pB cannot be linked: `%s'\n"),
3797 file
->the_bfd
, ctf_errmsg (ctf_errno (ctf_output
)));
3798 ctf_close (file
->the_ctf
);
3799 file
->the_ctf
= NULL
;
3804 if (!config
.ctf_share_duplicated
)
3805 flags
= CTF_LINK_SHARE_UNCONFLICTED
;
3807 flags
= CTF_LINK_SHARE_DUPLICATED
;
3808 if (!config
.ctf_variables
)
3809 flags
|= CTF_LINK_OMIT_VARIABLES_SECTION
;
3811 if (ctf_link (ctf_output
, flags
) < 0)
3813 lang_ctf_errs_warnings (ctf_output
);
3814 einfo (_("%P: warning: CTF linking failed; "
3815 "output will have no CTF section: %s\n"),
3816 ctf_errmsg (ctf_errno (ctf_output
)));
3819 output_sect
->size
= 0;
3820 output_sect
->flags
|= SEC_EXCLUDE
;
3823 /* Output any lingering errors that didn't come from ctf_link. */
3824 lang_ctf_errs_warnings (ctf_output
);
3827 /* Let the emulation acquire strings from the dynamic strtab to help it optimize
3828 the CTF, if supported. */
3831 ldlang_ctf_acquire_strings (struct elf_strtab_hash
*dynstrtab
)
3833 ldemul_acquire_strings_for_ctf (ctf_output
, dynstrtab
);
3836 /* Inform the emulation about the addition of a new dynamic symbol, in BFD
3838 void ldlang_ctf_new_dynsym (int symidx
, struct elf_internal_sym
*sym
)
3840 ldemul_new_dynsym_for_ctf (ctf_output
, symidx
, sym
);
3843 /* Write out the CTF section. Called early, if the emulation isn't going to
3844 need to dedup against the strtab and symtab, then possibly called from the
3845 target linker code if the dedup has happened. */
3847 lang_write_ctf (int late
)
3850 asection
*output_sect
;
3857 /* Emit CTF late if this emulation says it can do so. */
3858 if (ldemul_emit_ctf_early ())
3863 if (!ldemul_emit_ctf_early ())
3867 /* Inform the emulation that all the symbols that will be received have
3870 ldemul_new_dynsym_for_ctf (ctf_output
, 0, NULL
);
3874 output_sect
= bfd_get_section_by_name (link_info
.output_bfd
, ".ctf");
3877 output_sect
->contents
= ctf_link_write (ctf_output
, &output_size
,
3878 CTF_COMPRESSION_THRESHOLD
);
3879 output_sect
->size
= output_size
;
3880 output_sect
->flags
|= SEC_IN_MEMORY
| SEC_KEEP
;
3882 lang_ctf_errs_warnings (ctf_output
);
3883 if (!output_sect
->contents
)
3885 einfo (_("%P: warning: CTF section emission failed; "
3886 "output will have no CTF section: %s\n"),
3887 ctf_errmsg (ctf_errno (ctf_output
)));
3888 output_sect
->size
= 0;
3889 output_sect
->flags
|= SEC_EXCLUDE
;
3893 /* This also closes every CTF input file used in the link. */
3894 ctf_dict_close (ctf_output
);
3897 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3898 file
->the_ctf
= NULL
;
3901 /* Write out the CTF section late, if the emulation needs that. */
3904 ldlang_write_ctf_late (void)
3906 /* Trigger a "late call", if the emulation needs one. */
3912 ldlang_open_ctf (void)
3914 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3918 /* If built without CTF, warn and delete all CTF sections from the output.
3919 (The alternative would be to simply concatenate them, which does not
3920 yield a valid CTF section.) */
3922 if ((sect
= bfd_get_section_by_name (file
->the_bfd
, ".ctf")) != NULL
)
3924 einfo (_("%P: warning: CTF section in %pB not linkable: "
3925 "%P was built without support for CTF\n"), file
->the_bfd
);
3927 sect
->flags
|= SEC_EXCLUDE
;
3932 static void lang_merge_ctf (void) {}
3934 ldlang_ctf_acquire_strings (struct elf_strtab_hash
*dynstrtab
3935 ATTRIBUTE_UNUSED
) {}
3937 ldlang_ctf_new_dynsym (int symidx ATTRIBUTE_UNUSED
,
3938 struct elf_internal_sym
*sym ATTRIBUTE_UNUSED
) {}
3939 static void lang_write_ctf (int late ATTRIBUTE_UNUSED
) {}
3940 void ldlang_write_ctf_late (void) {}
3943 /* Add the supplied name to the symbol table as an undefined reference.
3944 This is a two step process as the symbol table doesn't even exist at
3945 the time the ld command line is processed. First we put the name
3946 on a list, then, once the output file has been opened, transfer the
3947 name to the symbol table. */
3949 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3951 #define ldlang_undef_chain_list_head entry_symbol.next
3954 ldlang_add_undef (const char *const name
, bfd_boolean cmdline ATTRIBUTE_UNUSED
)
3956 ldlang_undef_chain_list_type
*new_undef
;
3958 new_undef
= stat_alloc (sizeof (*new_undef
));
3959 new_undef
->next
= ldlang_undef_chain_list_head
;
3960 ldlang_undef_chain_list_head
= new_undef
;
3962 new_undef
->name
= xstrdup (name
);
3964 if (link_info
.output_bfd
!= NULL
)
3965 insert_undefined (new_undef
->name
);
3968 /* Insert NAME as undefined in the symbol table. */
3971 insert_undefined (const char *name
)
3973 struct bfd_link_hash_entry
*h
;
3975 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
3977 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
3978 if (h
->type
== bfd_link_hash_new
)
3980 h
->type
= bfd_link_hash_undefined
;
3981 h
->u
.undef
.abfd
= NULL
;
3982 h
->non_ir_ref_regular
= TRUE
;
3983 if (is_elf_hash_table (link_info
.hash
))
3984 ((struct elf_link_hash_entry
*) h
)->mark
= 1;
3985 bfd_link_add_undef (link_info
.hash
, h
);
3989 /* Run through the list of undefineds created above and place them
3990 into the linker hash table as undefined symbols belonging to the
3994 lang_place_undefineds (void)
3996 ldlang_undef_chain_list_type
*ptr
;
3998 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3999 insert_undefined (ptr
->name
);
4002 /* Structure used to build the list of symbols that the user has required
4005 struct require_defined_symbol
4008 struct require_defined_symbol
*next
;
4011 /* The list of symbols that the user has required be defined. */
4013 static struct require_defined_symbol
*require_defined_symbol_list
;
4015 /* Add a new symbol NAME to the list of symbols that are required to be
4019 ldlang_add_require_defined (const char *const name
)
4021 struct require_defined_symbol
*ptr
;
4023 ldlang_add_undef (name
, TRUE
);
4024 ptr
= stat_alloc (sizeof (*ptr
));
4025 ptr
->next
= require_defined_symbol_list
;
4026 ptr
->name
= strdup (name
);
4027 require_defined_symbol_list
= ptr
;
4030 /* Check that all symbols the user required to be defined, are defined,
4031 raise an error if we find a symbol that is not defined. */
4034 ldlang_check_require_defined_symbols (void)
4036 struct require_defined_symbol
*ptr
;
4038 for (ptr
= require_defined_symbol_list
; ptr
!= NULL
; ptr
= ptr
->next
)
4040 struct bfd_link_hash_entry
*h
;
4042 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
,
4043 FALSE
, FALSE
, TRUE
);
4045 || (h
->type
!= bfd_link_hash_defined
4046 && h
->type
!= bfd_link_hash_defweak
))
4047 einfo(_("%X%P: required symbol `%s' not defined\n"), ptr
->name
);
4051 /* Check for all readonly or some readwrite sections. */
4054 check_input_sections
4055 (lang_statement_union_type
*s
,
4056 lang_output_section_statement_type
*output_section_statement
)
4058 for (; s
!= NULL
; s
= s
->header
.next
)
4060 switch (s
->header
.type
)
4062 case lang_wild_statement_enum
:
4063 walk_wild (&s
->wild_statement
, check_section_callback
,
4064 output_section_statement
);
4065 if (!output_section_statement
->all_input_readonly
)
4068 case lang_constructors_statement_enum
:
4069 check_input_sections (constructor_list
.head
,
4070 output_section_statement
);
4071 if (!output_section_statement
->all_input_readonly
)
4074 case lang_group_statement_enum
:
4075 check_input_sections (s
->group_statement
.children
.head
,
4076 output_section_statement
);
4077 if (!output_section_statement
->all_input_readonly
)
4086 /* Update wildcard statements if needed. */
4089 update_wild_statements (lang_statement_union_type
*s
)
4091 struct wildcard_list
*sec
;
4093 switch (sort_section
)
4103 for (; s
!= NULL
; s
= s
->header
.next
)
4105 switch (s
->header
.type
)
4110 case lang_wild_statement_enum
:
4111 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
4113 /* Don't sort .init/.fini sections. */
4114 if (strcmp (sec
->spec
.name
, ".init") != 0
4115 && strcmp (sec
->spec
.name
, ".fini") != 0)
4116 switch (sec
->spec
.sorted
)
4119 sec
->spec
.sorted
= sort_section
;
4122 if (sort_section
== by_alignment
)
4123 sec
->spec
.sorted
= by_name_alignment
;
4126 if (sort_section
== by_name
)
4127 sec
->spec
.sorted
= by_alignment_name
;
4134 case lang_constructors_statement_enum
:
4135 update_wild_statements (constructor_list
.head
);
4138 case lang_output_section_statement_enum
:
4139 update_wild_statements
4140 (s
->output_section_statement
.children
.head
);
4143 case lang_group_statement_enum
:
4144 update_wild_statements (s
->group_statement
.children
.head
);
4152 /* Open input files and attach to output sections. */
4155 map_input_to_output_sections
4156 (lang_statement_union_type
*s
, const char *target
,
4157 lang_output_section_statement_type
*os
)
4159 for (; s
!= NULL
; s
= s
->header
.next
)
4161 lang_output_section_statement_type
*tos
;
4164 switch (s
->header
.type
)
4166 case lang_wild_statement_enum
:
4167 wild (&s
->wild_statement
, target
, os
);
4169 case lang_constructors_statement_enum
:
4170 map_input_to_output_sections (constructor_list
.head
,
4174 case lang_output_section_statement_enum
:
4175 tos
= &s
->output_section_statement
;
4176 if (tos
->constraint
== ONLY_IF_RW
4177 || tos
->constraint
== ONLY_IF_RO
)
4179 tos
->all_input_readonly
= TRUE
;
4180 check_input_sections (tos
->children
.head
, tos
);
4181 if (tos
->all_input_readonly
!= (tos
->constraint
== ONLY_IF_RO
))
4182 tos
->constraint
= -1;
4184 if (tos
->constraint
>= 0)
4185 map_input_to_output_sections (tos
->children
.head
,
4189 case lang_output_statement_enum
:
4191 case lang_target_statement_enum
:
4192 target
= s
->target_statement
.target
;
4194 case lang_group_statement_enum
:
4195 map_input_to_output_sections (s
->group_statement
.children
.head
,
4199 case lang_data_statement_enum
:
4200 /* Make sure that any sections mentioned in the expression
4202 exp_init_os (s
->data_statement
.exp
);
4203 /* The output section gets CONTENTS, ALLOC and LOAD, but
4204 these may be overridden by the script. */
4205 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
;
4206 switch (os
->sectype
)
4208 case normal_section
:
4209 case overlay_section
:
4210 case first_overlay_section
:
4212 case noalloc_section
:
4213 flags
= SEC_HAS_CONTENTS
;
4215 case noload_section
:
4216 if (bfd_get_flavour (link_info
.output_bfd
)
4217 == bfd_target_elf_flavour
)
4218 flags
= SEC_NEVER_LOAD
| SEC_ALLOC
;
4220 flags
= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
;
4223 if (os
->bfd_section
== NULL
)
4224 init_os (os
, flags
);
4226 os
->bfd_section
->flags
|= flags
;
4228 case lang_input_section_enum
:
4230 case lang_fill_statement_enum
:
4231 case lang_object_symbols_statement_enum
:
4232 case lang_reloc_statement_enum
:
4233 case lang_padding_statement_enum
:
4234 case lang_input_statement_enum
:
4235 if (os
!= NULL
&& os
->bfd_section
== NULL
)
4238 case lang_assignment_statement_enum
:
4239 if (os
!= NULL
&& os
->bfd_section
== NULL
)
4242 /* Make sure that any sections mentioned in the assignment
4244 exp_init_os (s
->assignment_statement
.exp
);
4246 case lang_address_statement_enum
:
4247 /* Mark the specified section with the supplied address.
4248 If this section was actually a segment marker, then the
4249 directive is ignored if the linker script explicitly
4250 processed the segment marker. Originally, the linker
4251 treated segment directives (like -Ttext on the
4252 command-line) as section directives. We honor the
4253 section directive semantics for backwards compatibility;
4254 linker scripts that do not specifically check for
4255 SEGMENT_START automatically get the old semantics. */
4256 if (!s
->address_statement
.segment
4257 || !s
->address_statement
.segment
->used
)
4259 const char *name
= s
->address_statement
.section_name
;
4261 /* Create the output section statement here so that
4262 orphans with a set address will be placed after other
4263 script sections. If we let the orphan placement code
4264 place them in amongst other sections then the address
4265 will affect following script sections, which is
4266 likely to surprise naive users. */
4267 tos
= lang_output_section_statement_lookup (name
, 0, 1);
4268 tos
->addr_tree
= s
->address_statement
.address
;
4269 if (tos
->bfd_section
== NULL
)
4273 case lang_insert_statement_enum
:
4279 /* An insert statement snips out all the linker statements from the
4280 start of the list and places them after the output section
4281 statement specified by the insert. This operation is complicated
4282 by the fact that we keep a doubly linked list of output section
4283 statements as well as the singly linked list of all statements.
4284 FIXME someday: Twiddling with the list not only moves statements
4285 from the user's script but also input and group statements that are
4286 built from command line object files and --start-group. We only
4287 get away with this because the list pointers used by file_chain
4288 and input_file_chain are not reordered, and processing via
4289 statement_list after this point mostly ignores input statements.
4290 One exception is the map file, where LOAD and START GROUP/END GROUP
4291 can end up looking odd. */
4294 process_insert_statements (lang_statement_union_type
**start
)
4296 lang_statement_union_type
**s
;
4297 lang_output_section_statement_type
*first_os
= NULL
;
4298 lang_output_section_statement_type
*last_os
= NULL
;
4299 lang_output_section_statement_type
*os
;
4304 if ((*s
)->header
.type
== lang_output_section_statement_enum
)
4306 /* Keep pointers to the first and last output section
4307 statement in the sequence we may be about to move. */
4308 os
= &(*s
)->output_section_statement
;
4310 ASSERT (last_os
== NULL
|| last_os
->next
== os
);
4313 /* Set constraint negative so that lang_output_section_find
4314 won't match this output section statement. At this
4315 stage in linking constraint has values in the range
4316 [-1, ONLY_IN_RW]. */
4317 last_os
->constraint
= -2 - last_os
->constraint
;
4318 if (first_os
== NULL
)
4321 else if ((*s
)->header
.type
== lang_group_statement_enum
)
4323 /* A user might put -T between --start-group and
4324 --end-group. One way this odd construct might arise is
4325 from a wrapper around ld to change library search
4326 behaviour. For example:
4328 exec real_ld --start-group "$@" --end-group
4329 This isn't completely unreasonable so go looking inside a
4330 group statement for insert statements. */
4331 process_insert_statements (&(*s
)->group_statement
.children
.head
);
4333 else if ((*s
)->header
.type
== lang_insert_statement_enum
)
4335 lang_insert_statement_type
*i
= &(*s
)->insert_statement
;
4336 lang_output_section_statement_type
*where
;
4337 lang_statement_union_type
**ptr
;
4338 lang_statement_union_type
*first
;
4340 if (link_info
.non_contiguous_regions
)
4342 einfo (_("warning: INSERT statement in linker script is "
4343 "incompatible with --enable-non-contiguous-regions.\n"));
4346 where
= lang_output_section_find (i
->where
);
4347 if (where
!= NULL
&& i
->is_before
)
4350 where
= where
->prev
;
4351 while (where
!= NULL
&& where
->constraint
< 0);
4355 einfo (_("%F%P: %s not found for insert\n"), i
->where
);
4359 /* Deal with reordering the output section statement list. */
4360 if (last_os
!= NULL
)
4362 asection
*first_sec
, *last_sec
;
4363 struct lang_output_section_statement_struct
**next
;
4365 /* Snip out the output sections we are moving. */
4366 first_os
->prev
->next
= last_os
->next
;
4367 if (last_os
->next
== NULL
)
4369 next
= &first_os
->prev
->next
;
4370 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4373 last_os
->next
->prev
= first_os
->prev
;
4374 /* Add them in at the new position. */
4375 last_os
->next
= where
->next
;
4376 if (where
->next
== NULL
)
4378 next
= &last_os
->next
;
4379 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4382 where
->next
->prev
= last_os
;
4383 first_os
->prev
= where
;
4384 where
->next
= first_os
;
4386 /* Move the bfd sections in the same way. */
4389 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4391 os
->constraint
= -2 - os
->constraint
;
4392 if (os
->bfd_section
!= NULL
4393 && os
->bfd_section
->owner
!= NULL
)
4395 last_sec
= os
->bfd_section
;
4396 if (first_sec
== NULL
)
4397 first_sec
= last_sec
;
4402 if (last_sec
!= NULL
)
4404 asection
*sec
= where
->bfd_section
;
4406 sec
= output_prev_sec_find (where
);
4408 /* The place we want to insert must come after the
4409 sections we are moving. So if we find no
4410 section or if the section is the same as our
4411 last section, then no move is needed. */
4412 if (sec
!= NULL
&& sec
!= last_sec
)
4414 /* Trim them off. */
4415 if (first_sec
->prev
!= NULL
)
4416 first_sec
->prev
->next
= last_sec
->next
;
4418 link_info
.output_bfd
->sections
= last_sec
->next
;
4419 if (last_sec
->next
!= NULL
)
4420 last_sec
->next
->prev
= first_sec
->prev
;
4422 link_info
.output_bfd
->section_last
= first_sec
->prev
;
4424 last_sec
->next
= sec
->next
;
4425 if (sec
->next
!= NULL
)
4426 sec
->next
->prev
= last_sec
;
4428 link_info
.output_bfd
->section_last
= last_sec
;
4429 first_sec
->prev
= sec
;
4430 sec
->next
= first_sec
;
4438 ptr
= insert_os_after (where
);
4439 /* Snip everything from the start of the list, up to and
4440 including the insert statement we are currently processing. */
4442 *start
= (*s
)->header
.next
;
4443 /* Add them back where they belong, minus the insert. */
4446 statement_list
.tail
= s
;
4451 s
= &(*s
)->header
.next
;
4454 /* Undo constraint twiddling. */
4455 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4457 os
->constraint
= -2 - os
->constraint
;
4463 /* An output section might have been removed after its statement was
4464 added. For example, ldemul_before_allocation can remove dynamic
4465 sections if they turn out to be not needed. Clean them up here. */
4468 strip_excluded_output_sections (void)
4470 lang_output_section_statement_type
*os
;
4472 /* Run lang_size_sections (if not already done). */
4473 if (expld
.phase
!= lang_mark_phase_enum
)
4475 expld
.phase
= lang_mark_phase_enum
;
4476 expld
.dataseg
.phase
= exp_seg_none
;
4477 one_lang_size_sections_pass (NULL
, FALSE
);
4478 lang_reset_memory_regions ();
4481 for (os
= (void *) lang_os_list
.head
;
4485 asection
*output_section
;
4486 bfd_boolean exclude
;
4488 if (os
->constraint
< 0)
4491 output_section
= os
->bfd_section
;
4492 if (output_section
== NULL
)
4495 exclude
= (output_section
->rawsize
== 0
4496 && (output_section
->flags
& SEC_KEEP
) == 0
4497 && !bfd_section_removed_from_list (link_info
.output_bfd
,
4500 /* Some sections have not yet been sized, notably .gnu.version,
4501 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
4502 input sections, so don't drop output sections that have such
4503 input sections unless they are also marked SEC_EXCLUDE. */
4504 if (exclude
&& output_section
->map_head
.s
!= NULL
)
4508 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
4509 if ((s
->flags
& SEC_EXCLUDE
) == 0
4510 && ((s
->flags
& SEC_LINKER_CREATED
) != 0
4511 || link_info
.emitrelocations
))
4520 /* We don't set bfd_section to NULL since bfd_section of the
4521 removed output section statement may still be used. */
4522 if (!os
->update_dot
)
4524 output_section
->flags
|= SEC_EXCLUDE
;
4525 bfd_section_list_remove (link_info
.output_bfd
, output_section
);
4526 link_info
.output_bfd
->section_count
--;
4531 /* Called from ldwrite to clear out asection.map_head and
4532 asection.map_tail for use as link_orders in ldwrite. */
4535 lang_clear_os_map (void)
4537 lang_output_section_statement_type
*os
;
4539 if (map_head_is_link_order
)
4542 for (os
= (void *) lang_os_list
.head
;
4546 asection
*output_section
;
4548 if (os
->constraint
< 0)
4551 output_section
= os
->bfd_section
;
4552 if (output_section
== NULL
)
4555 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
4556 output_section
->map_head
.link_order
= NULL
;
4557 output_section
->map_tail
.link_order
= NULL
;
4560 /* Stop future calls to lang_add_section from messing with map_head
4561 and map_tail link_order fields. */
4562 map_head_is_link_order
= TRUE
;
4566 print_output_section_statement
4567 (lang_output_section_statement_type
*output_section_statement
)
4569 asection
*section
= output_section_statement
->bfd_section
;
4572 if (output_section_statement
!= abs_output_section
)
4574 minfo ("\n%s", output_section_statement
->name
);
4576 if (section
!= NULL
)
4578 print_dot
= section
->vma
;
4580 len
= strlen (output_section_statement
->name
);
4581 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4586 while (len
< SECTION_NAME_MAP_LENGTH
)
4592 minfo ("0x%V %W", section
->vma
, TO_ADDR (section
->size
));
4594 if (section
->vma
!= section
->lma
)
4595 minfo (_(" load address 0x%V"), section
->lma
);
4597 if (output_section_statement
->update_dot_tree
!= NULL
)
4598 exp_fold_tree (output_section_statement
->update_dot_tree
,
4599 bfd_abs_section_ptr
, &print_dot
);
4605 print_statement_list (output_section_statement
->children
.head
,
4606 output_section_statement
);
4610 print_assignment (lang_assignment_statement_type
*assignment
,
4611 lang_output_section_statement_type
*output_section
)
4618 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4621 if (assignment
->exp
->type
.node_class
== etree_assert
)
4624 tree
= assignment
->exp
->assert_s
.child
;
4628 const char *dst
= assignment
->exp
->assign
.dst
;
4630 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
4631 tree
= assignment
->exp
;
4634 osec
= output_section
->bfd_section
;
4636 osec
= bfd_abs_section_ptr
;
4638 if (assignment
->exp
->type
.node_class
!= etree_provide
)
4639 exp_fold_tree (tree
, osec
, &print_dot
);
4641 expld
.result
.valid_p
= FALSE
;
4643 if (expld
.result
.valid_p
)
4647 if (assignment
->exp
->type
.node_class
== etree_assert
4649 || expld
.assign_name
!= NULL
)
4651 value
= expld
.result
.value
;
4653 if (expld
.result
.section
!= NULL
)
4654 value
+= expld
.result
.section
->vma
;
4656 minfo ("0x%V", value
);
4662 struct bfd_link_hash_entry
*h
;
4664 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
4665 FALSE
, FALSE
, TRUE
);
4667 && (h
->type
== bfd_link_hash_defined
4668 || h
->type
== bfd_link_hash_defweak
))
4670 value
= h
->u
.def
.value
;
4671 value
+= h
->u
.def
.section
->output_section
->vma
;
4672 value
+= h
->u
.def
.section
->output_offset
;
4674 minfo ("[0x%V]", value
);
4677 minfo ("[unresolved]");
4682 if (assignment
->exp
->type
.node_class
== etree_provide
)
4683 minfo ("[!provide]");
4690 expld
.assign_name
= NULL
;
4693 exp_print_tree (assignment
->exp
);
4698 print_input_statement (lang_input_statement_type
*statm
)
4700 if (statm
->filename
!= NULL
)
4701 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
4704 /* Print all symbols defined in a particular section. This is called
4705 via bfd_link_hash_traverse, or by print_all_symbols. */
4708 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
4710 asection
*sec
= (asection
*) ptr
;
4712 if ((hash_entry
->type
== bfd_link_hash_defined
4713 || hash_entry
->type
== bfd_link_hash_defweak
)
4714 && sec
== hash_entry
->u
.def
.section
)
4718 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4721 (hash_entry
->u
.def
.value
4722 + hash_entry
->u
.def
.section
->output_offset
4723 + hash_entry
->u
.def
.section
->output_section
->vma
));
4725 minfo (" %pT\n", hash_entry
->root
.string
);
4732 hash_entry_addr_cmp (const void *a
, const void *b
)
4734 const struct bfd_link_hash_entry
*l
= *(const struct bfd_link_hash_entry
**)a
;
4735 const struct bfd_link_hash_entry
*r
= *(const struct bfd_link_hash_entry
**)b
;
4737 if (l
->u
.def
.value
< r
->u
.def
.value
)
4739 else if (l
->u
.def
.value
> r
->u
.def
.value
)
4746 print_all_symbols (asection
*sec
)
4748 input_section_userdata_type
*ud
= bfd_section_userdata (sec
);
4749 struct map_symbol_def
*def
;
4750 struct bfd_link_hash_entry
**entries
;
4756 *ud
->map_symbol_def_tail
= 0;
4758 /* Sort the symbols by address. */
4759 entries
= (struct bfd_link_hash_entry
**)
4760 obstack_alloc (&map_obstack
,
4761 ud
->map_symbol_def_count
* sizeof (*entries
));
4763 for (i
= 0, def
= ud
->map_symbol_def_head
; def
; def
= def
->next
, i
++)
4764 entries
[i
] = def
->entry
;
4766 qsort (entries
, ud
->map_symbol_def_count
, sizeof (*entries
),
4767 hash_entry_addr_cmp
);
4769 /* Print the symbols. */
4770 for (i
= 0; i
< ud
->map_symbol_def_count
; i
++)
4771 ldemul_print_symbol (entries
[i
], sec
);
4773 obstack_free (&map_obstack
, entries
);
4776 /* Print information about an input section to the map file. */
4779 print_input_section (asection
*i
, bfd_boolean is_discarded
)
4781 bfd_size_type size
= i
->size
;
4788 minfo ("%s", i
->name
);
4790 len
= 1 + strlen (i
->name
);
4791 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4796 while (len
< SECTION_NAME_MAP_LENGTH
)
4802 if (i
->output_section
!= NULL
4803 && i
->output_section
->owner
== link_info
.output_bfd
)
4804 addr
= i
->output_section
->vma
+ i
->output_offset
;
4812 minfo ("0x%V %W %pB\n", addr
, TO_ADDR (size
), i
->owner
);
4814 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
4816 len
= SECTION_NAME_MAP_LENGTH
+ 3;
4828 minfo (_("%W (size before relaxing)\n"), TO_ADDR (i
->rawsize
));
4831 if (i
->output_section
!= NULL
4832 && i
->output_section
->owner
== link_info
.output_bfd
)
4834 if (link_info
.reduce_memory_overheads
)
4835 bfd_link_hash_traverse (link_info
.hash
, ldemul_print_symbol
, i
);
4837 print_all_symbols (i
);
4839 /* Update print_dot, but make sure that we do not move it
4840 backwards - this could happen if we have overlays and a
4841 later overlay is shorter than an earier one. */
4842 if (addr
+ TO_ADDR (size
) > print_dot
)
4843 print_dot
= addr
+ TO_ADDR (size
);
4848 print_fill_statement (lang_fill_statement_type
*fill
)
4852 fputs (" FILL mask 0x", config
.map_file
);
4853 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
4854 fprintf (config
.map_file
, "%02x", *p
);
4855 fputs ("\n", config
.map_file
);
4859 print_data_statement (lang_data_statement_type
*data
)
4866 init_opb (data
->output_section
);
4867 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4870 addr
= data
->output_offset
;
4871 if (data
->output_section
!= NULL
)
4872 addr
+= data
->output_section
->vma
;
4900 if (size
< TO_SIZE ((unsigned) 1))
4901 size
= TO_SIZE ((unsigned) 1);
4902 minfo ("0x%V %W %s 0x%v", addr
, TO_ADDR (size
), name
, data
->value
);
4904 if (data
->exp
->type
.node_class
!= etree_value
)
4907 exp_print_tree (data
->exp
);
4912 print_dot
= addr
+ TO_ADDR (size
);
4915 /* Print an address statement. These are generated by options like
4919 print_address_statement (lang_address_statement_type
*address
)
4921 minfo (_("Address of section %s set to "), address
->section_name
);
4922 exp_print_tree (address
->address
);
4926 /* Print a reloc statement. */
4929 print_reloc_statement (lang_reloc_statement_type
*reloc
)
4935 init_opb (reloc
->output_section
);
4936 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4939 addr
= reloc
->output_offset
;
4940 if (reloc
->output_section
!= NULL
)
4941 addr
+= reloc
->output_section
->vma
;
4943 size
= bfd_get_reloc_size (reloc
->howto
);
4945 minfo ("0x%V %W RELOC %s ", addr
, TO_ADDR (size
), reloc
->howto
->name
);
4947 if (reloc
->name
!= NULL
)
4948 minfo ("%s+", reloc
->name
);
4950 minfo ("%s+", reloc
->section
->name
);
4952 exp_print_tree (reloc
->addend_exp
);
4956 print_dot
= addr
+ TO_ADDR (size
);
4960 print_padding_statement (lang_padding_statement_type
*s
)
4965 init_opb (s
->output_section
);
4968 len
= sizeof " *fill*" - 1;
4969 while (len
< SECTION_NAME_MAP_LENGTH
)
4975 addr
= s
->output_offset
;
4976 if (s
->output_section
!= NULL
)
4977 addr
+= s
->output_section
->vma
;
4978 minfo ("0x%V %W ", addr
, TO_ADDR (s
->size
));
4980 if (s
->fill
->size
!= 0)
4984 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
4985 fprintf (config
.map_file
, "%02x", *p
);
4990 print_dot
= addr
+ TO_ADDR (s
->size
);
4994 print_wild_statement (lang_wild_statement_type
*w
,
4995 lang_output_section_statement_type
*os
)
4997 struct wildcard_list
*sec
;
5001 if (w
->exclude_name_list
)
5004 minfo ("EXCLUDE_FILE(%s", w
->exclude_name_list
->name
);
5005 for (tmp
= w
->exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
5006 minfo (" %s", tmp
->name
);
5010 if (w
->filenames_sorted
)
5011 minfo ("SORT_BY_NAME(");
5012 if (w
->filename
!= NULL
)
5013 minfo ("%s", w
->filename
);
5016 if (w
->filenames_sorted
)
5020 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
5022 int closing_paren
= 0;
5024 switch (sec
->spec
.sorted
)
5030 minfo ("SORT_BY_NAME(");
5035 minfo ("SORT_BY_ALIGNMENT(");
5039 case by_name_alignment
:
5040 minfo ("SORT_BY_NAME(SORT_BY_ALIGNMENT(");
5044 case by_alignment_name
:
5045 minfo ("SORT_BY_ALIGNMENT(SORT_BY_NAME(");
5050 minfo ("SORT_NONE(");
5054 case by_init_priority
:
5055 minfo ("SORT_BY_INIT_PRIORITY(");
5060 if (sec
->spec
.exclude_name_list
!= NULL
)
5063 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
5064 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
5065 minfo (" %s", tmp
->name
);
5068 if (sec
->spec
.name
!= NULL
)
5069 minfo ("%s", sec
->spec
.name
);
5072 for (;closing_paren
> 0; closing_paren
--)
5081 print_statement_list (w
->children
.head
, os
);
5084 /* Print a group statement. */
5087 print_group (lang_group_statement_type
*s
,
5088 lang_output_section_statement_type
*os
)
5090 fprintf (config
.map_file
, "START GROUP\n");
5091 print_statement_list (s
->children
.head
, os
);
5092 fprintf (config
.map_file
, "END GROUP\n");
5095 /* Print the list of statements in S.
5096 This can be called for any statement type. */
5099 print_statement_list (lang_statement_union_type
*s
,
5100 lang_output_section_statement_type
*os
)
5104 print_statement (s
, os
);
5109 /* Print the first statement in statement list S.
5110 This can be called for any statement type. */
5113 print_statement (lang_statement_union_type
*s
,
5114 lang_output_section_statement_type
*os
)
5116 switch (s
->header
.type
)
5119 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
5122 case lang_constructors_statement_enum
:
5123 if (constructor_list
.head
!= NULL
)
5125 if (constructors_sorted
)
5126 minfo (" SORT (CONSTRUCTORS)\n");
5128 minfo (" CONSTRUCTORS\n");
5129 print_statement_list (constructor_list
.head
, os
);
5132 case lang_wild_statement_enum
:
5133 print_wild_statement (&s
->wild_statement
, os
);
5135 case lang_address_statement_enum
:
5136 print_address_statement (&s
->address_statement
);
5138 case lang_object_symbols_statement_enum
:
5139 minfo (" CREATE_OBJECT_SYMBOLS\n");
5141 case lang_fill_statement_enum
:
5142 print_fill_statement (&s
->fill_statement
);
5144 case lang_data_statement_enum
:
5145 print_data_statement (&s
->data_statement
);
5147 case lang_reloc_statement_enum
:
5148 print_reloc_statement (&s
->reloc_statement
);
5150 case lang_input_section_enum
:
5151 print_input_section (s
->input_section
.section
, FALSE
);
5153 case lang_padding_statement_enum
:
5154 print_padding_statement (&s
->padding_statement
);
5156 case lang_output_section_statement_enum
:
5157 print_output_section_statement (&s
->output_section_statement
);
5159 case lang_assignment_statement_enum
:
5160 print_assignment (&s
->assignment_statement
, os
);
5162 case lang_target_statement_enum
:
5163 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
5165 case lang_output_statement_enum
:
5166 minfo ("OUTPUT(%s", s
->output_statement
.name
);
5167 if (output_target
!= NULL
)
5168 minfo (" %s", output_target
);
5171 case lang_input_statement_enum
:
5172 print_input_statement (&s
->input_statement
);
5174 case lang_group_statement_enum
:
5175 print_group (&s
->group_statement
, os
);
5177 case lang_insert_statement_enum
:
5178 minfo ("INSERT %s %s\n",
5179 s
->insert_statement
.is_before
? "BEFORE" : "AFTER",
5180 s
->insert_statement
.where
);
5186 print_statements (void)
5188 print_statement_list (statement_list
.head
, abs_output_section
);
5191 /* Print the first N statements in statement list S to STDERR.
5192 If N == 0, nothing is printed.
5193 If N < 0, the entire list is printed.
5194 Intended to be called from GDB. */
5197 dprint_statement (lang_statement_union_type
*s
, int n
)
5199 FILE *map_save
= config
.map_file
;
5201 config
.map_file
= stderr
;
5204 print_statement_list (s
, abs_output_section
);
5207 while (s
&& --n
>= 0)
5209 print_statement (s
, abs_output_section
);
5214 config
.map_file
= map_save
;
5218 insert_pad (lang_statement_union_type
**ptr
,
5220 bfd_size_type alignment_needed
,
5221 asection
*output_section
,
5224 static fill_type zero_fill
;
5225 lang_statement_union_type
*pad
= NULL
;
5227 if (ptr
!= &statement_list
.head
)
5228 pad
= ((lang_statement_union_type
*)
5229 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
5231 && pad
->header
.type
== lang_padding_statement_enum
5232 && pad
->padding_statement
.output_section
== output_section
)
5234 /* Use the existing pad statement. */
5236 else if ((pad
= *ptr
) != NULL
5237 && pad
->header
.type
== lang_padding_statement_enum
5238 && pad
->padding_statement
.output_section
== output_section
)
5240 /* Use the existing pad statement. */
5244 /* Make a new padding statement, linked into existing chain. */
5245 pad
= stat_alloc (sizeof (lang_padding_statement_type
));
5246 pad
->header
.next
= *ptr
;
5248 pad
->header
.type
= lang_padding_statement_enum
;
5249 pad
->padding_statement
.output_section
= output_section
;
5252 pad
->padding_statement
.fill
= fill
;
5254 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
5255 pad
->padding_statement
.size
= alignment_needed
;
5256 if (!(output_section
->flags
& SEC_FIXED_SIZE
))
5257 output_section
->size
= TO_SIZE (dot
+ TO_ADDR (alignment_needed
)
5258 - output_section
->vma
);
5261 /* Work out how much this section will move the dot point. */
5265 (lang_statement_union_type
**this_ptr
,
5266 lang_output_section_statement_type
*output_section_statement
,
5268 bfd_boolean
*removed
,
5271 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
5272 asection
*i
= is
->section
;
5273 asection
*o
= output_section_statement
->bfd_section
;
5276 if (link_info
.non_contiguous_regions
)
5278 /* If the input section I has already been successfully assigned
5279 to an output section other than O, don't bother with it and
5280 let the caller remove it from the list. Keep processing in
5281 case we have already handled O, because the repeated passes
5282 have reinitialized its size. */
5283 if (i
->already_assigned
&& i
->already_assigned
!= o
)
5290 if (i
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
5291 i
->output_offset
= i
->vma
- o
->vma
;
5292 else if (((i
->flags
& SEC_EXCLUDE
) != 0)
5293 || output_section_statement
->ignored
)
5294 i
->output_offset
= dot
- o
->vma
;
5297 bfd_size_type alignment_needed
;
5299 /* Align this section first to the input sections requirement,
5300 then to the output section's requirement. If this alignment
5301 is greater than any seen before, then record it too. Perform
5302 the alignment by inserting a magic 'padding' statement. */
5304 if (output_section_statement
->subsection_alignment
!= NULL
)
5306 = exp_get_power (output_section_statement
->subsection_alignment
,
5307 "subsection alignment");
5309 if (o
->alignment_power
< i
->alignment_power
)
5310 o
->alignment_power
= i
->alignment_power
;
5312 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
5314 if (alignment_needed
!= 0)
5316 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
5317 dot
+= alignment_needed
;
5320 if (link_info
.non_contiguous_regions
)
5322 /* If I would overflow O, let the caller remove I from the
5324 if (output_section_statement
->region
)
5326 bfd_vma end
= output_section_statement
->region
->origin
5327 + output_section_statement
->region
->length
;
5329 if (dot
+ TO_ADDR (i
->size
) > end
)
5331 if (i
->flags
& SEC_LINKER_CREATED
)
5332 einfo (_("%F%P: Output section '%s' not large enough for the "
5333 "linker-created stubs section '%s'.\n"),
5334 i
->output_section
->name
, i
->name
);
5336 if (i
->rawsize
&& i
->rawsize
!= i
->size
)
5337 einfo (_("%F%P: Relaxation not supported with "
5338 "--enable-non-contiguous-regions (section '%s' "
5339 "would overflow '%s' after it changed size).\n"),
5340 i
->name
, i
->output_section
->name
);
5344 i
->output_section
= NULL
;
5350 /* Remember where in the output section this input section goes. */
5351 i
->output_offset
= dot
- o
->vma
;
5353 /* Mark how big the output section must be to contain this now. */
5354 dot
+= TO_ADDR (i
->size
);
5355 if (!(o
->flags
& SEC_FIXED_SIZE
))
5356 o
->size
= TO_SIZE (dot
- o
->vma
);
5358 if (link_info
.non_contiguous_regions
)
5360 /* Record that I was successfully assigned to O, and update
5361 its actual output section too. */
5362 i
->already_assigned
= o
;
5363 i
->output_section
= o
;
5377 sort_sections_by_lma (const void *arg1
, const void *arg2
)
5379 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
5380 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
5382 if (sec1
->lma
< sec2
->lma
)
5384 else if (sec1
->lma
> sec2
->lma
)
5386 else if (sec1
->id
< sec2
->id
)
5388 else if (sec1
->id
> sec2
->id
)
5395 sort_sections_by_vma (const void *arg1
, const void *arg2
)
5397 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
5398 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
5400 if (sec1
->vma
< sec2
->vma
)
5402 else if (sec1
->vma
> sec2
->vma
)
5404 else if (sec1
->id
< sec2
->id
)
5406 else if (sec1
->id
> sec2
->id
)
5412 #define IS_TBSS(s) \
5413 ((s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == SEC_THREAD_LOCAL)
5415 #define IGNORE_SECTION(s) \
5416 ((s->flags & SEC_ALLOC) == 0 || IS_TBSS (s))
5418 /* Check to see if any allocated sections overlap with other allocated
5419 sections. This can happen if a linker script specifies the output
5420 section addresses of the two sections. Also check whether any memory
5421 region has overflowed. */
5424 lang_check_section_addresses (void)
5427 struct check_sec
*sections
;
5432 bfd_vma p_start
= 0;
5434 lang_memory_region_type
*m
;
5435 bfd_boolean overlays
;
5437 /* Detect address space overflow on allocated sections. */
5438 addr_mask
= ((bfd_vma
) 1 <<
5439 (bfd_arch_bits_per_address (link_info
.output_bfd
) - 1)) - 1;
5440 addr_mask
= (addr_mask
<< 1) + 1;
5441 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5442 if ((s
->flags
& SEC_ALLOC
) != 0)
5444 s_end
= (s
->vma
+ s
->size
) & addr_mask
;
5445 if (s_end
!= 0 && s_end
< (s
->vma
& addr_mask
))
5446 einfo (_("%X%P: section %s VMA wraps around address space\n"),
5450 s_end
= (s
->lma
+ s
->size
) & addr_mask
;
5451 if (s_end
!= 0 && s_end
< (s
->lma
& addr_mask
))
5452 einfo (_("%X%P: section %s LMA wraps around address space\n"),
5457 if (bfd_count_sections (link_info
.output_bfd
) <= 1)
5460 count
= bfd_count_sections (link_info
.output_bfd
);
5461 sections
= XNEWVEC (struct check_sec
, count
);
5463 /* Scan all sections in the output list. */
5465 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5467 if (IGNORE_SECTION (s
)
5471 sections
[count
].sec
= s
;
5472 sections
[count
].warned
= FALSE
;
5482 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_lma
);
5484 /* First check section LMAs. There should be no overlap of LMAs on
5485 loadable sections, even with overlays. */
5486 for (p
= NULL
, i
= 0; i
< count
; i
++)
5488 s
= sections
[i
].sec
;
5490 if ((s
->flags
& SEC_LOAD
) != 0)
5493 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5495 /* Look for an overlap. We have sorted sections by lma, so
5496 we know that s_start >= p_start. Besides the obvious
5497 case of overlap when the current section starts before
5498 the previous one ends, we also must have overlap if the
5499 previous section wraps around the address space. */
5501 && (s_start
<= p_end
5502 || p_end
< p_start
))
5504 einfo (_("%X%P: section %s LMA [%V,%V]"
5505 " overlaps section %s LMA [%V,%V]\n"),
5506 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5507 sections
[i
].warned
= TRUE
;
5515 /* If any non-zero size allocated section (excluding tbss) starts at
5516 exactly the same VMA as another such section, then we have
5517 overlays. Overlays generated by the OVERLAY keyword will have
5518 this property. It is possible to intentionally generate overlays
5519 that fail this test, but it would be unusual. */
5520 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_vma
);
5522 p_start
= sections
[0].sec
->vma
;
5523 for (i
= 1; i
< count
; i
++)
5525 s_start
= sections
[i
].sec
->vma
;
5526 if (p_start
== s_start
)
5534 /* Now check section VMAs if no overlays were detected. */
5537 for (p
= NULL
, i
= 0; i
< count
; i
++)
5539 s
= sections
[i
].sec
;
5542 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5545 && !sections
[i
].warned
5546 && (s_start
<= p_end
5547 || p_end
< p_start
))
5548 einfo (_("%X%P: section %s VMA [%V,%V]"
5549 " overlaps section %s VMA [%V,%V]\n"),
5550 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5559 /* If any memory region has overflowed, report by how much.
5560 We do not issue this diagnostic for regions that had sections
5561 explicitly placed outside their bounds; os_region_check's
5562 diagnostics are adequate for that case.
5564 FIXME: It is conceivable that m->current - (m->origin + m->length)
5565 might overflow a 32-bit integer. There is, alas, no way to print
5566 a bfd_vma quantity in decimal. */
5567 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
5568 if (m
->had_full_message
)
5570 unsigned long over
= m
->current
- (m
->origin
+ m
->length
);
5571 einfo (ngettext ("%X%P: region `%s' overflowed by %lu byte\n",
5572 "%X%P: region `%s' overflowed by %lu bytes\n",
5574 m
->name_list
.name
, over
);
5578 /* Make sure the new address is within the region. We explicitly permit the
5579 current address to be at the exact end of the region when the address is
5580 non-zero, in case the region is at the end of addressable memory and the
5581 calculation wraps around. */
5584 os_region_check (lang_output_section_statement_type
*os
,
5585 lang_memory_region_type
*region
,
5589 if ((region
->current
< region
->origin
5590 || (region
->current
- region
->origin
> region
->length
))
5591 && ((region
->current
!= region
->origin
+ region
->length
)
5596 einfo (_("%X%P: address 0x%v of %pB section `%s'"
5597 " is not within region `%s'\n"),
5599 os
->bfd_section
->owner
,
5600 os
->bfd_section
->name
,
5601 region
->name_list
.name
);
5603 else if (!region
->had_full_message
)
5605 region
->had_full_message
= TRUE
;
5607 einfo (_("%X%P: %pB section `%s' will not fit in region `%s'\n"),
5608 os
->bfd_section
->owner
,
5609 os
->bfd_section
->name
,
5610 region
->name_list
.name
);
5616 ldlang_check_relro_region (lang_statement_union_type
*s
,
5617 seg_align_type
*seg
)
5619 if (seg
->relro
== exp_seg_relro_start
)
5621 if (!seg
->relro_start_stat
)
5622 seg
->relro_start_stat
= s
;
5625 ASSERT (seg
->relro_start_stat
== s
);
5628 else if (seg
->relro
== exp_seg_relro_end
)
5630 if (!seg
->relro_end_stat
)
5631 seg
->relro_end_stat
= s
;
5634 ASSERT (seg
->relro_end_stat
== s
);
5639 /* Set the sizes for all the output sections. */
5642 lang_size_sections_1
5643 (lang_statement_union_type
**prev
,
5644 lang_output_section_statement_type
*output_section_statement
,
5648 bfd_boolean check_regions
)
5650 lang_statement_union_type
*s
;
5651 lang_statement_union_type
*prev_s
= NULL
;
5652 bfd_boolean removed_prev_s
= FALSE
;
5654 /* Size up the sections from their constituent parts. */
5655 for (s
= *prev
; s
!= NULL
; prev_s
= s
, s
= s
->header
.next
)
5657 bfd_boolean removed
=FALSE
;
5659 switch (s
->header
.type
)
5661 case lang_output_section_statement_enum
:
5663 bfd_vma newdot
, after
, dotdelta
;
5664 lang_output_section_statement_type
*os
;
5665 lang_memory_region_type
*r
;
5666 int section_alignment
= 0;
5668 os
= &s
->output_section_statement
;
5669 init_opb (os
->bfd_section
);
5670 if (os
->constraint
== -1)
5673 /* FIXME: We shouldn't need to zero section vmas for ld -r
5674 here, in lang_insert_orphan, or in the default linker scripts.
5675 This is covering for coff backend linker bugs. See PR6945. */
5676 if (os
->addr_tree
== NULL
5677 && bfd_link_relocatable (&link_info
)
5678 && (bfd_get_flavour (link_info
.output_bfd
)
5679 == bfd_target_coff_flavour
))
5680 os
->addr_tree
= exp_intop (0);
5681 if (os
->addr_tree
!= NULL
)
5683 os
->processed_vma
= FALSE
;
5684 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
5686 if (expld
.result
.valid_p
)
5688 dot
= expld
.result
.value
;
5689 if (expld
.result
.section
!= NULL
)
5690 dot
+= expld
.result
.section
->vma
;
5692 else if (expld
.phase
!= lang_mark_phase_enum
)
5693 einfo (_("%F%P:%pS: non constant or forward reference"
5694 " address expression for section %s\n"),
5695 os
->addr_tree
, os
->name
);
5698 if (os
->bfd_section
== NULL
)
5699 /* This section was removed or never actually created. */
5702 /* If this is a COFF shared library section, use the size and
5703 address from the input section. FIXME: This is COFF
5704 specific; it would be cleaner if there were some other way
5705 to do this, but nothing simple comes to mind. */
5706 if (((bfd_get_flavour (link_info
.output_bfd
)
5707 == bfd_target_ecoff_flavour
)
5708 || (bfd_get_flavour (link_info
.output_bfd
)
5709 == bfd_target_coff_flavour
))
5710 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
5714 if (os
->children
.head
== NULL
5715 || os
->children
.head
->header
.next
!= NULL
5716 || (os
->children
.head
->header
.type
5717 != lang_input_section_enum
))
5718 einfo (_("%X%P: internal error on COFF shared library"
5719 " section %s\n"), os
->name
);
5721 input
= os
->children
.head
->input_section
.section
;
5722 bfd_set_section_vma (os
->bfd_section
,
5723 bfd_section_vma (input
));
5724 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5725 os
->bfd_section
->size
= input
->size
;
5731 if (bfd_is_abs_section (os
->bfd_section
))
5733 /* No matter what happens, an abs section starts at zero. */
5734 ASSERT (os
->bfd_section
->vma
== 0);
5738 if (os
->addr_tree
== NULL
)
5740 /* No address specified for this section, get one
5741 from the region specification. */
5742 if (os
->region
== NULL
5743 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
5744 && os
->region
->name_list
.name
[0] == '*'
5745 && strcmp (os
->region
->name_list
.name
,
5746 DEFAULT_MEMORY_REGION
) == 0))
5748 os
->region
= lang_memory_default (os
->bfd_section
);
5751 /* If a loadable section is using the default memory
5752 region, and some non default memory regions were
5753 defined, issue an error message. */
5755 && !IGNORE_SECTION (os
->bfd_section
)
5756 && !bfd_link_relocatable (&link_info
)
5758 && strcmp (os
->region
->name_list
.name
,
5759 DEFAULT_MEMORY_REGION
) == 0
5760 && lang_memory_region_list
!= NULL
5761 && (strcmp (lang_memory_region_list
->name_list
.name
,
5762 DEFAULT_MEMORY_REGION
) != 0
5763 || lang_memory_region_list
->next
!= NULL
)
5764 && lang_sizing_iteration
== 1)
5766 /* By default this is an error rather than just a
5767 warning because if we allocate the section to the
5768 default memory region we can end up creating an
5769 excessively large binary, or even seg faulting when
5770 attempting to perform a negative seek. See
5771 sources.redhat.com/ml/binutils/2003-04/msg00423.html
5772 for an example of this. This behaviour can be
5773 overridden by the using the --no-check-sections
5775 if (command_line
.check_section_addresses
)
5776 einfo (_("%F%P: error: no memory region specified"
5777 " for loadable section `%s'\n"),
5778 bfd_section_name (os
->bfd_section
));
5780 einfo (_("%P: warning: no memory region specified"
5781 " for loadable section `%s'\n"),
5782 bfd_section_name (os
->bfd_section
));
5785 newdot
= os
->region
->current
;
5786 section_alignment
= os
->bfd_section
->alignment_power
;
5789 section_alignment
= exp_get_power (os
->section_alignment
,
5790 "section alignment");
5792 /* Align to what the section needs. */
5793 if (section_alignment
> 0)
5795 bfd_vma savedot
= newdot
;
5798 newdot
= align_power (newdot
, section_alignment
);
5799 dotdelta
= newdot
- savedot
;
5801 if (lang_sizing_iteration
== 1)
5803 else if (lang_sizing_iteration
> 1)
5805 /* Only report adjustments that would change
5806 alignment from what we have already reported. */
5807 diff
= newdot
- os
->bfd_section
->vma
;
5808 if (!(diff
& (((bfd_vma
) 1 << section_alignment
) - 1)))
5812 && (config
.warn_section_align
5813 || os
->addr_tree
!= NULL
))
5814 einfo (_("%P: warning: "
5815 "start of section %s changed by %ld\n"),
5816 os
->name
, (long) diff
);
5819 bfd_set_section_vma (os
->bfd_section
, newdot
);
5821 os
->bfd_section
->output_offset
= 0;
5824 lang_size_sections_1 (&os
->children
.head
, os
,
5825 os
->fill
, newdot
, relax
, check_regions
);
5827 os
->processed_vma
= TRUE
;
5829 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5830 /* Except for some special linker created sections,
5831 no output section should change from zero size
5832 after strip_excluded_output_sections. A non-zero
5833 size on an ignored section indicates that some
5834 input section was not sized early enough. */
5835 ASSERT (os
->bfd_section
->size
== 0);
5838 dot
= os
->bfd_section
->vma
;
5840 /* Put the section within the requested block size, or
5841 align at the block boundary. */
5843 + TO_ADDR (os
->bfd_section
->size
)
5844 + os
->block_value
- 1)
5845 & - (bfd_vma
) os
->block_value
);
5847 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5848 os
->bfd_section
->size
= TO_SIZE (after
5849 - os
->bfd_section
->vma
);
5852 /* Set section lma. */
5855 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
5859 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
5860 os
->bfd_section
->lma
= lma
;
5862 else if (os
->lma_region
!= NULL
)
5864 bfd_vma lma
= os
->lma_region
->current
;
5866 if (os
->align_lma_with_input
)
5870 /* When LMA_REGION is the same as REGION, align the LMA
5871 as we did for the VMA, possibly including alignment
5872 from the bfd section. If a different region, then
5873 only align according to the value in the output
5875 if (os
->lma_region
!= os
->region
)
5876 section_alignment
= exp_get_power (os
->section_alignment
,
5877 "section alignment");
5878 if (section_alignment
> 0)
5879 lma
= align_power (lma
, section_alignment
);
5881 os
->bfd_section
->lma
= lma
;
5883 else if (r
->last_os
!= NULL
5884 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5889 last
= r
->last_os
->output_section_statement
.bfd_section
;
5891 /* A backwards move of dot should be accompanied by
5892 an explicit assignment to the section LMA (ie.
5893 os->load_base set) because backwards moves can
5894 create overlapping LMAs. */
5896 && os
->bfd_section
->size
!= 0
5897 && dot
+ TO_ADDR (os
->bfd_section
->size
) <= last
->vma
)
5899 /* If dot moved backwards then leave lma equal to
5900 vma. This is the old default lma, which might
5901 just happen to work when the backwards move is
5902 sufficiently large. Nag if this changes anything,
5903 so people can fix their linker scripts. */
5905 if (last
->vma
!= last
->lma
)
5906 einfo (_("%P: warning: dot moved backwards "
5907 "before `%s'\n"), os
->name
);
5911 /* If this is an overlay, set the current lma to that
5912 at the end of the previous section. */
5913 if (os
->sectype
== overlay_section
)
5914 lma
= last
->lma
+ TO_ADDR (last
->size
);
5916 /* Otherwise, keep the same lma to vma relationship
5917 as the previous section. */
5919 lma
= os
->bfd_section
->vma
+ last
->lma
- last
->vma
;
5921 if (section_alignment
> 0)
5922 lma
= align_power (lma
, section_alignment
);
5923 os
->bfd_section
->lma
= lma
;
5926 os
->processed_lma
= TRUE
;
5928 /* Keep track of normal sections using the default
5929 lma region. We use this to set the lma for
5930 following sections. Overlays or other linker
5931 script assignment to lma might mean that the
5932 default lma == vma is incorrect.
5933 To avoid warnings about dot moving backwards when using
5934 -Ttext, don't start tracking sections until we find one
5935 of non-zero size or with lma set differently to vma.
5936 Do this tracking before we short-cut the loop so that we
5937 track changes for the case where the section size is zero,
5938 but the lma is set differently to the vma. This is
5939 important, if an orphan section is placed after an
5940 otherwise empty output section that has an explicit lma
5941 set, we want that lma reflected in the orphans lma. */
5942 if (((!IGNORE_SECTION (os
->bfd_section
)
5943 && (os
->bfd_section
->size
!= 0
5944 || (r
->last_os
== NULL
5945 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
5946 || (r
->last_os
!= NULL
5947 && dot
>= (r
->last_os
->output_section_statement
5948 .bfd_section
->vma
))))
5949 || os
->sectype
== first_overlay_section
)
5950 && os
->lma_region
== NULL
5951 && !bfd_link_relocatable (&link_info
))
5954 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5957 /* .tbss sections effectively have zero size. */
5958 if (!IS_TBSS (os
->bfd_section
)
5959 || bfd_link_relocatable (&link_info
))
5960 dotdelta
= TO_ADDR (os
->bfd_section
->size
);
5965 if (os
->update_dot_tree
!= 0)
5966 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5968 /* Update dot in the region ?
5969 We only do this if the section is going to be allocated,
5970 since unallocated sections do not contribute to the region's
5971 overall size in memory. */
5972 if (os
->region
!= NULL
5973 && (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)))
5975 os
->region
->current
= dot
;
5978 /* Make sure the new address is within the region. */
5979 os_region_check (os
, os
->region
, os
->addr_tree
,
5980 os
->bfd_section
->vma
);
5982 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
5983 && ((os
->bfd_section
->flags
& SEC_LOAD
)
5984 || os
->align_lma_with_input
))
5986 os
->lma_region
->current
= os
->bfd_section
->lma
+ dotdelta
;
5989 os_region_check (os
, os
->lma_region
, NULL
,
5990 os
->bfd_section
->lma
);
5996 case lang_constructors_statement_enum
:
5997 dot
= lang_size_sections_1 (&constructor_list
.head
,
5998 output_section_statement
,
5999 fill
, dot
, relax
, check_regions
);
6002 case lang_data_statement_enum
:
6004 unsigned int size
= 0;
6006 s
->data_statement
.output_offset
=
6007 dot
- output_section_statement
->bfd_section
->vma
;
6008 s
->data_statement
.output_section
=
6009 output_section_statement
->bfd_section
;
6011 /* We might refer to provided symbols in the expression, and
6012 need to mark them as needed. */
6013 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
6015 switch (s
->data_statement
.type
)
6033 if (size
< TO_SIZE ((unsigned) 1))
6034 size
= TO_SIZE ((unsigned) 1);
6035 dot
+= TO_ADDR (size
);
6036 if (!(output_section_statement
->bfd_section
->flags
6038 output_section_statement
->bfd_section
->size
6039 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
6044 case lang_reloc_statement_enum
:
6048 s
->reloc_statement
.output_offset
=
6049 dot
- output_section_statement
->bfd_section
->vma
;
6050 s
->reloc_statement
.output_section
=
6051 output_section_statement
->bfd_section
;
6052 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
6053 dot
+= TO_ADDR (size
);
6054 if (!(output_section_statement
->bfd_section
->flags
6056 output_section_statement
->bfd_section
->size
6057 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
6061 case lang_wild_statement_enum
:
6062 dot
= lang_size_sections_1 (&s
->wild_statement
.children
.head
,
6063 output_section_statement
,
6064 fill
, dot
, relax
, check_regions
);
6067 case lang_object_symbols_statement_enum
:
6068 link_info
.create_object_symbols_section
6069 = output_section_statement
->bfd_section
;
6070 output_section_statement
->bfd_section
->flags
|= SEC_KEEP
;
6073 case lang_output_statement_enum
:
6074 case lang_target_statement_enum
:
6077 case lang_input_section_enum
:
6081 i
= s
->input_section
.section
;
6086 if (!bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
6087 einfo (_("%F%P: can't relax section: %E\n"));
6091 dot
= size_input_section (prev
, output_section_statement
,
6092 fill
, &removed
, dot
);
6096 case lang_input_statement_enum
:
6099 case lang_fill_statement_enum
:
6100 s
->fill_statement
.output_section
=
6101 output_section_statement
->bfd_section
;
6103 fill
= s
->fill_statement
.fill
;
6106 case lang_assignment_statement_enum
:
6108 bfd_vma newdot
= dot
;
6109 etree_type
*tree
= s
->assignment_statement
.exp
;
6111 expld
.dataseg
.relro
= exp_seg_relro_none
;
6113 exp_fold_tree (tree
,
6114 output_section_statement
->bfd_section
,
6117 ldlang_check_relro_region (s
, &expld
.dataseg
);
6119 expld
.dataseg
.relro
= exp_seg_relro_none
;
6121 /* This symbol may be relative to this section. */
6122 if ((tree
->type
.node_class
== etree_provided
6123 || tree
->type
.node_class
== etree_assign
)
6124 && (tree
->assign
.dst
[0] != '.'
6125 || tree
->assign
.dst
[1] != '\0'))
6126 output_section_statement
->update_dot
= 1;
6128 if (!output_section_statement
->ignored
)
6130 if (output_section_statement
== abs_output_section
)
6132 /* If we don't have an output section, then just adjust
6133 the default memory address. */
6134 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
6135 FALSE
)->current
= newdot
;
6137 else if (newdot
!= dot
)
6139 /* Insert a pad after this statement. We can't
6140 put the pad before when relaxing, in case the
6141 assignment references dot. */
6142 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
6143 output_section_statement
->bfd_section
, dot
);
6145 /* Don't neuter the pad below when relaxing. */
6148 /* If dot is advanced, this implies that the section
6149 should have space allocated to it, unless the
6150 user has explicitly stated that the section
6151 should not be allocated. */
6152 if (output_section_statement
->sectype
!= noalloc_section
6153 && (output_section_statement
->sectype
!= noload_section
6154 || (bfd_get_flavour (link_info
.output_bfd
)
6155 == bfd_target_elf_flavour
)))
6156 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
6163 case lang_padding_statement_enum
:
6164 /* If this is the first time lang_size_sections is called,
6165 we won't have any padding statements. If this is the
6166 second or later passes when relaxing, we should allow
6167 padding to shrink. If padding is needed on this pass, it
6168 will be added back in. */
6169 s
->padding_statement
.size
= 0;
6171 /* Make sure output_offset is valid. If relaxation shrinks
6172 the section and this pad isn't needed, it's possible to
6173 have output_offset larger than the final size of the
6174 section. bfd_set_section_contents will complain even for
6175 a pad size of zero. */
6176 s
->padding_statement
.output_offset
6177 = dot
- output_section_statement
->bfd_section
->vma
;
6180 case lang_group_statement_enum
:
6181 dot
= lang_size_sections_1 (&s
->group_statement
.children
.head
,
6182 output_section_statement
,
6183 fill
, dot
, relax
, check_regions
);
6186 case lang_insert_statement_enum
:
6189 /* We can only get here when relaxing is turned on. */
6190 case lang_address_statement_enum
:
6198 /* If an input section doesn't fit in the current output
6199 section, remove it from the list. Handle the case where we
6200 have to remove an input_section statement here: there is a
6201 special case to remove the first element of the list. */
6202 if (link_info
.non_contiguous_regions
&& removed
)
6204 /* If we removed the first element during the previous
6205 iteration, override the loop assignment of prev_s. */
6211 /* If there was a real previous input section, just skip
6213 prev_s
->header
.next
=s
->header
.next
;
6215 removed_prev_s
= FALSE
;
6219 /* Remove the first input section of the list. */
6220 *prev
= s
->header
.next
;
6221 removed_prev_s
= TRUE
;
6224 /* Move to next element, unless we removed the head of the
6226 if (!removed_prev_s
)
6227 prev
= &s
->header
.next
;
6231 prev
= &s
->header
.next
;
6232 removed_prev_s
= FALSE
;
6238 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
6239 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
6240 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
6241 segments. We are allowed an opportunity to override this decision. */
6244 ldlang_override_segment_assignment (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6245 bfd
*abfd ATTRIBUTE_UNUSED
,
6246 asection
*current_section
,
6247 asection
*previous_section
,
6248 bfd_boolean new_segment
)
6250 lang_output_section_statement_type
*cur
;
6251 lang_output_section_statement_type
*prev
;
6253 /* The checks below are only necessary when the BFD library has decided
6254 that the two sections ought to be placed into the same segment. */
6258 /* Paranoia checks. */
6259 if (current_section
== NULL
|| previous_section
== NULL
)
6262 /* If this flag is set, the target never wants code and non-code
6263 sections comingled in the same segment. */
6264 if (config
.separate_code
6265 && ((current_section
->flags
^ previous_section
->flags
) & SEC_CODE
))
6268 /* Find the memory regions associated with the two sections.
6269 We call lang_output_section_find() here rather than scanning the list
6270 of output sections looking for a matching section pointer because if
6271 we have a large number of sections then a hash lookup is faster. */
6272 cur
= lang_output_section_find (current_section
->name
);
6273 prev
= lang_output_section_find (previous_section
->name
);
6275 /* More paranoia. */
6276 if (cur
== NULL
|| prev
== NULL
)
6279 /* If the regions are different then force the sections to live in
6280 different segments. See the email thread starting at the following
6281 URL for the reasons why this is necessary:
6282 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
6283 return cur
->region
!= prev
->region
;
6287 one_lang_size_sections_pass (bfd_boolean
*relax
, bfd_boolean check_regions
)
6289 lang_statement_iteration
++;
6290 if (expld
.phase
!= lang_mark_phase_enum
)
6291 lang_sizing_iteration
++;
6292 lang_size_sections_1 (&statement_list
.head
, abs_output_section
,
6293 0, 0, relax
, check_regions
);
6297 lang_size_segment (seg_align_type
*seg
)
6299 /* If XXX_SEGMENT_ALIGN XXX_SEGMENT_END pair was seen, check whether
6300 a page could be saved in the data segment. */
6301 bfd_vma first
, last
;
6303 first
= -seg
->base
& (seg
->pagesize
- 1);
6304 last
= seg
->end
& (seg
->pagesize
- 1);
6306 && ((seg
->base
& ~(seg
->pagesize
- 1))
6307 != (seg
->end
& ~(seg
->pagesize
- 1)))
6308 && first
+ last
<= seg
->pagesize
)
6310 seg
->phase
= exp_seg_adjust
;
6314 seg
->phase
= exp_seg_done
;
6319 lang_size_relro_segment_1 (seg_align_type
*seg
)
6321 bfd_vma relro_end
, desired_end
;
6324 /* Compute the expected PT_GNU_RELRO/PT_LOAD segment end. */
6325 relro_end
= ((seg
->relro_end
+ seg
->pagesize
- 1)
6326 & ~(seg
->pagesize
- 1));
6328 /* Adjust by the offset arg of XXX_SEGMENT_RELRO_END. */
6329 desired_end
= relro_end
- seg
->relro_offset
;
6331 /* For sections in the relro segment.. */
6332 for (sec
= link_info
.output_bfd
->section_last
; sec
; sec
= sec
->prev
)
6333 if ((sec
->flags
& SEC_ALLOC
) != 0
6334 && sec
->vma
>= seg
->base
6335 && sec
->vma
< seg
->relro_end
- seg
->relro_offset
)
6337 /* Where do we want to put this section so that it ends as
6339 bfd_vma start
, end
, bump
;
6341 end
= start
= sec
->vma
;
6343 end
+= TO_ADDR (sec
->size
);
6344 bump
= desired_end
- end
;
6345 /* We'd like to increase START by BUMP, but we must heed
6346 alignment so the increase might be less than optimum. */
6348 start
&= ~(((bfd_vma
) 1 << sec
->alignment_power
) - 1);
6349 /* This is now the desired end for the previous section. */
6350 desired_end
= start
;
6353 seg
->phase
= exp_seg_relro_adjust
;
6354 ASSERT (desired_end
>= seg
->base
);
6355 seg
->base
= desired_end
;
6360 lang_size_relro_segment (bfd_boolean
*relax
, bfd_boolean check_regions
)
6362 bfd_boolean do_reset
= FALSE
;
6363 bfd_boolean do_data_relro
;
6364 bfd_vma data_initial_base
, data_relro_end
;
6366 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
6368 do_data_relro
= TRUE
;
6369 data_initial_base
= expld
.dataseg
.base
;
6370 data_relro_end
= lang_size_relro_segment_1 (&expld
.dataseg
);
6374 do_data_relro
= FALSE
;
6375 data_initial_base
= data_relro_end
= 0;
6380 lang_reset_memory_regions ();
6381 one_lang_size_sections_pass (relax
, check_regions
);
6383 /* Assignments to dot, or to output section address in a user
6384 script have increased padding over the original. Revert. */
6385 if (do_data_relro
&& expld
.dataseg
.relro_end
> data_relro_end
)
6387 expld
.dataseg
.base
= data_initial_base
;;
6392 if (!do_data_relro
&& lang_size_segment (&expld
.dataseg
))
6399 lang_size_sections (bfd_boolean
*relax
, bfd_boolean check_regions
)
6401 expld
.phase
= lang_allocating_phase_enum
;
6402 expld
.dataseg
.phase
= exp_seg_none
;
6404 one_lang_size_sections_pass (relax
, check_regions
);
6406 if (expld
.dataseg
.phase
!= exp_seg_end_seen
)
6407 expld
.dataseg
.phase
= exp_seg_done
;
6409 if (expld
.dataseg
.phase
== exp_seg_end_seen
)
6411 bfd_boolean do_reset
6412 = lang_size_relro_segment (relax
, check_regions
);
6416 lang_reset_memory_regions ();
6417 one_lang_size_sections_pass (relax
, check_regions
);
6420 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
6422 link_info
.relro_start
= expld
.dataseg
.base
;
6423 link_info
.relro_end
= expld
.dataseg
.relro_end
;
6428 static lang_output_section_statement_type
*current_section
;
6429 static lang_assignment_statement_type
*current_assign
;
6430 static bfd_boolean prefer_next_section
;
6432 /* Worker function for lang_do_assignments. Recursiveness goes here. */
6435 lang_do_assignments_1 (lang_statement_union_type
*s
,
6436 lang_output_section_statement_type
*current_os
,
6439 bfd_boolean
*found_end
)
6441 for (; s
!= NULL
; s
= s
->header
.next
)
6443 switch (s
->header
.type
)
6445 case lang_constructors_statement_enum
:
6446 dot
= lang_do_assignments_1 (constructor_list
.head
,
6447 current_os
, fill
, dot
, found_end
);
6450 case lang_output_section_statement_enum
:
6452 lang_output_section_statement_type
*os
;
6455 os
= &(s
->output_section_statement
);
6456 os
->after_end
= *found_end
;
6457 init_opb (os
->bfd_section
);
6458 if (os
->bfd_section
!= NULL
&& !os
->ignored
)
6460 if ((os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
6462 current_section
= os
;
6463 prefer_next_section
= FALSE
;
6465 dot
= os
->bfd_section
->vma
;
6467 newdot
= lang_do_assignments_1 (os
->children
.head
,
6468 os
, os
->fill
, dot
, found_end
);
6471 if (os
->bfd_section
!= NULL
)
6473 /* .tbss sections effectively have zero size. */
6474 if (!IS_TBSS (os
->bfd_section
)
6475 || bfd_link_relocatable (&link_info
))
6476 dot
+= TO_ADDR (os
->bfd_section
->size
);
6478 if (os
->update_dot_tree
!= NULL
)
6479 exp_fold_tree (os
->update_dot_tree
,
6480 bfd_abs_section_ptr
, &dot
);
6488 case lang_wild_statement_enum
:
6490 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
6491 current_os
, fill
, dot
, found_end
);
6494 case lang_object_symbols_statement_enum
:
6495 case lang_output_statement_enum
:
6496 case lang_target_statement_enum
:
6499 case lang_data_statement_enum
:
6500 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
6501 if (expld
.result
.valid_p
)
6503 s
->data_statement
.value
= expld
.result
.value
;
6504 if (expld
.result
.section
!= NULL
)
6505 s
->data_statement
.value
+= expld
.result
.section
->vma
;
6507 else if (expld
.phase
== lang_final_phase_enum
)
6508 einfo (_("%F%P: invalid data statement\n"));
6511 switch (s
->data_statement
.type
)
6529 if (size
< TO_SIZE ((unsigned) 1))
6530 size
= TO_SIZE ((unsigned) 1);
6531 dot
+= TO_ADDR (size
);
6535 case lang_reloc_statement_enum
:
6536 exp_fold_tree (s
->reloc_statement
.addend_exp
,
6537 bfd_abs_section_ptr
, &dot
);
6538 if (expld
.result
.valid_p
)
6539 s
->reloc_statement
.addend_value
= expld
.result
.value
;
6540 else if (expld
.phase
== lang_final_phase_enum
)
6541 einfo (_("%F%P: invalid reloc statement\n"));
6542 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
6545 case lang_input_section_enum
:
6547 asection
*in
= s
->input_section
.section
;
6549 if ((in
->flags
& SEC_EXCLUDE
) == 0)
6550 dot
+= TO_ADDR (in
->size
);
6554 case lang_input_statement_enum
:
6557 case lang_fill_statement_enum
:
6558 fill
= s
->fill_statement
.fill
;
6561 case lang_assignment_statement_enum
:
6562 current_assign
= &s
->assignment_statement
;
6563 if (current_assign
->exp
->type
.node_class
!= etree_assert
)
6565 const char *p
= current_assign
->exp
->assign
.dst
;
6567 if (current_os
== abs_output_section
&& p
[0] == '.' && p
[1] == 0)
6568 prefer_next_section
= TRUE
;
6572 if (strcmp (p
, "end") == 0)
6575 exp_fold_tree (s
->assignment_statement
.exp
,
6576 (current_os
->bfd_section
!= NULL
6577 ? current_os
->bfd_section
: bfd_und_section_ptr
),
6581 case lang_padding_statement_enum
:
6582 dot
+= TO_ADDR (s
->padding_statement
.size
);
6585 case lang_group_statement_enum
:
6586 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
6587 current_os
, fill
, dot
, found_end
);
6590 case lang_insert_statement_enum
:
6593 case lang_address_statement_enum
:
6605 lang_do_assignments (lang_phase_type phase
)
6607 bfd_boolean found_end
= FALSE
;
6609 current_section
= NULL
;
6610 prefer_next_section
= FALSE
;
6611 expld
.phase
= phase
;
6612 lang_statement_iteration
++;
6613 lang_do_assignments_1 (statement_list
.head
,
6614 abs_output_section
, NULL
, 0, &found_end
);
6617 /* For an assignment statement outside of an output section statement,
6618 choose the best of neighbouring output sections to use for values
6622 section_for_dot (void)
6626 /* Assignments belong to the previous output section, unless there
6627 has been an assignment to "dot", in which case following
6628 assignments belong to the next output section. (The assumption
6629 is that an assignment to "dot" is setting up the address for the
6630 next output section.) Except that past the assignment to "_end"
6631 we always associate with the previous section. This exception is
6632 for targets like SH that define an alloc .stack or other
6633 weirdness after non-alloc sections. */
6634 if (current_section
== NULL
|| prefer_next_section
)
6636 lang_statement_union_type
*stmt
;
6637 lang_output_section_statement_type
*os
;
6639 for (stmt
= (lang_statement_union_type
*) current_assign
;
6641 stmt
= stmt
->header
.next
)
6642 if (stmt
->header
.type
== lang_output_section_statement_enum
)
6645 os
= &stmt
->output_section_statement
;
6648 && (os
->bfd_section
== NULL
6649 || (os
->bfd_section
->flags
& SEC_EXCLUDE
) != 0
6650 || bfd_section_removed_from_list (link_info
.output_bfd
,
6654 if (current_section
== NULL
|| os
== NULL
|| !os
->after_end
)
6657 s
= os
->bfd_section
;
6659 s
= link_info
.output_bfd
->section_last
;
6661 && ((s
->flags
& SEC_ALLOC
) == 0
6662 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6667 return bfd_abs_section_ptr
;
6671 s
= current_section
->bfd_section
;
6673 /* The section may have been stripped. */
6675 && ((s
->flags
& SEC_EXCLUDE
) != 0
6676 || (s
->flags
& SEC_ALLOC
) == 0
6677 || (s
->flags
& SEC_THREAD_LOCAL
) != 0
6678 || bfd_section_removed_from_list (link_info
.output_bfd
, s
)))
6681 s
= link_info
.output_bfd
->sections
;
6683 && ((s
->flags
& SEC_ALLOC
) == 0
6684 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6689 return bfd_abs_section_ptr
;
6692 /* Array of __start/__stop/.startof./.sizeof/ symbols. */
6694 static struct bfd_link_hash_entry
**start_stop_syms
;
6695 static size_t start_stop_count
= 0;
6696 static size_t start_stop_alloc
= 0;
6698 /* Give start/stop SYMBOL for SEC a preliminary definition, and add it
6699 to start_stop_syms. */
6702 lang_define_start_stop (const char *symbol
, asection
*sec
)
6704 struct bfd_link_hash_entry
*h
;
6706 h
= bfd_define_start_stop (link_info
.output_bfd
, &link_info
, symbol
, sec
);
6709 if (start_stop_count
== start_stop_alloc
)
6711 start_stop_alloc
= 2 * start_stop_alloc
+ 10;
6713 = xrealloc (start_stop_syms
,
6714 start_stop_alloc
* sizeof (*start_stop_syms
));
6716 start_stop_syms
[start_stop_count
++] = h
;
6720 /* Check for input sections whose names match references to
6721 __start_SECNAME or __stop_SECNAME symbols. Give the symbols
6722 preliminary definitions. */
6725 lang_init_start_stop (void)
6729 char leading_char
= bfd_get_symbol_leading_char (link_info
.output_bfd
);
6731 for (abfd
= link_info
.input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6732 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6735 const char *secname
= s
->name
;
6737 for (ps
= secname
; *ps
!= '\0'; ps
++)
6738 if (!ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
6742 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6744 symbol
[0] = leading_char
;
6745 sprintf (symbol
+ (leading_char
!= 0), "__start_%s", secname
);
6746 lang_define_start_stop (symbol
, s
);
6748 symbol
[1] = leading_char
;
6749 memcpy (symbol
+ 1 + (leading_char
!= 0), "__stop", 6);
6750 lang_define_start_stop (symbol
+ 1, s
);
6757 /* Iterate over start_stop_syms. */
6760 foreach_start_stop (void (*func
) (struct bfd_link_hash_entry
*))
6764 for (i
= 0; i
< start_stop_count
; ++i
)
6765 func (start_stop_syms
[i
]);
6768 /* __start and __stop symbols are only supposed to be defined by the
6769 linker for orphan sections, but we now extend that to sections that
6770 map to an output section of the same name. The symbols were
6771 defined early for --gc-sections, before we mapped input to output
6772 sections, so undo those that don't satisfy this rule. */
6775 undef_start_stop (struct bfd_link_hash_entry
*h
)
6777 if (h
->ldscript_def
)
6780 if (h
->u
.def
.section
->output_section
== NULL
6781 || h
->u
.def
.section
->output_section
->owner
!= link_info
.output_bfd
6782 || strcmp (h
->u
.def
.section
->name
,
6783 h
->u
.def
.section
->output_section
->name
) != 0)
6785 asection
*sec
= bfd_get_section_by_name (link_info
.output_bfd
,
6786 h
->u
.def
.section
->name
);
6789 /* When there are more than one input sections with the same
6790 section name, SECNAME, linker picks the first one to define
6791 __start_SECNAME and __stop_SECNAME symbols. When the first
6792 input section is removed by comdat group, we need to check
6793 if there is still an output section with section name
6796 for (i
= sec
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
6797 if (strcmp (h
->u
.def
.section
->name
, i
->name
) == 0)
6799 h
->u
.def
.section
= i
;
6803 h
->type
= bfd_link_hash_undefined
;
6804 h
->u
.undef
.abfd
= NULL
;
6809 lang_undef_start_stop (void)
6811 foreach_start_stop (undef_start_stop
);
6814 /* Check for output sections whose names match references to
6815 .startof.SECNAME or .sizeof.SECNAME symbols. Give the symbols
6816 preliminary definitions. */
6819 lang_init_startof_sizeof (void)
6823 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6825 const char *secname
= s
->name
;
6826 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6828 sprintf (symbol
, ".startof.%s", secname
);
6829 lang_define_start_stop (symbol
, s
);
6831 memcpy (symbol
+ 1, ".size", 5);
6832 lang_define_start_stop (symbol
+ 1, s
);
6837 /* Set .startof., .sizeof., __start and __stop symbols final values. */
6840 set_start_stop (struct bfd_link_hash_entry
*h
)
6843 || h
->type
!= bfd_link_hash_defined
)
6846 if (h
->root
.string
[0] == '.')
6848 /* .startof. or .sizeof. symbol.
6849 .startof. already has final value. */
6850 if (h
->root
.string
[2] == 'i')
6853 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6854 h
->u
.def
.section
= bfd_abs_section_ptr
;
6859 /* __start or __stop symbol. */
6860 int has_lead
= bfd_get_symbol_leading_char (link_info
.output_bfd
) != 0;
6862 h
->u
.def
.section
= h
->u
.def
.section
->output_section
;
6863 if (h
->root
.string
[4 + has_lead
] == 'o')
6866 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6872 lang_finalize_start_stop (void)
6874 foreach_start_stop (set_start_stop
);
6880 struct bfd_link_hash_entry
*h
;
6883 if ((bfd_link_relocatable (&link_info
) && !link_info
.gc_sections
)
6884 || bfd_link_dll (&link_info
))
6885 warn
= entry_from_cmdline
;
6889 /* Force the user to specify a root when generating a relocatable with
6890 --gc-sections, unless --gc-keep-exported was also given. */
6891 if (bfd_link_relocatable (&link_info
)
6892 && link_info
.gc_sections
6893 && !link_info
.gc_keep_exported
)
6895 struct bfd_sym_chain
*sym
;
6897 for (sym
= link_info
.gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
6899 h
= bfd_link_hash_lookup (link_info
.hash
, sym
->name
,
6900 FALSE
, FALSE
, FALSE
);
6902 && (h
->type
== bfd_link_hash_defined
6903 || h
->type
== bfd_link_hash_defweak
)
6904 && !bfd_is_const_section (h
->u
.def
.section
))
6908 einfo (_("%F%P: --gc-sections requires a defined symbol root "
6909 "specified by -e or -u\n"));
6912 if (entry_symbol
.name
== NULL
)
6914 /* No entry has been specified. Look for the default entry, but
6915 don't warn if we don't find it. */
6916 entry_symbol
.name
= entry_symbol_default
;
6920 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
6921 FALSE
, FALSE
, TRUE
);
6923 && (h
->type
== bfd_link_hash_defined
6924 || h
->type
== bfd_link_hash_defweak
)
6925 && h
->u
.def
.section
->output_section
!= NULL
)
6929 val
= (h
->u
.def
.value
6930 + bfd_section_vma (h
->u
.def
.section
->output_section
)
6931 + h
->u
.def
.section
->output_offset
);
6932 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6933 einfo (_("%F%P: %s: can't set start address\n"), entry_symbol
.name
);
6940 /* We couldn't find the entry symbol. Try parsing it as a
6942 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
6945 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6946 einfo (_("%F%P: can't set start address\n"));
6952 /* Can't find the entry symbol, and it's not a number. Use
6953 the first address in the text section. */
6954 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
6958 einfo (_("%P: warning: cannot find entry symbol %s;"
6959 " defaulting to %V\n"),
6961 bfd_section_vma (ts
));
6962 if (!bfd_set_start_address (link_info
.output_bfd
,
6963 bfd_section_vma (ts
)))
6964 einfo (_("%F%P: can't set start address\n"));
6969 einfo (_("%P: warning: cannot find entry symbol %s;"
6970 " not setting start address\n"),
6977 /* This is a small function used when we want to ignore errors from
6981 ignore_bfd_errors (const char *fmt ATTRIBUTE_UNUSED
,
6982 va_list ap ATTRIBUTE_UNUSED
)
6984 /* Don't do anything. */
6987 /* Check that the architecture of all the input files is compatible
6988 with the output file. Also call the backend to let it do any
6989 other checking that is needed. */
6994 lang_input_statement_type
*file
;
6996 const bfd_arch_info_type
*compatible
;
6998 for (file
= (void *) file_chain
.head
;
7002 #if BFD_SUPPORTS_PLUGINS
7003 /* Don't check format of files claimed by plugin. */
7004 if (file
->flags
.claimed
)
7006 #endif /* BFD_SUPPORTS_PLUGINS */
7007 input_bfd
= file
->the_bfd
;
7009 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
7010 command_line
.accept_unknown_input_arch
);
7012 /* In general it is not possible to perform a relocatable
7013 link between differing object formats when the input
7014 file has relocations, because the relocations in the
7015 input format may not have equivalent representations in
7016 the output format (and besides BFD does not translate
7017 relocs for other link purposes than a final link). */
7018 if (!file
->flags
.just_syms
7019 && (bfd_link_relocatable (&link_info
)
7020 || link_info
.emitrelocations
)
7021 && (compatible
== NULL
7022 || (bfd_get_flavour (input_bfd
)
7023 != bfd_get_flavour (link_info
.output_bfd
)))
7024 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
7026 einfo (_("%F%P: relocatable linking with relocations from"
7027 " format %s (%pB) to format %s (%pB) is not supported\n"),
7028 bfd_get_target (input_bfd
), input_bfd
,
7029 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
7030 /* einfo with %F exits. */
7033 if (compatible
== NULL
)
7035 if (command_line
.warn_mismatch
)
7036 einfo (_("%X%P: %s architecture of input file `%pB'"
7037 " is incompatible with %s output\n"),
7038 bfd_printable_name (input_bfd
), input_bfd
,
7039 bfd_printable_name (link_info
.output_bfd
));
7042 /* If the input bfd has no contents, it shouldn't set the
7043 private data of the output bfd. */
7044 else if (!file
->flags
.just_syms
7045 && ((input_bfd
->flags
& DYNAMIC
) != 0
7046 || bfd_count_sections (input_bfd
) != 0))
7048 bfd_error_handler_type pfn
= NULL
;
7050 /* If we aren't supposed to warn about mismatched input
7051 files, temporarily set the BFD error handler to a
7052 function which will do nothing. We still want to call
7053 bfd_merge_private_bfd_data, since it may set up
7054 information which is needed in the output file. */
7055 if (!command_line
.warn_mismatch
)
7056 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
7057 if (!bfd_merge_private_bfd_data (input_bfd
, &link_info
))
7059 if (command_line
.warn_mismatch
)
7060 einfo (_("%X%P: failed to merge target specific data"
7061 " of file %pB\n"), input_bfd
);
7063 if (!command_line
.warn_mismatch
)
7064 bfd_set_error_handler (pfn
);
7069 /* Look through all the global common symbols and attach them to the
7070 correct section. The -sort-common command line switch may be used
7071 to roughly sort the entries by alignment. */
7076 if (link_info
.inhibit_common_definition
)
7078 if (bfd_link_relocatable (&link_info
)
7079 && !command_line
.force_common_definition
)
7082 if (!config
.sort_common
)
7083 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
7088 if (config
.sort_common
== sort_descending
)
7090 for (power
= 4; power
> 0; power
--)
7091 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7094 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7098 for (power
= 0; power
<= 4; power
++)
7099 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7101 power
= (unsigned int) -1;
7102 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7107 /* Place one common symbol in the correct section. */
7110 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
7112 unsigned int power_of_two
;
7116 if (h
->type
!= bfd_link_hash_common
)
7120 power_of_two
= h
->u
.c
.p
->alignment_power
;
7122 if (config
.sort_common
== sort_descending
7123 && power_of_two
< *(unsigned int *) info
)
7125 else if (config
.sort_common
== sort_ascending
7126 && power_of_two
> *(unsigned int *) info
)
7129 section
= h
->u
.c
.p
->section
;
7130 if (!bfd_define_common_symbol (link_info
.output_bfd
, &link_info
, h
))
7131 einfo (_("%F%P: could not define common symbol `%pT': %E\n"),
7134 if (config
.map_file
!= NULL
)
7136 static bfd_boolean header_printed
;
7141 if (!header_printed
)
7143 minfo (_("\nAllocating common symbols\n"));
7144 minfo (_("Common symbol size file\n\n"));
7145 header_printed
= TRUE
;
7148 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
7149 DMGL_ANSI
| DMGL_PARAMS
);
7152 minfo ("%s", h
->root
.string
);
7153 len
= strlen (h
->root
.string
);
7158 len
= strlen (name
);
7174 if (size
<= 0xffffffff)
7175 sprintf (buf
, "%lx", (unsigned long) size
);
7177 sprintf_vma (buf
, size
);
7187 minfo ("%pB\n", section
->owner
);
7193 /* Handle a single orphan section S, placing the orphan into an appropriate
7194 output section. The effects of the --orphan-handling command line
7195 option are handled here. */
7198 ldlang_place_orphan (asection
*s
)
7200 if (config
.orphan_handling
== orphan_handling_discard
)
7202 lang_output_section_statement_type
*os
;
7203 os
= lang_output_section_statement_lookup (DISCARD_SECTION_NAME
, 0, 1);
7204 if (os
->addr_tree
== NULL
7205 && (bfd_link_relocatable (&link_info
)
7206 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
7207 os
->addr_tree
= exp_intop (0);
7208 lang_add_section (&os
->children
, s
, NULL
, os
);
7212 lang_output_section_statement_type
*os
;
7213 const char *name
= s
->name
;
7216 if (config
.orphan_handling
== orphan_handling_error
)
7217 einfo (_("%X%P: error: unplaced orphan section `%pA' from `%pB'\n"),
7220 if (config
.unique_orphan_sections
|| unique_section_p (s
, NULL
))
7221 constraint
= SPECIAL
;
7223 os
= ldemul_place_orphan (s
, name
, constraint
);
7226 os
= lang_output_section_statement_lookup (name
, constraint
, 1);
7227 if (os
->addr_tree
== NULL
7228 && (bfd_link_relocatable (&link_info
)
7229 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
7230 os
->addr_tree
= exp_intop (0);
7231 lang_add_section (&os
->children
, s
, NULL
, os
);
7234 if (config
.orphan_handling
== orphan_handling_warn
)
7235 einfo (_("%P: warning: orphan section `%pA' from `%pB' being "
7236 "placed in section `%s'\n"),
7237 s
, s
->owner
, os
->name
);
7241 /* Run through the input files and ensure that every input section has
7242 somewhere to go. If one is found without a destination then create
7243 an input request and place it into the statement tree. */
7246 lang_place_orphans (void)
7248 LANG_FOR_EACH_INPUT_STATEMENT (file
)
7252 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
7254 if (s
->output_section
== NULL
)
7256 /* This section of the file is not attached, root
7257 around for a sensible place for it to go. */
7259 if (file
->flags
.just_syms
)
7260 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
7261 else if (lang_discard_section_p (s
))
7262 s
->output_section
= bfd_abs_section_ptr
;
7263 else if (strcmp (s
->name
, "COMMON") == 0)
7265 /* This is a lonely common section which must have
7266 come from an archive. We attach to the section
7267 with the wildcard. */
7268 if (!bfd_link_relocatable (&link_info
)
7269 || command_line
.force_common_definition
)
7271 if (default_common_section
== NULL
)
7272 default_common_section
7273 = lang_output_section_statement_lookup (".bss", 0, 1);
7274 lang_add_section (&default_common_section
->children
, s
,
7275 NULL
, default_common_section
);
7279 ldlang_place_orphan (s
);
7286 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
7288 flagword
*ptr_flags
;
7290 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
7296 /* PR 17900: An exclamation mark in the attributes reverses
7297 the sense of any of the attributes that follow. */
7300 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
7304 *ptr_flags
|= SEC_ALLOC
;
7308 *ptr_flags
|= SEC_READONLY
;
7312 *ptr_flags
|= SEC_DATA
;
7316 *ptr_flags
|= SEC_CODE
;
7321 *ptr_flags
|= SEC_LOAD
;
7325 einfo (_("%F%P: invalid character %c (%d) in flags\n"),
7333 /* Call a function on each real input file. This function will be
7334 called on an archive, but not on the elements. */
7337 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
7339 lang_input_statement_type
*f
;
7341 for (f
= (void *) input_file_chain
.head
;
7343 f
= f
->next_real_file
)
7348 /* Call a function on each real file. The function will be called on
7349 all the elements of an archive which are included in the link, but
7350 will not be called on the archive file itself. */
7353 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
7355 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7363 ldlang_add_file (lang_input_statement_type
*entry
)
7365 lang_statement_append (&file_chain
, entry
, &entry
->next
);
7367 /* The BFD linker needs to have a list of all input BFDs involved in
7369 ASSERT (link_info
.input_bfds_tail
!= &entry
->the_bfd
->link
.next
7370 && entry
->the_bfd
->link
.next
== NULL
);
7371 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
7373 *link_info
.input_bfds_tail
= entry
->the_bfd
;
7374 link_info
.input_bfds_tail
= &entry
->the_bfd
->link
.next
;
7375 bfd_set_usrdata (entry
->the_bfd
, entry
);
7376 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
7378 /* Look through the sections and check for any which should not be
7379 included in the link. We need to do this now, so that we can
7380 notice when the backend linker tries to report multiple
7381 definition errors for symbols which are in sections we aren't
7382 going to link. FIXME: It might be better to entirely ignore
7383 symbols which are defined in sections which are going to be
7384 discarded. This would require modifying the backend linker for
7385 each backend which might set the SEC_LINK_ONCE flag. If we do
7386 this, we should probably handle SEC_EXCLUDE in the same way. */
7388 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
7392 lang_add_output (const char *name
, int from_script
)
7394 /* Make -o on command line override OUTPUT in script. */
7395 if (!had_output_filename
|| !from_script
)
7397 output_filename
= name
;
7398 had_output_filename
= TRUE
;
7402 lang_output_section_statement_type
*
7403 lang_enter_output_section_statement (const char *output_section_statement_name
,
7404 etree_type
*address_exp
,
7405 enum section_type sectype
,
7407 etree_type
*subalign
,
7410 int align_with_input
)
7412 lang_output_section_statement_type
*os
;
7414 os
= lang_output_section_statement_lookup (output_section_statement_name
,
7416 current_section
= os
;
7418 if (os
->addr_tree
== NULL
)
7420 os
->addr_tree
= address_exp
;
7422 os
->sectype
= sectype
;
7423 if (sectype
!= noload_section
)
7424 os
->flags
= SEC_NO_FLAGS
;
7426 os
->flags
= SEC_NEVER_LOAD
;
7427 os
->block_value
= 1;
7429 /* Make next things chain into subchain of this. */
7430 push_stat_ptr (&os
->children
);
7432 os
->align_lma_with_input
= align_with_input
== ALIGN_WITH_INPUT
;
7433 if (os
->align_lma_with_input
&& align
!= NULL
)
7434 einfo (_("%F%P:%pS: error: align with input and explicit align specified\n"),
7437 os
->subsection_alignment
= subalign
;
7438 os
->section_alignment
= align
;
7440 os
->load_base
= ebase
;
7447 lang_output_statement_type
*new_stmt
;
7449 new_stmt
= new_stat (lang_output_statement
, stat_ptr
);
7450 new_stmt
->name
= output_filename
;
7453 /* Reset the current counters in the regions. */
7456 lang_reset_memory_regions (void)
7458 lang_memory_region_type
*p
= lang_memory_region_list
;
7460 lang_output_section_statement_type
*os
;
7462 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
7464 p
->current
= p
->origin
;
7468 for (os
= (void *) lang_os_list
.head
;
7472 os
->processed_vma
= FALSE
;
7473 os
->processed_lma
= FALSE
;
7476 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
7478 /* Save the last size for possible use by bfd_relax_section. */
7479 o
->rawsize
= o
->size
;
7480 if (!(o
->flags
& SEC_FIXED_SIZE
))
7485 /* Worker for lang_gc_sections_1. */
7488 gc_section_callback (lang_wild_statement_type
*ptr
,
7489 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7491 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
7492 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7493 void *data ATTRIBUTE_UNUSED
)
7495 /* If the wild pattern was marked KEEP, the member sections
7496 should be as well. */
7497 if (ptr
->keep_sections
)
7498 section
->flags
|= SEC_KEEP
;
7501 /* Iterate over sections marking them against GC. */
7504 lang_gc_sections_1 (lang_statement_union_type
*s
)
7506 for (; s
!= NULL
; s
= s
->header
.next
)
7508 switch (s
->header
.type
)
7510 case lang_wild_statement_enum
:
7511 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
7513 case lang_constructors_statement_enum
:
7514 lang_gc_sections_1 (constructor_list
.head
);
7516 case lang_output_section_statement_enum
:
7517 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
7519 case lang_group_statement_enum
:
7520 lang_gc_sections_1 (s
->group_statement
.children
.head
);
7529 lang_gc_sections (void)
7531 /* Keep all sections so marked in the link script. */
7532 lang_gc_sections_1 (statement_list
.head
);
7534 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
7535 the special case of debug info. (See bfd/stabs.c)
7536 Twiddle the flag here, to simplify later linker code. */
7537 if (bfd_link_relocatable (&link_info
))
7539 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7542 #if BFD_SUPPORTS_PLUGINS
7543 if (f
->flags
.claimed
)
7546 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7547 if ((sec
->flags
& SEC_DEBUGGING
) == 0)
7548 sec
->flags
&= ~SEC_EXCLUDE
;
7552 if (link_info
.gc_sections
)
7553 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
7556 /* Worker for lang_find_relro_sections_1. */
7559 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
7560 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7562 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
7563 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7566 /* Discarded, excluded and ignored sections effectively have zero
7568 if (section
->output_section
!= NULL
7569 && section
->output_section
->owner
== link_info
.output_bfd
7570 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
7571 && !IGNORE_SECTION (section
)
7572 && section
->size
!= 0)
7574 bfd_boolean
*has_relro_section
= (bfd_boolean
*) data
;
7575 *has_relro_section
= TRUE
;
7579 /* Iterate over sections for relro sections. */
7582 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
7583 seg_align_type
*seg
,
7584 bfd_boolean
*has_relro_section
)
7586 if (*has_relro_section
)
7589 for (; s
!= NULL
; s
= s
->header
.next
)
7591 if (s
== seg
->relro_end_stat
)
7594 switch (s
->header
.type
)
7596 case lang_wild_statement_enum
:
7597 walk_wild (&s
->wild_statement
,
7598 find_relro_section_callback
,
7601 case lang_constructors_statement_enum
:
7602 lang_find_relro_sections_1 (constructor_list
.head
,
7603 seg
, has_relro_section
);
7605 case lang_output_section_statement_enum
:
7606 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
7607 seg
, has_relro_section
);
7609 case lang_group_statement_enum
:
7610 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
7611 seg
, has_relro_section
);
7620 lang_find_relro_sections (void)
7622 bfd_boolean has_relro_section
= FALSE
;
7624 /* Check all sections in the link script. */
7626 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
7627 &expld
.dataseg
, &has_relro_section
);
7629 if (!has_relro_section
)
7630 link_info
.relro
= FALSE
;
7633 /* Relax all sections until bfd_relax_section gives up. */
7636 lang_relax_sections (bfd_boolean need_layout
)
7638 if (RELAXATION_ENABLED
)
7640 /* We may need more than one relaxation pass. */
7641 int i
= link_info
.relax_pass
;
7643 /* The backend can use it to determine the current pass. */
7644 link_info
.relax_pass
= 0;
7648 /* Keep relaxing until bfd_relax_section gives up. */
7649 bfd_boolean relax_again
;
7651 link_info
.relax_trip
= -1;
7654 link_info
.relax_trip
++;
7656 /* Note: pe-dll.c does something like this also. If you find
7657 you need to change this code, you probably need to change
7658 pe-dll.c also. DJ */
7660 /* Do all the assignments with our current guesses as to
7662 lang_do_assignments (lang_assigning_phase_enum
);
7664 /* We must do this after lang_do_assignments, because it uses
7666 lang_reset_memory_regions ();
7668 /* Perform another relax pass - this time we know where the
7669 globals are, so can make a better guess. */
7670 relax_again
= FALSE
;
7671 lang_size_sections (&relax_again
, FALSE
);
7673 while (relax_again
);
7675 link_info
.relax_pass
++;
7682 /* Final extra sizing to report errors. */
7683 lang_do_assignments (lang_assigning_phase_enum
);
7684 lang_reset_memory_regions ();
7685 lang_size_sections (NULL
, TRUE
);
7689 #if BFD_SUPPORTS_PLUGINS
7690 /* Find the insert point for the plugin's replacement files. We
7691 place them after the first claimed real object file, or if the
7692 first claimed object is an archive member, after the last real
7693 object file immediately preceding the archive. In the event
7694 no objects have been claimed at all, we return the first dummy
7695 object file on the list as the insert point; that works, but
7696 the callee must be careful when relinking the file_chain as it
7697 is not actually on that chain, only the statement_list and the
7698 input_file list; in that case, the replacement files must be
7699 inserted at the head of the file_chain. */
7701 static lang_input_statement_type
*
7702 find_replacements_insert_point (bfd_boolean
*before
)
7704 lang_input_statement_type
*claim1
, *lastobject
;
7705 lastobject
= (void *) input_file_chain
.head
;
7706 for (claim1
= (void *) file_chain
.head
;
7708 claim1
= claim1
->next
)
7710 if (claim1
->flags
.claimed
)
7712 *before
= claim1
->flags
.claim_archive
;
7713 return claim1
->flags
.claim_archive
? lastobject
: claim1
;
7715 /* Update lastobject if this is a real object file. */
7716 if (claim1
->the_bfd
!= NULL
&& claim1
->the_bfd
->my_archive
== NULL
)
7717 lastobject
= claim1
;
7719 /* No files were claimed by the plugin. Choose the last object
7720 file found on the list (maybe the first, dummy entry) as the
7726 /* Find where to insert ADD, an archive element or shared library
7727 added during a rescan. */
7729 static lang_input_statement_type
**
7730 find_rescan_insertion (lang_input_statement_type
*add
)
7732 bfd
*add_bfd
= add
->the_bfd
;
7733 lang_input_statement_type
*f
;
7734 lang_input_statement_type
*last_loaded
= NULL
;
7735 lang_input_statement_type
*before
= NULL
;
7736 lang_input_statement_type
**iter
= NULL
;
7738 if (add_bfd
->my_archive
!= NULL
)
7739 add_bfd
= add_bfd
->my_archive
;
7741 /* First look through the input file chain, to find an object file
7742 before the one we've rescanned. Normal object files always
7743 appear on both the input file chain and the file chain, so this
7744 lets us get quickly to somewhere near the correct place on the
7745 file chain if it is full of archive elements. Archives don't
7746 appear on the file chain, but if an element has been extracted
7747 then their input_statement->next points at it. */
7748 for (f
= (void *) input_file_chain
.head
;
7750 f
= f
->next_real_file
)
7752 if (f
->the_bfd
== add_bfd
)
7754 before
= last_loaded
;
7755 if (f
->next
!= NULL
)
7756 return &f
->next
->next
;
7758 if (f
->the_bfd
!= NULL
&& f
->next
!= NULL
)
7762 for (iter
= before
? &before
->next
: &file_chain
.head
->input_statement
.next
;
7764 iter
= &(*iter
)->next
)
7765 if (!(*iter
)->flags
.claim_archive
7766 && (*iter
)->the_bfd
->my_archive
== NULL
)
7772 /* Insert SRCLIST into DESTLIST after given element by chaining
7773 on FIELD as the next-pointer. (Counterintuitively does not need
7774 a pointer to the actual after-node itself, just its chain field.) */
7777 lang_list_insert_after (lang_statement_list_type
*destlist
,
7778 lang_statement_list_type
*srclist
,
7779 lang_statement_union_type
**field
)
7781 *(srclist
->tail
) = *field
;
7782 *field
= srclist
->head
;
7783 if (destlist
->tail
== field
)
7784 destlist
->tail
= srclist
->tail
;
7787 /* Detach new nodes added to DESTLIST since the time ORIGLIST
7788 was taken as a copy of it and leave them in ORIGLIST. */
7791 lang_list_remove_tail (lang_statement_list_type
*destlist
,
7792 lang_statement_list_type
*origlist
)
7794 union lang_statement_union
**savetail
;
7795 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
7796 ASSERT (origlist
->head
== destlist
->head
);
7797 savetail
= origlist
->tail
;
7798 origlist
->head
= *(savetail
);
7799 origlist
->tail
= destlist
->tail
;
7800 destlist
->tail
= savetail
;
7804 static lang_statement_union_type
**
7805 find_next_input_statement (lang_statement_union_type
**s
)
7807 for ( ; *s
; s
= &(*s
)->header
.next
)
7809 lang_statement_union_type
**t
;
7810 switch ((*s
)->header
.type
)
7812 case lang_input_statement_enum
:
7814 case lang_wild_statement_enum
:
7815 t
= &(*s
)->wild_statement
.children
.head
;
7817 case lang_group_statement_enum
:
7818 t
= &(*s
)->group_statement
.children
.head
;
7820 case lang_output_section_statement_enum
:
7821 t
= &(*s
)->output_section_statement
.children
.head
;
7826 t
= find_next_input_statement (t
);
7832 #endif /* BFD_SUPPORTS_PLUGINS */
7834 /* Add NAME to the list of garbage collection entry points. */
7837 lang_add_gc_name (const char *name
)
7839 struct bfd_sym_chain
*sym
;
7844 sym
= stat_alloc (sizeof (*sym
));
7846 sym
->next
= link_info
.gc_sym_list
;
7848 link_info
.gc_sym_list
= sym
;
7851 /* Check relocations. */
7854 lang_check_relocs (void)
7856 if (link_info
.check_relocs_after_open_input
)
7860 for (abfd
= link_info
.input_bfds
;
7861 abfd
!= (bfd
*) NULL
; abfd
= abfd
->link
.next
)
7862 if (!bfd_link_check_relocs (abfd
, &link_info
))
7864 /* No object output, fail return. */
7865 config
.make_executable
= FALSE
;
7866 /* Note: we do not abort the loop, but rather
7867 continue the scan in case there are other
7868 bad relocations to report. */
7873 /* Look through all output sections looking for places where we can
7874 propagate forward the lma region. */
7877 lang_propagate_lma_regions (void)
7879 lang_output_section_statement_type
*os
;
7881 for (os
= (void *) lang_os_list
.head
;
7885 if (os
->prev
!= NULL
7886 && os
->lma_region
== NULL
7887 && os
->load_base
== NULL
7888 && os
->addr_tree
== NULL
7889 && os
->region
== os
->prev
->region
)
7890 os
->lma_region
= os
->prev
->lma_region
;
7897 /* Finalize dynamic list. */
7898 if (link_info
.dynamic_list
)
7899 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
7901 current_target
= default_target
;
7903 /* Open the output file. */
7904 lang_for_each_statement (ldlang_open_output
);
7907 ldemul_create_output_section_statements ();
7909 /* Add to the hash table all undefineds on the command line. */
7910 lang_place_undefineds ();
7912 if (!bfd_section_already_linked_table_init ())
7913 einfo (_("%F%P: can not create hash table: %E\n"));
7915 /* A first pass through the memory regions ensures that if any region
7916 references a symbol for its origin or length then this symbol will be
7917 added to the symbol table. Having these symbols in the symbol table
7918 means that when we call open_input_bfds PROVIDE statements will
7919 trigger to provide any needed symbols. The regions origins and
7920 lengths are not assigned as a result of this call. */
7921 lang_do_memory_regions (FALSE
);
7923 /* Create a bfd for each input file. */
7924 current_target
= default_target
;
7925 lang_statement_iteration
++;
7926 open_input_bfds (statement_list
.head
, OPEN_BFD_NORMAL
);
7928 /* Now that open_input_bfds has processed assignments and provide
7929 statements we can give values to symbolic origin/length now. */
7930 lang_do_memory_regions (TRUE
);
7932 #if BFD_SUPPORTS_PLUGINS
7933 if (link_info
.lto_plugin_active
)
7935 lang_statement_list_type added
;
7936 lang_statement_list_type files
, inputfiles
;
7938 /* Now all files are read, let the plugin(s) decide if there
7939 are any more to be added to the link before we call the
7940 emulation's after_open hook. We create a private list of
7941 input statements for this purpose, which we will eventually
7942 insert into the global statement list after the first claimed
7945 /* We need to manipulate all three chains in synchrony. */
7947 inputfiles
= input_file_chain
;
7948 if (plugin_call_all_symbols_read ())
7949 einfo (_("%F%P: %s: plugin reported error after all symbols read\n"),
7950 plugin_error_plugin ());
7951 link_info
.lto_all_symbols_read
= TRUE
;
7952 /* Open any newly added files, updating the file chains. */
7953 plugin_undefs
= link_info
.hash
->undefs_tail
;
7954 open_input_bfds (*added
.tail
, OPEN_BFD_NORMAL
);
7955 if (plugin_undefs
== link_info
.hash
->undefs_tail
)
7956 plugin_undefs
= NULL
;
7957 /* Restore the global list pointer now they have all been added. */
7958 lang_list_remove_tail (stat_ptr
, &added
);
7959 /* And detach the fresh ends of the file lists. */
7960 lang_list_remove_tail (&file_chain
, &files
);
7961 lang_list_remove_tail (&input_file_chain
, &inputfiles
);
7962 /* Were any new files added? */
7963 if (added
.head
!= NULL
)
7965 /* If so, we will insert them into the statement list immediately
7966 after the first input file that was claimed by the plugin,
7967 unless that file was an archive in which case it is inserted
7968 immediately before. */
7970 lang_statement_union_type
**prev
;
7971 plugin_insert
= find_replacements_insert_point (&before
);
7972 /* If a plugin adds input files without having claimed any, we
7973 don't really have a good idea where to place them. Just putting
7974 them at the start or end of the list is liable to leave them
7975 outside the crtbegin...crtend range. */
7976 ASSERT (plugin_insert
!= NULL
);
7977 /* Splice the new statement list into the old one. */
7978 prev
= &plugin_insert
->header
.next
;
7981 prev
= find_next_input_statement (prev
);
7982 if (*prev
!= (void *) plugin_insert
->next_real_file
)
7984 /* We didn't find the expected input statement.
7985 Fall back to adding after plugin_insert. */
7986 prev
= &plugin_insert
->header
.next
;
7989 lang_list_insert_after (stat_ptr
, &added
, prev
);
7990 /* Likewise for the file chains. */
7991 lang_list_insert_after (&input_file_chain
, &inputfiles
,
7992 (void *) &plugin_insert
->next_real_file
);
7993 /* We must be careful when relinking file_chain; we may need to
7994 insert the new files at the head of the list if the insert
7995 point chosen is the dummy first input file. */
7996 if (plugin_insert
->filename
)
7997 lang_list_insert_after (&file_chain
, &files
,
7998 (void *) &plugin_insert
->next
);
8000 lang_list_insert_after (&file_chain
, &files
, &file_chain
.head
);
8002 /* Rescan archives in case new undefined symbols have appeared. */
8004 lang_statement_iteration
++;
8005 open_input_bfds (statement_list
.head
, OPEN_BFD_RESCAN
);
8006 lang_list_remove_tail (&file_chain
, &files
);
8007 while (files
.head
!= NULL
)
8009 lang_input_statement_type
**insert
;
8010 lang_input_statement_type
**iter
, *temp
;
8013 insert
= find_rescan_insertion (&files
.head
->input_statement
);
8014 /* All elements from an archive can be added at once. */
8015 iter
= &files
.head
->input_statement
.next
;
8016 my_arch
= files
.head
->input_statement
.the_bfd
->my_archive
;
8017 if (my_arch
!= NULL
)
8018 for (; *iter
!= NULL
; iter
= &(*iter
)->next
)
8019 if ((*iter
)->the_bfd
->my_archive
!= my_arch
)
8022 *insert
= &files
.head
->input_statement
;
8023 files
.head
= (lang_statement_union_type
*) *iter
;
8025 if (my_arch
!= NULL
)
8027 lang_input_statement_type
*parent
= bfd_usrdata (my_arch
);
8029 parent
->next
= (lang_input_statement_type
*)
8031 - offsetof (lang_input_statement_type
, next
));
8036 #endif /* BFD_SUPPORTS_PLUGINS */
8038 /* Make sure that nobody has tried to add a symbol to this list
8040 ASSERT (link_info
.gc_sym_list
== NULL
);
8042 link_info
.gc_sym_list
= &entry_symbol
;
8044 if (entry_symbol
.name
== NULL
)
8046 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
8048 /* entry_symbol is normally initialied by a ENTRY definition in the
8049 linker script or the -e command line option. But if neither of
8050 these have been used, the target specific backend may still have
8051 provided an entry symbol via a call to lang_default_entry().
8052 Unfortunately this value will not be processed until lang_end()
8053 is called, long after this function has finished. So detect this
8054 case here and add the target's entry symbol to the list of starting
8055 points for garbage collection resolution. */
8056 lang_add_gc_name (entry_symbol_default
);
8059 lang_add_gc_name (link_info
.init_function
);
8060 lang_add_gc_name (link_info
.fini_function
);
8062 ldemul_after_open ();
8063 if (config
.map_file
!= NULL
)
8064 lang_print_asneeded ();
8068 bfd_section_already_linked_table_free ();
8070 /* Make sure that we're not mixing architectures. We call this
8071 after all the input files have been opened, but before we do any
8072 other processing, so that any operations merge_private_bfd_data
8073 does on the output file will be known during the rest of the
8077 /* Handle .exports instead of a version script if we're told to do so. */
8078 if (command_line
.version_exports_section
)
8079 lang_do_version_exports_section ();
8081 /* Build all sets based on the information gathered from the input
8083 ldctor_build_sets ();
8085 /* Give initial values for __start and __stop symbols, so that ELF
8086 gc_sections will keep sections referenced by these symbols. Must
8087 be done before lang_do_assignments below. */
8088 if (config
.build_constructors
)
8089 lang_init_start_stop ();
8091 /* PR 13683: We must rerun the assignments prior to running garbage
8092 collection in order to make sure that all symbol aliases are resolved. */
8093 lang_do_assignments (lang_mark_phase_enum
);
8094 expld
.phase
= lang_first_phase_enum
;
8096 /* Size up the common data. */
8099 /* Remove unreferenced sections if asked to. */
8100 lang_gc_sections ();
8102 /* Check relocations. */
8103 lang_check_relocs ();
8105 ldemul_after_check_relocs ();
8107 /* Update wild statements. */
8108 update_wild_statements (statement_list
.head
);
8110 /* Run through the contours of the script and attach input sections
8111 to the correct output sections. */
8112 lang_statement_iteration
++;
8113 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
8115 /* Start at the statement immediately after the special abs_section
8116 output statement, so that it isn't reordered. */
8117 process_insert_statements (&lang_os_list
.head
->header
.next
);
8119 ldemul_before_place_orphans ();
8121 /* Find any sections not attached explicitly and handle them. */
8122 lang_place_orphans ();
8124 if (!bfd_link_relocatable (&link_info
))
8128 /* Merge SEC_MERGE sections. This has to be done after GC of
8129 sections, so that GCed sections are not merged, but before
8130 assigning dynamic symbols, since removing whole input sections
8132 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
8134 /* Look for a text section and set the readonly attribute in it. */
8135 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
8139 if (config
.text_read_only
)
8140 found
->flags
|= SEC_READONLY
;
8142 found
->flags
&= ~SEC_READONLY
;
8146 /* Merge together CTF sections. After this, only the symtab-dependent
8147 function and data object sections need adjustment. */
8150 /* Emit the CTF, iff the emulation doesn't need to do late emission after
8151 examining things laid out late, like the strtab. */
8154 /* Copy forward lma regions for output sections in same lma region. */
8155 lang_propagate_lma_regions ();
8157 /* Defining __start/__stop symbols early for --gc-sections to work
8158 around a glibc build problem can result in these symbols being
8159 defined when they should not be. Fix them now. */
8160 if (config
.build_constructors
)
8161 lang_undef_start_stop ();
8163 /* Define .startof./.sizeof. symbols with preliminary values before
8164 dynamic symbols are created. */
8165 if (!bfd_link_relocatable (&link_info
))
8166 lang_init_startof_sizeof ();
8168 /* Do anything special before sizing sections. This is where ELF
8169 and other back-ends size dynamic sections. */
8170 ldemul_before_allocation ();
8172 /* We must record the program headers before we try to fix the
8173 section positions, since they will affect SIZEOF_HEADERS. */
8174 lang_record_phdrs ();
8176 /* Check relro sections. */
8177 if (link_info
.relro
&& !bfd_link_relocatable (&link_info
))
8178 lang_find_relro_sections ();
8180 /* Size up the sections. */
8181 lang_size_sections (NULL
, !RELAXATION_ENABLED
);
8183 /* See if anything special should be done now we know how big
8184 everything is. This is where relaxation is done. */
8185 ldemul_after_allocation ();
8187 /* Fix any __start, __stop, .startof. or .sizeof. symbols. */
8188 lang_finalize_start_stop ();
8190 /* Do all the assignments again, to report errors. Assignment
8191 statements are processed multiple times, updating symbols; In
8192 open_input_bfds, lang_do_assignments, and lang_size_sections.
8193 Since lang_relax_sections calls lang_do_assignments, symbols are
8194 also updated in ldemul_after_allocation. */
8195 lang_do_assignments (lang_final_phase_enum
);
8199 /* Convert absolute symbols to section relative. */
8200 ldexp_finalize_syms ();
8202 /* Make sure that the section addresses make sense. */
8203 if (command_line
.check_section_addresses
)
8204 lang_check_section_addresses ();
8206 /* Check any required symbols are known. */
8207 ldlang_check_require_defined_symbols ();
8212 /* EXPORTED TO YACC */
8215 lang_add_wild (struct wildcard_spec
*filespec
,
8216 struct wildcard_list
*section_list
,
8217 bfd_boolean keep_sections
)
8219 struct wildcard_list
*curr
, *next
;
8220 lang_wild_statement_type
*new_stmt
;
8222 /* Reverse the list as the parser puts it back to front. */
8223 for (curr
= section_list
, section_list
= NULL
;
8225 section_list
= curr
, curr
= next
)
8228 curr
->next
= section_list
;
8231 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
8233 if (strcmp (filespec
->name
, "*") == 0)
8234 filespec
->name
= NULL
;
8235 else if (!wildcardp (filespec
->name
))
8236 lang_has_input_file
= TRUE
;
8239 new_stmt
= new_stat (lang_wild_statement
, stat_ptr
);
8240 new_stmt
->filename
= NULL
;
8241 new_stmt
->filenames_sorted
= FALSE
;
8242 new_stmt
->section_flag_list
= NULL
;
8243 new_stmt
->exclude_name_list
= NULL
;
8244 if (filespec
!= NULL
)
8246 new_stmt
->filename
= filespec
->name
;
8247 new_stmt
->filenames_sorted
= filespec
->sorted
== by_name
;
8248 new_stmt
->section_flag_list
= filespec
->section_flag_list
;
8249 new_stmt
->exclude_name_list
= filespec
->exclude_name_list
;
8251 new_stmt
->section_list
= section_list
;
8252 new_stmt
->keep_sections
= keep_sections
;
8253 lang_list_init (&new_stmt
->children
);
8254 analyze_walk_wild_section_handler (new_stmt
);
8258 lang_section_start (const char *name
, etree_type
*address
,
8259 const segment_type
*segment
)
8261 lang_address_statement_type
*ad
;
8263 ad
= new_stat (lang_address_statement
, stat_ptr
);
8264 ad
->section_name
= name
;
8265 ad
->address
= address
;
8266 ad
->segment
= segment
;
8269 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
8270 because of a -e argument on the command line, or zero if this is
8271 called by ENTRY in a linker script. Command line arguments take
8275 lang_add_entry (const char *name
, bfd_boolean cmdline
)
8277 if (entry_symbol
.name
== NULL
8279 || !entry_from_cmdline
)
8281 entry_symbol
.name
= name
;
8282 entry_from_cmdline
= cmdline
;
8286 /* Set the default start symbol to NAME. .em files should use this,
8287 not lang_add_entry, to override the use of "start" if neither the
8288 linker script nor the command line specifies an entry point. NAME
8289 must be permanently allocated. */
8291 lang_default_entry (const char *name
)
8293 entry_symbol_default
= name
;
8297 lang_add_target (const char *name
)
8299 lang_target_statement_type
*new_stmt
;
8301 new_stmt
= new_stat (lang_target_statement
, stat_ptr
);
8302 new_stmt
->target
= name
;
8306 lang_add_map (const char *name
)
8313 map_option_f
= TRUE
;
8321 lang_add_fill (fill_type
*fill
)
8323 lang_fill_statement_type
*new_stmt
;
8325 new_stmt
= new_stat (lang_fill_statement
, stat_ptr
);
8326 new_stmt
->fill
= fill
;
8330 lang_add_data (int type
, union etree_union
*exp
)
8332 lang_data_statement_type
*new_stmt
;
8334 new_stmt
= new_stat (lang_data_statement
, stat_ptr
);
8335 new_stmt
->exp
= exp
;
8336 new_stmt
->type
= type
;
8339 /* Create a new reloc statement. RELOC is the BFD relocation type to
8340 generate. HOWTO is the corresponding howto structure (we could
8341 look this up, but the caller has already done so). SECTION is the
8342 section to generate a reloc against, or NAME is the name of the
8343 symbol to generate a reloc against. Exactly one of SECTION and
8344 NAME must be NULL. ADDEND is an expression for the addend. */
8347 lang_add_reloc (bfd_reloc_code_real_type reloc
,
8348 reloc_howto_type
*howto
,
8351 union etree_union
*addend
)
8353 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
8357 p
->section
= section
;
8359 p
->addend_exp
= addend
;
8361 p
->addend_value
= 0;
8362 p
->output_section
= NULL
;
8363 p
->output_offset
= 0;
8366 lang_assignment_statement_type
*
8367 lang_add_assignment (etree_type
*exp
)
8369 lang_assignment_statement_type
*new_stmt
;
8371 new_stmt
= new_stat (lang_assignment_statement
, stat_ptr
);
8372 new_stmt
->exp
= exp
;
8377 lang_add_attribute (enum statement_enum attribute
)
8379 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
8383 lang_startup (const char *name
)
8385 if (first_file
->filename
!= NULL
)
8387 einfo (_("%F%P: multiple STARTUP files\n"));
8389 first_file
->filename
= name
;
8390 first_file
->local_sym_name
= name
;
8391 first_file
->flags
.real
= TRUE
;
8395 lang_float (bfd_boolean maybe
)
8397 lang_float_flag
= maybe
;
8401 /* Work out the load- and run-time regions from a script statement, and
8402 store them in *LMA_REGION and *REGION respectively.
8404 MEMSPEC is the name of the run-time region, or the value of
8405 DEFAULT_MEMORY_REGION if the statement didn't specify one.
8406 LMA_MEMSPEC is the name of the load-time region, or null if the
8407 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
8408 had an explicit load address.
8410 It is an error to specify both a load region and a load address. */
8413 lang_get_regions (lang_memory_region_type
**region
,
8414 lang_memory_region_type
**lma_region
,
8415 const char *memspec
,
8416 const char *lma_memspec
,
8417 bfd_boolean have_lma
,
8418 bfd_boolean have_vma
)
8420 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
8422 /* If no runtime region or VMA has been specified, but the load region
8423 has been specified, then use the load region for the runtime region
8425 if (lma_memspec
!= NULL
8427 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
8428 *region
= *lma_region
;
8430 *region
= lang_memory_region_lookup (memspec
, FALSE
);
8432 if (have_lma
&& lma_memspec
!= 0)
8433 einfo (_("%X%P:%pS: section has both a load address and a load region\n"),
8438 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
8439 lang_output_section_phdr_list
*phdrs
,
8440 const char *lma_memspec
)
8442 lang_get_regions (¤t_section
->region
,
8443 ¤t_section
->lma_region
,
8444 memspec
, lma_memspec
,
8445 current_section
->load_base
!= NULL
,
8446 current_section
->addr_tree
!= NULL
);
8448 current_section
->fill
= fill
;
8449 current_section
->phdrs
= phdrs
;
8453 /* Set the output format type. -oformat overrides scripts. */
8456 lang_add_output_format (const char *format
,
8461 if (output_target
== NULL
|| !from_script
)
8463 if (command_line
.endian
== ENDIAN_BIG
8466 else if (command_line
.endian
== ENDIAN_LITTLE
8470 output_target
= format
;
8475 lang_add_insert (const char *where
, int is_before
)
8477 lang_insert_statement_type
*new_stmt
;
8479 new_stmt
= new_stat (lang_insert_statement
, stat_ptr
);
8480 new_stmt
->where
= where
;
8481 new_stmt
->is_before
= is_before
;
8482 saved_script_handle
= previous_script_handle
;
8485 /* Enter a group. This creates a new lang_group_statement, and sets
8486 stat_ptr to build new statements within the group. */
8489 lang_enter_group (void)
8491 lang_group_statement_type
*g
;
8493 g
= new_stat (lang_group_statement
, stat_ptr
);
8494 lang_list_init (&g
->children
);
8495 push_stat_ptr (&g
->children
);
8498 /* Leave a group. This just resets stat_ptr to start writing to the
8499 regular list of statements again. Note that this will not work if
8500 groups can occur inside anything else which can adjust stat_ptr,
8501 but currently they can't. */
8504 lang_leave_group (void)
8509 /* Add a new program header. This is called for each entry in a PHDRS
8510 command in a linker script. */
8513 lang_new_phdr (const char *name
,
8515 bfd_boolean filehdr
,
8520 struct lang_phdr
*n
, **pp
;
8523 n
= stat_alloc (sizeof (struct lang_phdr
));
8526 n
->type
= exp_get_vma (type
, 0, "program header type");
8527 n
->filehdr
= filehdr
;
8532 hdrs
= n
->type
== 1 && (phdrs
|| filehdr
);
8534 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
8537 && !((*pp
)->filehdr
|| (*pp
)->phdrs
))
8539 einfo (_("%X%P:%pS: PHDRS and FILEHDR are not supported"
8540 " when prior PT_LOAD headers lack them\n"), NULL
);
8547 /* Record the program header information in the output BFD. FIXME: We
8548 should not be calling an ELF specific function here. */
8551 lang_record_phdrs (void)
8555 lang_output_section_phdr_list
*last
;
8556 struct lang_phdr
*l
;
8557 lang_output_section_statement_type
*os
;
8560 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
8563 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
8570 for (os
= (void *) lang_os_list
.head
;
8574 lang_output_section_phdr_list
*pl
;
8576 if (os
->constraint
< 0)
8584 if (os
->sectype
== noload_section
8585 || os
->bfd_section
== NULL
8586 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
8589 /* Don't add orphans to PT_INTERP header. */
8595 lang_output_section_statement_type
*tmp_os
;
8597 /* If we have not run across a section with a program
8598 header assigned to it yet, then scan forwards to find
8599 one. This prevents inconsistencies in the linker's
8600 behaviour when a script has specified just a single
8601 header and there are sections in that script which are
8602 not assigned to it, and which occur before the first
8603 use of that header. See here for more details:
8604 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
8605 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
8608 last
= tmp_os
->phdrs
;
8612 einfo (_("%F%P: no sections assigned to phdrs\n"));
8617 if (os
->bfd_section
== NULL
)
8620 for (; pl
!= NULL
; pl
= pl
->next
)
8622 if (strcmp (pl
->name
, l
->name
) == 0)
8627 secs
= (asection
**) xrealloc (secs
,
8628 alc
* sizeof (asection
*));
8630 secs
[c
] = os
->bfd_section
;
8637 if (l
->flags
== NULL
)
8640 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
8645 at
= exp_get_vma (l
->at
, 0, "phdr load address");
8647 if (!bfd_record_phdr (link_info
.output_bfd
, l
->type
,
8648 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
8649 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
8650 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
8655 /* Make sure all the phdr assignments succeeded. */
8656 for (os
= (void *) lang_os_list
.head
;
8660 lang_output_section_phdr_list
*pl
;
8662 if (os
->constraint
< 0
8663 || os
->bfd_section
== NULL
)
8666 for (pl
= os
->phdrs
;
8669 if (!pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
8670 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
8671 os
->name
, pl
->name
);
8675 /* Record a list of sections which may not be cross referenced. */
8678 lang_add_nocrossref (lang_nocrossref_type
*l
)
8680 struct lang_nocrossrefs
*n
;
8682 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
8683 n
->next
= nocrossref_list
;
8685 n
->onlyfirst
= FALSE
;
8686 nocrossref_list
= n
;
8688 /* Set notice_all so that we get informed about all symbols. */
8689 link_info
.notice_all
= TRUE
;
8692 /* Record a section that cannot be referenced from a list of sections. */
8695 lang_add_nocrossref_to (lang_nocrossref_type
*l
)
8697 lang_add_nocrossref (l
);
8698 nocrossref_list
->onlyfirst
= TRUE
;
8701 /* Overlay handling. We handle overlays with some static variables. */
8703 /* The overlay virtual address. */
8704 static etree_type
*overlay_vma
;
8705 /* And subsection alignment. */
8706 static etree_type
*overlay_subalign
;
8708 /* An expression for the maximum section size seen so far. */
8709 static etree_type
*overlay_max
;
8711 /* A list of all the sections in this overlay. */
8713 struct overlay_list
{
8714 struct overlay_list
*next
;
8715 lang_output_section_statement_type
*os
;
8718 static struct overlay_list
*overlay_list
;
8720 /* Start handling an overlay. */
8723 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
8725 /* The grammar should prevent nested overlays from occurring. */
8726 ASSERT (overlay_vma
== NULL
8727 && overlay_subalign
== NULL
8728 && overlay_max
== NULL
);
8730 overlay_vma
= vma_expr
;
8731 overlay_subalign
= subalign
;
8734 /* Start a section in an overlay. We handle this by calling
8735 lang_enter_output_section_statement with the correct VMA.
8736 lang_leave_overlay sets up the LMA and memory regions. */
8739 lang_enter_overlay_section (const char *name
)
8741 struct overlay_list
*n
;
8744 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
8745 0, overlay_subalign
, 0, 0, 0);
8747 /* If this is the first section, then base the VMA of future
8748 sections on this one. This will work correctly even if `.' is
8749 used in the addresses. */
8750 if (overlay_list
== NULL
)
8751 overlay_vma
= exp_nameop (ADDR
, name
);
8753 /* Remember the section. */
8754 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
8755 n
->os
= current_section
;
8756 n
->next
= overlay_list
;
8759 size
= exp_nameop (SIZEOF
, name
);
8761 /* Arrange to work out the maximum section end address. */
8762 if (overlay_max
== NULL
)
8765 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
8768 /* Finish a section in an overlay. There isn't any special to do
8772 lang_leave_overlay_section (fill_type
*fill
,
8773 lang_output_section_phdr_list
*phdrs
)
8780 name
= current_section
->name
;
8782 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
8783 region and that no load-time region has been specified. It doesn't
8784 really matter what we say here, since lang_leave_overlay will
8786 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
8788 /* Define the magic symbols. */
8790 clean
= (char *) xmalloc (strlen (name
) + 1);
8792 for (s1
= name
; *s1
!= '\0'; s1
++)
8793 if (ISALNUM (*s1
) || *s1
== '_')
8797 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_start_");
8798 sprintf (buf
, "__load_start_%s", clean
);
8799 lang_add_assignment (exp_provide (buf
,
8800 exp_nameop (LOADADDR
, name
),
8803 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_stop_");
8804 sprintf (buf
, "__load_stop_%s", clean
);
8805 lang_add_assignment (exp_provide (buf
,
8807 exp_nameop (LOADADDR
, name
),
8808 exp_nameop (SIZEOF
, name
)),
8814 /* Finish an overlay. If there are any overlay wide settings, this
8815 looks through all the sections in the overlay and sets them. */
8818 lang_leave_overlay (etree_type
*lma_expr
,
8821 const char *memspec
,
8822 lang_output_section_phdr_list
*phdrs
,
8823 const char *lma_memspec
)
8825 lang_memory_region_type
*region
;
8826 lang_memory_region_type
*lma_region
;
8827 struct overlay_list
*l
;
8828 lang_nocrossref_type
*nocrossref
;
8830 lang_get_regions (®ion
, &lma_region
,
8831 memspec
, lma_memspec
,
8832 lma_expr
!= NULL
, FALSE
);
8836 /* After setting the size of the last section, set '.' to end of the
8838 if (overlay_list
!= NULL
)
8840 overlay_list
->os
->update_dot
= 1;
8841 overlay_list
->os
->update_dot_tree
8842 = exp_assign (".", exp_binop ('+', overlay_vma
, overlay_max
), FALSE
);
8848 struct overlay_list
*next
;
8850 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
8853 l
->os
->region
= region
;
8854 l
->os
->lma_region
= lma_region
;
8856 /* The first section has the load address specified in the
8857 OVERLAY statement. The rest are worked out from that.
8858 The base address is not needed (and should be null) if
8859 an LMA region was specified. */
8862 l
->os
->load_base
= lma_expr
;
8863 l
->os
->sectype
= first_overlay_section
;
8865 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
8866 l
->os
->phdrs
= phdrs
;
8870 lang_nocrossref_type
*nc
;
8872 nc
= (lang_nocrossref_type
*) xmalloc (sizeof *nc
);
8873 nc
->name
= l
->os
->name
;
8874 nc
->next
= nocrossref
;
8883 if (nocrossref
!= NULL
)
8884 lang_add_nocrossref (nocrossref
);
8887 overlay_list
= NULL
;
8889 overlay_subalign
= NULL
;
8892 /* Version handling. This is only useful for ELF. */
8894 /* If PREV is NULL, return first version pattern matching particular symbol.
8895 If PREV is non-NULL, return first version pattern matching particular
8896 symbol after PREV (previously returned by lang_vers_match). */
8898 static struct bfd_elf_version_expr
*
8899 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
8900 struct bfd_elf_version_expr
*prev
,
8904 const char *cxx_sym
= sym
;
8905 const char *java_sym
= sym
;
8906 struct bfd_elf_version_expr
*expr
= NULL
;
8907 enum demangling_styles curr_style
;
8909 curr_style
= CURRENT_DEMANGLING_STYLE
;
8910 cplus_demangle_set_style (no_demangling
);
8911 c_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_NO_OPTS
);
8914 cplus_demangle_set_style (curr_style
);
8916 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8918 cxx_sym
= bfd_demangle (link_info
.output_bfd
, sym
,
8919 DMGL_PARAMS
| DMGL_ANSI
);
8923 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8925 java_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_JAVA
);
8930 if (head
->htab
&& (prev
== NULL
|| prev
->literal
))
8932 struct bfd_elf_version_expr e
;
8934 switch (prev
? prev
->mask
: 0)
8937 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
8940 expr
= (struct bfd_elf_version_expr
*)
8941 htab_find ((htab_t
) head
->htab
, &e
);
8942 while (expr
&& strcmp (expr
->pattern
, c_sym
) == 0)
8943 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
8949 case BFD_ELF_VERSION_C_TYPE
:
8950 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8952 e
.pattern
= cxx_sym
;
8953 expr
= (struct bfd_elf_version_expr
*)
8954 htab_find ((htab_t
) head
->htab
, &e
);
8955 while (expr
&& strcmp (expr
->pattern
, cxx_sym
) == 0)
8956 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
8962 case BFD_ELF_VERSION_CXX_TYPE
:
8963 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8965 e
.pattern
= java_sym
;
8966 expr
= (struct bfd_elf_version_expr
*)
8967 htab_find ((htab_t
) head
->htab
, &e
);
8968 while (expr
&& strcmp (expr
->pattern
, java_sym
) == 0)
8969 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8980 /* Finally, try the wildcards. */
8981 if (prev
== NULL
|| prev
->literal
)
8982 expr
= head
->remaining
;
8985 for (; expr
; expr
= expr
->next
)
8992 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
8995 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8997 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
9001 if (fnmatch (expr
->pattern
, s
, 0) == 0)
9007 free ((char *) c_sym
);
9009 free ((char *) cxx_sym
);
9010 if (java_sym
!= sym
)
9011 free ((char *) java_sym
);
9015 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
9016 return a pointer to the symbol name with any backslash quotes removed. */
9019 realsymbol (const char *pattern
)
9022 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
9023 char *s
, *symbol
= (char *) xmalloc (strlen (pattern
) + 1);
9025 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
9027 /* It is a glob pattern only if there is no preceding
9031 /* Remove the preceding backslash. */
9038 if (*p
== '?' || *p
== '*' || *p
== '[')
9045 backslash
= *p
== '\\';
9061 /* This is called for each variable name or match expression. NEW_NAME is
9062 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
9063 pattern to be matched against symbol names. */
9065 struct bfd_elf_version_expr
*
9066 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
9067 const char *new_name
,
9069 bfd_boolean literal_p
)
9071 struct bfd_elf_version_expr
*ret
;
9073 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
9077 ret
->literal
= TRUE
;
9078 ret
->pattern
= literal_p
? new_name
: realsymbol (new_name
);
9079 if (ret
->pattern
== NULL
)
9081 ret
->pattern
= new_name
;
9082 ret
->literal
= FALSE
;
9085 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
9086 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
9087 else if (strcasecmp (lang
, "C++") == 0)
9088 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
9089 else if (strcasecmp (lang
, "Java") == 0)
9090 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
9093 einfo (_("%X%P: unknown language `%s' in version information\n"),
9095 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
9098 return ldemul_new_vers_pattern (ret
);
9101 /* This is called for each set of variable names and match
9104 struct bfd_elf_version_tree
*
9105 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
9106 struct bfd_elf_version_expr
*locals
)
9108 struct bfd_elf_version_tree
*ret
;
9110 ret
= (struct bfd_elf_version_tree
*) xcalloc (1, sizeof *ret
);
9111 ret
->globals
.list
= globals
;
9112 ret
->locals
.list
= locals
;
9113 ret
->match
= lang_vers_match
;
9114 ret
->name_indx
= (unsigned int) -1;
9118 /* This static variable keeps track of version indices. */
9120 static int version_index
;
9123 version_expr_head_hash (const void *p
)
9125 const struct bfd_elf_version_expr
*e
=
9126 (const struct bfd_elf_version_expr
*) p
;
9128 return htab_hash_string (e
->pattern
);
9132 version_expr_head_eq (const void *p1
, const void *p2
)
9134 const struct bfd_elf_version_expr
*e1
=
9135 (const struct bfd_elf_version_expr
*) p1
;
9136 const struct bfd_elf_version_expr
*e2
=
9137 (const struct bfd_elf_version_expr
*) p2
;
9139 return strcmp (e1
->pattern
, e2
->pattern
) == 0;
9143 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
9146 struct bfd_elf_version_expr
*e
, *next
;
9147 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
9149 for (e
= head
->list
; e
; e
= e
->next
)
9153 head
->mask
|= e
->mask
;
9158 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
9159 version_expr_head_eq
, NULL
);
9160 list_loc
= &head
->list
;
9161 remaining_loc
= &head
->remaining
;
9162 for (e
= head
->list
; e
; e
= next
)
9168 remaining_loc
= &e
->next
;
9172 void **loc
= htab_find_slot ((htab_t
) head
->htab
, e
, INSERT
);
9176 struct bfd_elf_version_expr
*e1
, *last
;
9178 e1
= (struct bfd_elf_version_expr
*) *loc
;
9182 if (e1
->mask
== e
->mask
)
9190 while (e1
&& strcmp (e1
->pattern
, e
->pattern
) == 0);
9194 /* This is a duplicate. */
9195 /* FIXME: Memory leak. Sometimes pattern is not
9196 xmalloced alone, but in larger chunk of memory. */
9197 /* free (e->pattern); */
9202 e
->next
= last
->next
;
9210 list_loc
= &e
->next
;
9214 *remaining_loc
= NULL
;
9215 *list_loc
= head
->remaining
;
9218 head
->remaining
= head
->list
;
9221 /* This is called when we know the name and dependencies of the
9225 lang_register_vers_node (const char *name
,
9226 struct bfd_elf_version_tree
*version
,
9227 struct bfd_elf_version_deps
*deps
)
9229 struct bfd_elf_version_tree
*t
, **pp
;
9230 struct bfd_elf_version_expr
*e1
;
9235 if (link_info
.version_info
!= NULL
9236 && (name
[0] == '\0' || link_info
.version_info
->name
[0] == '\0'))
9238 einfo (_("%X%P: anonymous version tag cannot be combined"
9239 " with other version tags\n"));
9244 /* Make sure this node has a unique name. */
9245 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9246 if (strcmp (t
->name
, name
) == 0)
9247 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
9249 lang_finalize_version_expr_head (&version
->globals
);
9250 lang_finalize_version_expr_head (&version
->locals
);
9252 /* Check the global and local match names, and make sure there
9253 aren't any duplicates. */
9255 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
9257 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9259 struct bfd_elf_version_expr
*e2
;
9261 if (t
->locals
.htab
&& e1
->literal
)
9263 e2
= (struct bfd_elf_version_expr
*)
9264 htab_find ((htab_t
) t
->locals
.htab
, e1
);
9265 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
9267 if (e1
->mask
== e2
->mask
)
9268 einfo (_("%X%P: duplicate expression `%s'"
9269 " in version information\n"), e1
->pattern
);
9273 else if (!e1
->literal
)
9274 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
9275 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
9276 && e1
->mask
== e2
->mask
)
9277 einfo (_("%X%P: duplicate expression `%s'"
9278 " in version information\n"), e1
->pattern
);
9282 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
9284 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9286 struct bfd_elf_version_expr
*e2
;
9288 if (t
->globals
.htab
&& e1
->literal
)
9290 e2
= (struct bfd_elf_version_expr
*)
9291 htab_find ((htab_t
) t
->globals
.htab
, e1
);
9292 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
9294 if (e1
->mask
== e2
->mask
)
9295 einfo (_("%X%P: duplicate expression `%s'"
9296 " in version information\n"),
9301 else if (!e1
->literal
)
9302 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
9303 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
9304 && e1
->mask
== e2
->mask
)
9305 einfo (_("%X%P: duplicate expression `%s'"
9306 " in version information\n"), e1
->pattern
);
9310 version
->deps
= deps
;
9311 version
->name
= name
;
9312 if (name
[0] != '\0')
9315 version
->vernum
= version_index
;
9318 version
->vernum
= 0;
9320 for (pp
= &link_info
.version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
9325 /* This is called when we see a version dependency. */
9327 struct bfd_elf_version_deps
*
9328 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
9330 struct bfd_elf_version_deps
*ret
;
9331 struct bfd_elf_version_tree
*t
;
9333 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
9336 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9338 if (strcmp (t
->name
, name
) == 0)
9340 ret
->version_needed
= t
;
9345 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
9347 ret
->version_needed
= NULL
;
9352 lang_do_version_exports_section (void)
9354 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
9356 LANG_FOR_EACH_INPUT_STATEMENT (is
)
9358 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
9366 contents
= (char *) xmalloc (len
);
9367 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
9368 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
9371 while (p
< contents
+ len
)
9373 greg
= lang_new_vers_pattern (greg
, p
, NULL
, FALSE
);
9374 p
= strchr (p
, '\0') + 1;
9377 /* Do not free the contents, as we used them creating the regex. */
9379 /* Do not include this section in the link. */
9380 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
9383 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, FALSE
);
9384 lang_register_vers_node (command_line
.version_exports_section
,
9385 lang_new_vers_node (greg
, lreg
), NULL
);
9388 /* Evaluate LENGTH and ORIGIN parts of MEMORY spec. This is initially
9389 called with UPDATE_REGIONS_P set to FALSE, in this case no errors are
9390 thrown, however, references to symbols in the origin and length fields
9391 will be pushed into the symbol table, this allows PROVIDE statements to
9392 then provide these symbols. This function is called a second time with
9393 UPDATE_REGIONS_P set to TRUE, this time the we update the actual region
9394 data structures, and throw errors if missing symbols are encountered. */
9397 lang_do_memory_regions (bfd_boolean update_regions_p
)
9399 lang_memory_region_type
*r
= lang_memory_region_list
;
9401 for (; r
!= NULL
; r
= r
->next
)
9405 exp_fold_tree_no_dot (r
->origin_exp
);
9406 if (update_regions_p
)
9408 if (expld
.result
.valid_p
)
9410 r
->origin
= expld
.result
.value
;
9411 r
->current
= r
->origin
;
9414 einfo (_("%P: invalid origin for memory region %s\n"),
9420 exp_fold_tree_no_dot (r
->length_exp
);
9421 if (update_regions_p
)
9423 if (expld
.result
.valid_p
)
9424 r
->length
= expld
.result
.value
;
9426 einfo (_("%P: invalid length for memory region %s\n"),
9434 lang_add_unique (const char *name
)
9436 struct unique_sections
*ent
;
9438 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
9439 if (strcmp (ent
->name
, name
) == 0)
9442 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
9443 ent
->name
= xstrdup (name
);
9444 ent
->next
= unique_section_list
;
9445 unique_section_list
= ent
;
9448 /* Append the list of dynamic symbols to the existing one. */
9451 lang_append_dynamic_list (struct bfd_elf_dynamic_list
**list_p
,
9452 struct bfd_elf_version_expr
*dynamic
)
9456 struct bfd_elf_version_expr
*tail
;
9457 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
9459 tail
->next
= (*list_p
)->head
.list
;
9460 (*list_p
)->head
.list
= dynamic
;
9464 struct bfd_elf_dynamic_list
*d
;
9466 d
= (struct bfd_elf_dynamic_list
*) xcalloc (1, sizeof *d
);
9467 d
->head
.list
= dynamic
;
9468 d
->match
= lang_vers_match
;
9473 /* Append the list of C++ typeinfo dynamic symbols to the existing
9477 lang_append_dynamic_list_cpp_typeinfo (void)
9479 const char *symbols
[] =
9481 "typeinfo name for*",
9484 struct bfd_elf_version_expr
*dynamic
= NULL
;
9487 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9488 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9491 lang_append_dynamic_list (&link_info
.dynamic_list
, dynamic
);
9494 /* Append the list of C++ operator new and delete dynamic symbols to the
9498 lang_append_dynamic_list_cpp_new (void)
9500 const char *symbols
[] =
9505 struct bfd_elf_version_expr
*dynamic
= NULL
;
9508 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9509 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9512 lang_append_dynamic_list (&link_info
.dynamic_list
, dynamic
);
9515 /* Scan a space and/or comma separated string of features. */
9518 lang_ld_feature (char *str
)
9526 while (*p
== ',' || ISSPACE (*p
))
9531 while (*q
&& *q
!= ',' && !ISSPACE (*q
))
9535 if (strcasecmp (p
, "SANE_EXPR") == 0)
9536 config
.sane_expr
= TRUE
;
9538 einfo (_("%X%P: unknown feature `%s'\n"), p
);
9544 /* Pretty print memory amount. */
9547 lang_print_memory_size (bfd_vma sz
)
9549 if ((sz
& 0x3fffffff) == 0)
9550 printf ("%10" BFD_VMA_FMT
"u GB", sz
>> 30);
9551 else if ((sz
& 0xfffff) == 0)
9552 printf ("%10" BFD_VMA_FMT
"u MB", sz
>> 20);
9553 else if ((sz
& 0x3ff) == 0)
9554 printf ("%10" BFD_VMA_FMT
"u KB", sz
>> 10);
9556 printf (" %10" BFD_VMA_FMT
"u B", sz
);
9559 /* Implement --print-memory-usage: disply per region memory usage. */
9562 lang_print_memory_usage (void)
9564 lang_memory_region_type
*r
;
9566 printf ("Memory region Used Size Region Size %%age Used\n");
9567 for (r
= lang_memory_region_list
; r
->next
!= NULL
; r
= r
->next
)
9569 bfd_vma used_length
= r
->current
- r
->origin
;
9571 printf ("%16s: ",r
->name_list
.name
);
9572 lang_print_memory_size (used_length
);
9573 lang_print_memory_size ((bfd_vma
) r
->length
);
9577 double percent
= used_length
* 100.0 / r
->length
;
9578 printf (" %6.2f%%", percent
);