1 /* Linker command language support.
2 Copyright (C) 1991-2021 Free Software Foundation, Inc.
4 This file is part of the GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
24 #include "libiberty.h"
25 #include "filenames.h"
26 #include "safe-ctype.h"
45 #if BFD_SUPPORTS_PLUGINS
47 #endif /* BFD_SUPPORTS_PLUGINS */
50 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
53 /* Convert between addresses in bytes and sizes in octets.
54 For currently supported targets, octets_per_byte is always a power
55 of two, so we can use shifts. */
56 #define TO_ADDR(X) ((X) >> opb_shift)
57 #define TO_SIZE(X) ((X) << opb_shift)
59 /* Local variables. */
60 static struct obstack stat_obstack
;
61 static struct obstack map_obstack
;
63 #define obstack_chunk_alloc xmalloc
64 #define obstack_chunk_free free
65 static const char *entry_symbol_default
= "start";
66 static 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 static lang_statement_list_type
*stat_save
[10];
73 static lang_statement_list_type
**stat_save_ptr
= &stat_save
[0];
74 static struct unique_sections
*unique_section_list
;
75 static struct asneeded_minfo
*asneeded_list_head
;
76 static unsigned int opb_shift
= 0;
78 /* Forward declarations. */
79 static void exp_init_os (etree_type
*);
80 static lang_input_statement_type
*lookup_name (const char *);
81 static void insert_undefined (const char *);
82 static bfd_boolean
sort_def_symbol (struct bfd_link_hash_entry
*, void *);
83 static void print_statement (lang_statement_union_type
*,
84 lang_output_section_statement_type
*);
85 static void print_statement_list (lang_statement_union_type
*,
86 lang_output_section_statement_type
*);
87 static void print_statements (void);
88 static void print_input_section (asection
*, bfd_boolean
);
89 static bfd_boolean
lang_one_common (struct bfd_link_hash_entry
*, void *);
90 static void lang_record_phdrs (void);
91 static void lang_do_version_exports_section (void);
92 static void lang_finalize_version_expr_head
93 (struct bfd_elf_version_expr_head
*);
94 static void lang_do_memory_regions (bfd_boolean
);
96 /* Exported variables. */
97 const char *output_target
;
98 lang_output_section_statement_type
*abs_output_section
;
99 /* Header for list of statements corresponding to any files involved in the
100 link, either specified from the command-line or added implicitely (eg.
101 archive member used to resolved undefined symbol, wildcard statement from
102 linker script, etc.). Next pointer is in next field of a
103 lang_statement_header_type (reached via header field in a
104 lang_statement_union). */
105 lang_statement_list_type statement_list
;
106 lang_statement_list_type lang_os_list
;
107 lang_statement_list_type
*stat_ptr
= &statement_list
;
108 /* Header for list of statements corresponding to files used in the final
109 executable. This can be either object file specified on the command-line
110 or library member resolving an undefined reference. Next pointer is in next
111 field of a lang_input_statement_type (reached via input_statement field in a
112 lang_statement_union). */
113 lang_statement_list_type file_chain
= { NULL
, NULL
};
114 /* Header for list of statements corresponding to files specified on the
115 command-line for linking. It thus contains real object files and archive
116 but not archive members. Next pointer is in next_real_file field of a
117 lang_input_statement_type statement (reached via input_statement field in a
118 lang_statement_union). */
119 lang_statement_list_type input_file_chain
;
120 static const char *current_input_file
;
121 struct bfd_elf_dynamic_list
**current_dynamic_list_p
;
122 struct bfd_sym_chain entry_symbol
= { NULL
, NULL
};
123 const char *entry_section
= ".text";
124 struct lang_input_statement_flags input_flags
;
125 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
, file
, data
);
326 /* Lowest common denominator routine that can handle everything correctly,
330 walk_wild_section_general (lang_wild_statement_type
*ptr
,
331 lang_input_statement_type
*file
,
336 struct wildcard_list
*sec
;
338 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
340 sec
= ptr
->section_list
;
342 (*callback
) (ptr
, sec
, s
, file
, data
);
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 lang_input_statement_type
*file
,
572 lang_section_bst_type
*node
;
573 lang_section_bst_type
**tree
;
574 lang_output_section_statement_type
*os
;
576 os
= (lang_output_section_statement_type
*) output
;
578 if (unique_section_p (section
, os
))
581 node
= (lang_section_bst_type
*) xmalloc (sizeof (lang_section_bst_type
));
584 node
->section
= section
;
585 node
->pattern
= ptr
->section_list
;
587 tree
= wild_sort_fast (ptr
, sec
, file
, section
);
592 /* Convert a sorted sections' BST back to list form. */
595 output_section_callback_tree_to_list (lang_wild_statement_type
*ptr
,
596 lang_section_bst_type
*tree
,
600 output_section_callback_tree_to_list (ptr
, tree
->left
, output
);
602 lang_add_section (&ptr
->children
, tree
->section
, tree
->pattern
, NULL
,
603 (lang_output_section_statement_type
*) output
);
606 output_section_callback_tree_to_list (ptr
, tree
->right
, output
);
611 /* Specialized, optimized routines for handling different kinds of
615 walk_wild_section_specs1_wild0 (lang_wild_statement_type
*ptr
,
616 lang_input_statement_type
*file
,
620 /* We can just do a hash lookup for the section with the right name.
621 But if that lookup discovers more than one section with the name
622 (should be rare), we fall back to the general algorithm because
623 we would otherwise have to sort the sections to make sure they
624 get processed in the bfd's order. */
625 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
== '=' || startswith (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 entry
->s
.output_section_statement
.dup_output
= (create
== 2
1530 || constraint
== SPECIAL
);
1531 return &entry
->s
.output_section_statement
;
1534 /* Find the next output_section_statement with the same name as OS.
1535 If CONSTRAINT is non-zero, find one with that constraint otherwise
1536 match any non-negative constraint. */
1538 lang_output_section_statement_type
*
1539 next_matching_output_section_statement (lang_output_section_statement_type
*os
,
1542 /* All output_section_statements are actually part of a
1543 struct out_section_hash_entry. */
1544 struct out_section_hash_entry
*entry
= (struct out_section_hash_entry
*)
1546 - offsetof (struct out_section_hash_entry
, s
.output_section_statement
));
1547 const char *name
= os
->name
;
1549 ASSERT (name
== entry
->root
.string
);
1552 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1554 || name
!= entry
->s
.output_section_statement
.name
)
1557 while (constraint
!= entry
->s
.output_section_statement
.constraint
1559 || entry
->s
.output_section_statement
.constraint
< 0));
1561 return &entry
->s
.output_section_statement
;
1564 /* A variant of lang_output_section_find used by place_orphan.
1565 Returns the output statement that should precede a new output
1566 statement for SEC. If an exact match is found on certain flags,
1569 lang_output_section_statement_type
*
1570 lang_output_section_find_by_flags (const asection
*sec
,
1572 lang_output_section_statement_type
**exact
,
1573 lang_match_sec_type_func match_type
)
1575 lang_output_section_statement_type
*first
, *look
, *found
;
1576 flagword look_flags
, differ
;
1578 /* We know the first statement on this list is *ABS*. May as well
1580 first
= (void *) lang_os_list
.head
;
1581 first
= first
->next
;
1583 /* First try for an exact match. */
1585 for (look
= first
; look
; look
= look
->next
)
1587 look_flags
= look
->flags
;
1588 if (look
->bfd_section
!= NULL
)
1590 look_flags
= look
->bfd_section
->flags
;
1591 if (match_type
&& !match_type (link_info
.output_bfd
,
1596 differ
= look_flags
^ sec_flags
;
1597 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1598 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1608 if ((sec_flags
& SEC_CODE
) != 0
1609 && (sec_flags
& SEC_ALLOC
) != 0)
1611 /* Try for a rw code section. */
1612 for (look
= first
; look
; look
= look
->next
)
1614 look_flags
= look
->flags
;
1615 if (look
->bfd_section
!= NULL
)
1617 look_flags
= look
->bfd_section
->flags
;
1618 if (match_type
&& !match_type (link_info
.output_bfd
,
1623 differ
= look_flags
^ sec_flags
;
1624 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1625 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1629 else if ((sec_flags
& SEC_READONLY
) != 0
1630 && (sec_flags
& SEC_ALLOC
) != 0)
1632 /* .rodata can go after .text, .sdata2 after .rodata. */
1633 for (look
= first
; look
; look
= look
->next
)
1635 look_flags
= look
->flags
;
1636 if (look
->bfd_section
!= NULL
)
1638 look_flags
= look
->bfd_section
->flags
;
1639 if (match_type
&& !match_type (link_info
.output_bfd
,
1644 differ
= look_flags
^ sec_flags
;
1645 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1646 | SEC_READONLY
| SEC_SMALL_DATA
))
1647 || (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1649 && !(look_flags
& SEC_SMALL_DATA
)))
1653 else if ((sec_flags
& SEC_THREAD_LOCAL
) != 0
1654 && (sec_flags
& SEC_ALLOC
) != 0)
1656 /* .tdata can go after .data, .tbss after .tdata. Treat .tbss
1657 as if it were a loaded section, and don't use match_type. */
1658 bfd_boolean seen_thread_local
= FALSE
;
1661 for (look
= first
; look
; look
= look
->next
)
1663 look_flags
= look
->flags
;
1664 if (look
->bfd_section
!= NULL
)
1665 look_flags
= look
->bfd_section
->flags
;
1667 differ
= look_flags
^ (sec_flags
| SEC_LOAD
| SEC_HAS_CONTENTS
);
1668 if (!(differ
& (SEC_THREAD_LOCAL
| SEC_ALLOC
)))
1670 /* .tdata and .tbss must be adjacent and in that order. */
1671 if (!(look_flags
& SEC_LOAD
)
1672 && (sec_flags
& SEC_LOAD
))
1673 /* ..so if we're at a .tbss section and we're placing
1674 a .tdata section stop looking and return the
1675 previous section. */
1678 seen_thread_local
= TRUE
;
1680 else if (seen_thread_local
)
1682 else if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
)))
1686 else if ((sec_flags
& SEC_SMALL_DATA
) != 0
1687 && (sec_flags
& SEC_ALLOC
) != 0)
1689 /* .sdata goes after .data, .sbss after .sdata. */
1690 for (look
= first
; look
; look
= look
->next
)
1692 look_flags
= look
->flags
;
1693 if (look
->bfd_section
!= NULL
)
1695 look_flags
= look
->bfd_section
->flags
;
1696 if (match_type
&& !match_type (link_info
.output_bfd
,
1701 differ
= look_flags
^ sec_flags
;
1702 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1703 | SEC_THREAD_LOCAL
))
1704 || ((look_flags
& SEC_SMALL_DATA
)
1705 && !(sec_flags
& SEC_HAS_CONTENTS
)))
1709 else if ((sec_flags
& SEC_HAS_CONTENTS
) != 0
1710 && (sec_flags
& SEC_ALLOC
) != 0)
1712 /* .data goes after .rodata. */
1713 for (look
= first
; look
; look
= look
->next
)
1715 look_flags
= look
->flags
;
1716 if (look
->bfd_section
!= NULL
)
1718 look_flags
= look
->bfd_section
->flags
;
1719 if (match_type
&& !match_type (link_info
.output_bfd
,
1724 differ
= look_flags
^ sec_flags
;
1725 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1726 | SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1730 else if ((sec_flags
& SEC_ALLOC
) != 0)
1732 /* .bss goes after any other alloc section. */
1733 for (look
= first
; look
; look
= look
->next
)
1735 look_flags
= look
->flags
;
1736 if (look
->bfd_section
!= NULL
)
1738 look_flags
= look
->bfd_section
->flags
;
1739 if (match_type
&& !match_type (link_info
.output_bfd
,
1744 differ
= look_flags
^ sec_flags
;
1745 if (!(differ
& SEC_ALLOC
))
1751 /* non-alloc go last. */
1752 for (look
= first
; look
; look
= look
->next
)
1754 look_flags
= look
->flags
;
1755 if (look
->bfd_section
!= NULL
)
1756 look_flags
= look
->bfd_section
->flags
;
1757 differ
= look_flags
^ sec_flags
;
1758 if (!(differ
& SEC_DEBUGGING
))
1764 if (found
|| !match_type
)
1767 return lang_output_section_find_by_flags (sec
, sec_flags
, NULL
, NULL
);
1770 /* Find the last output section before given output statement.
1771 Used by place_orphan. */
1774 output_prev_sec_find (lang_output_section_statement_type
*os
)
1776 lang_output_section_statement_type
*lookup
;
1778 for (lookup
= os
->prev
; lookup
!= NULL
; lookup
= lookup
->prev
)
1780 if (lookup
->constraint
< 0)
1783 if (lookup
->bfd_section
!= NULL
&& lookup
->bfd_section
->owner
!= NULL
)
1784 return lookup
->bfd_section
;
1790 /* Look for a suitable place for a new output section statement. The
1791 idea is to skip over anything that might be inside a SECTIONS {}
1792 statement in a script, before we find another output section
1793 statement. Assignments to "dot" before an output section statement
1794 are assumed to belong to it, except in two cases; The first
1795 assignment to dot, and assignments before non-alloc sections.
1796 Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
1797 similar assignments that set the initial address, or we might
1798 insert non-alloc note sections among assignments setting end of
1801 static lang_statement_union_type
**
1802 insert_os_after (lang_output_section_statement_type
*after
)
1804 lang_statement_union_type
**where
;
1805 lang_statement_union_type
**assign
= NULL
;
1806 bfd_boolean ignore_first
;
1808 ignore_first
= after
== (void *) lang_os_list
.head
;
1810 for (where
= &after
->header
.next
;
1812 where
= &(*where
)->header
.next
)
1814 switch ((*where
)->header
.type
)
1816 case lang_assignment_statement_enum
:
1819 lang_assignment_statement_type
*ass
;
1821 ass
= &(*where
)->assignment_statement
;
1822 if (ass
->exp
->type
.node_class
!= etree_assert
1823 && ass
->exp
->assign
.dst
[0] == '.'
1824 && ass
->exp
->assign
.dst
[1] == 0)
1828 ignore_first
= FALSE
;
1832 case lang_wild_statement_enum
:
1833 case lang_input_section_enum
:
1834 case lang_object_symbols_statement_enum
:
1835 case lang_fill_statement_enum
:
1836 case lang_data_statement_enum
:
1837 case lang_reloc_statement_enum
:
1838 case lang_padding_statement_enum
:
1839 case lang_constructors_statement_enum
:
1841 ignore_first
= FALSE
;
1843 case lang_output_section_statement_enum
:
1846 asection
*s
= (*where
)->output_section_statement
.bfd_section
;
1849 || s
->map_head
.s
== NULL
1850 || (s
->flags
& SEC_ALLOC
) != 0)
1854 case lang_input_statement_enum
:
1855 case lang_address_statement_enum
:
1856 case lang_target_statement_enum
:
1857 case lang_output_statement_enum
:
1858 case lang_group_statement_enum
:
1859 case lang_insert_statement_enum
:
1868 lang_output_section_statement_type
*
1869 lang_insert_orphan (asection
*s
,
1870 const char *secname
,
1872 lang_output_section_statement_type
*after
,
1873 struct orphan_save
*place
,
1874 etree_type
*address
,
1875 lang_statement_list_type
*add_child
)
1877 lang_statement_list_type add
;
1878 lang_output_section_statement_type
*os
;
1879 lang_output_section_statement_type
**os_tail
;
1881 /* If we have found an appropriate place for the output section
1882 statements for this orphan, add them to our own private list,
1883 inserting them later into the global statement list. */
1886 lang_list_init (&add
);
1887 push_stat_ptr (&add
);
1890 if (bfd_link_relocatable (&link_info
)
1891 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
1892 address
= exp_intop (0);
1894 os_tail
= (lang_output_section_statement_type
**) lang_os_list
.tail
;
1895 os
= lang_enter_output_section_statement (secname
, address
, normal_section
,
1896 NULL
, NULL
, NULL
, constraint
, 0);
1898 if (add_child
== NULL
)
1899 add_child
= &os
->children
;
1900 lang_add_section (add_child
, s
, NULL
, NULL
, os
);
1902 if (after
&& (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) != 0)
1904 const char *region
= (after
->region
1905 ? after
->region
->name_list
.name
1906 : DEFAULT_MEMORY_REGION
);
1907 const char *lma_region
= (after
->lma_region
1908 ? after
->lma_region
->name_list
.name
1910 lang_leave_output_section_statement (NULL
, region
, after
->phdrs
,
1914 lang_leave_output_section_statement (NULL
, DEFAULT_MEMORY_REGION
, NULL
,
1917 /* Restore the global list pointer. */
1921 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
1923 asection
*snew
, *as
;
1924 bfd_boolean place_after
= place
->stmt
== NULL
;
1925 bfd_boolean insert_after
= TRUE
;
1927 snew
= os
->bfd_section
;
1929 /* Shuffle the bfd section list to make the output file look
1930 neater. This is really only cosmetic. */
1931 if (place
->section
== NULL
1932 && after
!= (void *) lang_os_list
.head
)
1934 asection
*bfd_section
= after
->bfd_section
;
1936 /* If the output statement hasn't been used to place any input
1937 sections (and thus doesn't have an output bfd_section),
1938 look for the closest prior output statement having an
1940 if (bfd_section
== NULL
)
1941 bfd_section
= output_prev_sec_find (after
);
1943 if (bfd_section
!= NULL
&& bfd_section
!= snew
)
1944 place
->section
= &bfd_section
->next
;
1947 if (place
->section
== NULL
)
1948 place
->section
= &link_info
.output_bfd
->sections
;
1950 as
= *place
->section
;
1954 /* Put the section at the end of the list. */
1956 /* Unlink the section. */
1957 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1959 /* Now tack it back on in the right place. */
1960 bfd_section_list_append (link_info
.output_bfd
, snew
);
1962 else if ((bfd_get_flavour (link_info
.output_bfd
)
1963 == bfd_target_elf_flavour
)
1964 && (bfd_get_flavour (s
->owner
)
1965 == bfd_target_elf_flavour
)
1966 && ((elf_section_type (s
) == SHT_NOTE
1967 && (s
->flags
& SEC_LOAD
) != 0)
1968 || (elf_section_type (as
) == SHT_NOTE
1969 && (as
->flags
& SEC_LOAD
) != 0)))
1971 /* Make sure that output note sections are grouped and sorted
1972 by alignments when inserting a note section or insert a
1973 section after a note section, */
1975 /* A specific section after which the output note section
1976 should be placed. */
1977 asection
*after_sec
;
1978 /* True if we need to insert the orphan section after a
1979 specific section to maintain output note section order. */
1980 bfd_boolean after_sec_note
= FALSE
;
1982 static asection
*first_orphan_note
= NULL
;
1984 /* Group and sort output note section by alignments in
1987 if (elf_section_type (s
) == SHT_NOTE
1988 && (s
->flags
& SEC_LOAD
) != 0)
1990 /* Search from the beginning for the last output note
1991 section with equal or larger alignments. NB: Don't
1992 place orphan note section after non-note sections. */
1994 first_orphan_note
= NULL
;
1995 for (sec
= link_info
.output_bfd
->sections
;
1997 && !bfd_is_abs_section (sec
));
2000 && elf_section_type (sec
) == SHT_NOTE
2001 && (sec
->flags
& SEC_LOAD
) != 0)
2003 if (!first_orphan_note
)
2004 first_orphan_note
= sec
;
2005 if (sec
->alignment_power
>= s
->alignment_power
)
2008 else if (first_orphan_note
)
2010 /* Stop if there is non-note section after the first
2011 orphan note section. */
2015 /* If this will be the first orphan note section, it can
2016 be placed at the default location. */
2017 after_sec_note
= first_orphan_note
!= NULL
;
2018 if (after_sec
== NULL
&& after_sec_note
)
2020 /* If all output note sections have smaller
2021 alignments, place the section before all
2022 output orphan note sections. */
2023 after_sec
= first_orphan_note
;
2024 insert_after
= FALSE
;
2027 else if (first_orphan_note
)
2029 /* Don't place non-note sections in the middle of orphan
2031 after_sec_note
= TRUE
;
2033 for (sec
= as
->next
;
2035 && !bfd_is_abs_section (sec
));
2037 if (elf_section_type (sec
) == SHT_NOTE
2038 && (sec
->flags
& SEC_LOAD
) != 0)
2046 /* Search forward to insert OS after AFTER_SEC output
2048 lang_output_section_statement_type
*stmt
, *next
;
2049 bfd_boolean found
= FALSE
;
2050 for (stmt
= after
; stmt
!= NULL
; stmt
= next
)
2055 if (stmt
->bfd_section
== after_sec
)
2065 /* If INSERT_AFTER is FALSE, place OS before
2066 AFTER_SEC output statement. */
2067 if (next
&& next
->bfd_section
== after_sec
)
2077 /* Search backward to insert OS after AFTER_SEC output
2080 for (stmt
= after
; stmt
!= NULL
; stmt
= stmt
->prev
)
2084 if (stmt
->bfd_section
== after_sec
)
2093 /* If INSERT_AFTER is FALSE, place OS before
2094 AFTER_SEC output statement. */
2095 if (stmt
->next
->bfd_section
== after_sec
)
2105 if (after_sec
== NULL
2106 || (insert_after
&& after_sec
->next
!= snew
)
2107 || (!insert_after
&& after_sec
->prev
!= snew
))
2109 /* Unlink the section. */
2110 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2112 /* Place SNEW after AFTER_SEC. If AFTER_SEC is NULL,
2117 bfd_section_list_insert_after (link_info
.output_bfd
,
2120 bfd_section_list_insert_before (link_info
.output_bfd
,
2124 bfd_section_list_prepend (link_info
.output_bfd
, snew
);
2127 else if (as
!= snew
&& as
->prev
!= snew
)
2129 /* Unlink the section. */
2130 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2132 /* Now tack it back on in the right place. */
2133 bfd_section_list_insert_before (link_info
.output_bfd
,
2137 else if (as
!= snew
&& as
->prev
!= snew
)
2139 /* Unlink the section. */
2140 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2142 /* Now tack it back on in the right place. */
2143 bfd_section_list_insert_before (link_info
.output_bfd
, as
, snew
);
2146 /* Save the end of this list. Further ophans of this type will
2147 follow the one we've just added. */
2148 place
->section
= &snew
->next
;
2150 /* The following is non-cosmetic. We try to put the output
2151 statements in some sort of reasonable order here, because they
2152 determine the final load addresses of the orphan sections.
2153 In addition, placing output statements in the wrong order may
2154 require extra segments. For instance, given a typical
2155 situation of all read-only sections placed in one segment and
2156 following that a segment containing all the read-write
2157 sections, we wouldn't want to place an orphan read/write
2158 section before or amongst the read-only ones. */
2159 if (add
.head
!= NULL
)
2161 lang_output_section_statement_type
*newly_added_os
;
2163 /* Place OS after AFTER if AFTER_NOTE is TRUE. */
2166 lang_statement_union_type
**where
= insert_os_after (after
);
2171 place
->os_tail
= &after
->next
;
2175 /* Put it after the last orphan statement we added. */
2176 *add
.tail
= *place
->stmt
;
2177 *place
->stmt
= add
.head
;
2180 /* Fix the global list pointer if we happened to tack our
2181 new list at the tail. */
2182 if (*stat_ptr
->tail
== add
.head
)
2183 stat_ptr
->tail
= add
.tail
;
2185 /* Save the end of this list. */
2186 place
->stmt
= add
.tail
;
2188 /* Do the same for the list of output section statements. */
2189 newly_added_os
= *os_tail
;
2191 newly_added_os
->prev
= (lang_output_section_statement_type
*)
2192 ((char *) place
->os_tail
2193 - offsetof (lang_output_section_statement_type
, next
));
2194 newly_added_os
->next
= *place
->os_tail
;
2195 if (newly_added_os
->next
!= NULL
)
2196 newly_added_os
->next
->prev
= newly_added_os
;
2197 *place
->os_tail
= newly_added_os
;
2198 place
->os_tail
= &newly_added_os
->next
;
2200 /* Fixing the global list pointer here is a little different.
2201 We added to the list in lang_enter_output_section_statement,
2202 trimmed off the new output_section_statment above when
2203 assigning *os_tail = NULL, but possibly added it back in
2204 the same place when assigning *place->os_tail. */
2205 if (*os_tail
== NULL
)
2206 lang_os_list
.tail
= (lang_statement_union_type
**) os_tail
;
2213 lang_print_asneeded (void)
2215 struct asneeded_minfo
*m
;
2217 if (asneeded_list_head
== NULL
)
2220 minfo (_("\nAs-needed library included to satisfy reference by file (symbol)\n\n"));
2222 for (m
= asneeded_list_head
; m
!= NULL
; m
= m
->next
)
2226 minfo ("%s", m
->soname
);
2227 len
= strlen (m
->soname
);
2241 minfo ("%pB ", m
->ref
);
2242 minfo ("(%pT)\n", m
->name
);
2247 lang_map_flags (flagword flag
)
2249 if (flag
& SEC_ALLOC
)
2252 if (flag
& SEC_CODE
)
2255 if (flag
& SEC_READONLY
)
2258 if (flag
& SEC_DATA
)
2261 if (flag
& SEC_LOAD
)
2268 lang_memory_region_type
*m
;
2269 bfd_boolean dis_header_printed
= FALSE
;
2271 LANG_FOR_EACH_INPUT_STATEMENT (file
)
2275 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
2276 || file
->flags
.just_syms
)
2279 if (config
.print_map_discarded
)
2280 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2281 if ((s
->output_section
== NULL
2282 || s
->output_section
->owner
!= link_info
.output_bfd
)
2283 && (s
->flags
& (SEC_LINKER_CREATED
| SEC_KEEP
)) == 0)
2285 if (! dis_header_printed
)
2287 fprintf (config
.map_file
, _("\nDiscarded input sections\n\n"));
2288 dis_header_printed
= TRUE
;
2291 print_input_section (s
, TRUE
);
2295 minfo (_("\nMemory Configuration\n\n"));
2296 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
2297 _("Name"), _("Origin"), _("Length"), _("Attributes"));
2299 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
2304 fprintf (config
.map_file
, "%-16s ", m
->name_list
.name
);
2306 sprintf_vma (buf
, m
->origin
);
2307 minfo ("0x%s ", buf
);
2315 minfo ("0x%V", m
->length
);
2316 if (m
->flags
|| m
->not_flags
)
2324 lang_map_flags (m
->flags
);
2330 lang_map_flags (m
->not_flags
);
2337 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
2339 if (!link_info
.reduce_memory_overheads
)
2341 obstack_begin (&map_obstack
, 1000);
2342 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
2344 expld
.phase
= lang_fixed_phase_enum
;
2345 lang_statement_iteration
++;
2346 print_statements ();
2348 ldemul_extra_map_file_text (link_info
.output_bfd
, &link_info
,
2353 sort_def_symbol (struct bfd_link_hash_entry
*hash_entry
,
2354 void *info ATTRIBUTE_UNUSED
)
2356 if ((hash_entry
->type
== bfd_link_hash_defined
2357 || hash_entry
->type
== bfd_link_hash_defweak
)
2358 && hash_entry
->u
.def
.section
->owner
!= link_info
.output_bfd
2359 && hash_entry
->u
.def
.section
->owner
!= NULL
)
2361 input_section_userdata_type
*ud
;
2362 struct map_symbol_def
*def
;
2364 ud
= bfd_section_userdata (hash_entry
->u
.def
.section
);
2367 ud
= stat_alloc (sizeof (*ud
));
2368 bfd_set_section_userdata (hash_entry
->u
.def
.section
, ud
);
2369 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2370 ud
->map_symbol_def_count
= 0;
2372 else if (!ud
->map_symbol_def_tail
)
2373 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2375 def
= (struct map_symbol_def
*) obstack_alloc (&map_obstack
, sizeof *def
);
2376 def
->entry
= hash_entry
;
2377 *(ud
->map_symbol_def_tail
) = def
;
2378 ud
->map_symbol_def_tail
= &def
->next
;
2379 ud
->map_symbol_def_count
++;
2384 /* Initialize an output section. */
2387 init_os (lang_output_section_statement_type
*s
, flagword flags
)
2389 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
2390 einfo (_("%F%P: illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
2393 s
->bfd_section
= bfd_get_section_by_name (link_info
.output_bfd
, s
->name
);
2394 if (s
->bfd_section
== NULL
)
2395 s
->bfd_section
= bfd_make_section_anyway_with_flags (link_info
.output_bfd
,
2397 if (s
->bfd_section
== NULL
)
2399 einfo (_("%F%P: output format %s cannot represent section"
2400 " called %s: %E\n"),
2401 link_info
.output_bfd
->xvec
->name
, s
->name
);
2403 s
->bfd_section
->output_section
= s
->bfd_section
;
2404 s
->bfd_section
->output_offset
= 0;
2406 /* Set the userdata of the output section to the output section
2407 statement to avoid lookup. */
2408 bfd_set_section_userdata (s
->bfd_section
, s
);
2410 /* If there is a base address, make sure that any sections it might
2411 mention are initialized. */
2412 if (s
->addr_tree
!= NULL
)
2413 exp_init_os (s
->addr_tree
);
2415 if (s
->load_base
!= NULL
)
2416 exp_init_os (s
->load_base
);
2418 /* If supplied an alignment, set it. */
2419 if (s
->section_alignment
!= NULL
)
2420 s
->bfd_section
->alignment_power
= exp_get_power (s
->section_alignment
,
2421 "section alignment");
2424 /* Make sure that all output sections mentioned in an expression are
2428 exp_init_os (etree_type
*exp
)
2430 switch (exp
->type
.node_class
)
2434 case etree_provided
:
2435 exp_init_os (exp
->assign
.src
);
2439 exp_init_os (exp
->binary
.lhs
);
2440 exp_init_os (exp
->binary
.rhs
);
2444 exp_init_os (exp
->trinary
.cond
);
2445 exp_init_os (exp
->trinary
.lhs
);
2446 exp_init_os (exp
->trinary
.rhs
);
2450 exp_init_os (exp
->assert_s
.child
);
2454 exp_init_os (exp
->unary
.child
);
2458 switch (exp
->type
.node_code
)
2464 lang_output_section_statement_type
*os
;
2466 os
= lang_output_section_find (exp
->name
.name
);
2467 if (os
!= NULL
&& os
->bfd_section
== NULL
)
2479 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
2481 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
2483 /* If we are only reading symbols from this object, then we want to
2484 discard all sections. */
2485 if (entry
->flags
.just_syms
)
2487 bfd_link_just_syms (abfd
, sec
, &link_info
);
2491 /* Deal with SHF_EXCLUDE ELF sections. */
2492 if (!bfd_link_relocatable (&link_info
)
2493 && (abfd
->flags
& BFD_PLUGIN
) == 0
2494 && (sec
->flags
& (SEC_GROUP
| SEC_KEEP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
2495 sec
->output_section
= bfd_abs_section_ptr
;
2497 if (!(abfd
->flags
& DYNAMIC
))
2498 bfd_section_already_linked (abfd
, sec
, &link_info
);
2502 /* Returns true if SECTION is one we know will be discarded based on its
2503 section flags, otherwise returns false. */
2506 lang_discard_section_p (asection
*section
)
2508 bfd_boolean discard
;
2509 flagword flags
= section
->flags
;
2511 /* Discard sections marked with SEC_EXCLUDE. */
2512 discard
= (flags
& SEC_EXCLUDE
) != 0;
2514 /* Discard the group descriptor sections when we're finally placing the
2515 sections from within the group. */
2516 if ((flags
& SEC_GROUP
) != 0
2517 && link_info
.resolve_section_groups
)
2520 /* Discard debugging sections if we are stripping debugging
2522 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
2523 && (flags
& SEC_DEBUGGING
) != 0)
2529 /* The wild routines.
2531 These expand statements like *(.text) and foo.o to a list of
2532 explicit actions, like foo.o(.text), bar.o(.text) and
2533 foo.o(.text, .data). */
2535 /* Add SECTION to the output section OUTPUT. Do this by creating a
2536 lang_input_section statement which is placed at PTR. */
2539 lang_add_section (lang_statement_list_type
*ptr
,
2541 struct wildcard_list
*pattern
,
2542 struct flag_info
*sflag_info
,
2543 lang_output_section_statement_type
*output
)
2545 flagword flags
= section
->flags
;
2547 bfd_boolean discard
;
2548 lang_input_section_type
*new_section
;
2549 bfd
*abfd
= link_info
.output_bfd
;
2551 /* Is this section one we know should be discarded? */
2552 discard
= lang_discard_section_p (section
);
2554 /* Discard input sections which are assigned to a section named
2555 DISCARD_SECTION_NAME. */
2556 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
2561 if (section
->output_section
== NULL
)
2563 /* This prevents future calls from assigning this section. */
2564 section
->output_section
= bfd_abs_section_ptr
;
2566 else if (link_info
.non_contiguous_regions_warnings
)
2567 einfo (_("%P:%pS: warning: --enable-non-contiguous-regions makes "
2568 "section `%pA' from '%pB' match /DISCARD/ clause.\n"),
2569 NULL
, section
, section
->owner
);
2578 keep
= bfd_lookup_section_flags (&link_info
, sflag_info
, section
);
2583 if (section
->output_section
!= NULL
)
2585 if (!link_info
.non_contiguous_regions
)
2588 /* SECTION has already been handled in a special way
2589 (eg. LINK_ONCE): skip it. */
2590 if (bfd_is_abs_section (section
->output_section
))
2593 /* Already assigned to the same output section, do not process
2594 it again, to avoid creating loops between duplicate sections
2596 if (section
->output_section
== output
->bfd_section
)
2599 if (link_info
.non_contiguous_regions_warnings
&& output
->bfd_section
)
2600 einfo (_("%P:%pS: warning: --enable-non-contiguous-regions may "
2601 "change behaviour for section `%pA' from '%pB' (assigned to "
2602 "%pA, but additional match: %pA)\n"),
2603 NULL
, section
, section
->owner
, section
->output_section
,
2604 output
->bfd_section
);
2606 /* SECTION has already been assigned to an output section, but
2607 the user allows it to be mapped to another one in case it
2608 overflows. We'll later update the actual output section in
2609 size_input_section as appropriate. */
2612 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2613 to an output section, because we want to be able to include a
2614 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2615 section (I don't know why we want to do this, but we do).
2616 build_link_order in ldwrite.c handles this case by turning
2617 the embedded SEC_NEVER_LOAD section into a fill. */
2618 flags
&= ~ SEC_NEVER_LOAD
;
2620 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2621 already been processed. One reason to do this is that on pe
2622 format targets, .text$foo sections go into .text and it's odd
2623 to see .text with SEC_LINK_ONCE set. */
2624 if ((flags
& (SEC_LINK_ONCE
| SEC_GROUP
)) == (SEC_LINK_ONCE
| SEC_GROUP
))
2626 if (link_info
.resolve_section_groups
)
2627 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2629 flags
&= ~(SEC_LINK_DUPLICATES
| SEC_RELOC
);
2631 else if (!bfd_link_relocatable (&link_info
))
2632 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2634 switch (output
->sectype
)
2636 case normal_section
:
2637 case overlay_section
:
2638 case first_overlay_section
:
2640 case noalloc_section
:
2641 flags
&= ~SEC_ALLOC
;
2643 case noload_section
:
2645 flags
|= SEC_NEVER_LOAD
;
2646 /* Unfortunately GNU ld has managed to evolve two different
2647 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2648 alloc, no contents section. All others get a noload, noalloc
2650 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
2651 flags
&= ~SEC_HAS_CONTENTS
;
2653 flags
&= ~SEC_ALLOC
;
2657 if (output
->bfd_section
== NULL
)
2658 init_os (output
, flags
);
2660 /* If SEC_READONLY is not set in the input section, then clear
2661 it from the output section. */
2662 output
->bfd_section
->flags
&= flags
| ~SEC_READONLY
;
2664 if (output
->bfd_section
->linker_has_input
)
2666 /* Only set SEC_READONLY flag on the first input section. */
2667 flags
&= ~ SEC_READONLY
;
2669 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2670 if ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2671 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2672 || ((flags
& SEC_MERGE
) != 0
2673 && output
->bfd_section
->entsize
!= section
->entsize
))
2675 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2676 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2679 output
->bfd_section
->flags
|= flags
;
2681 if (!output
->bfd_section
->linker_has_input
)
2683 output
->bfd_section
->linker_has_input
= 1;
2684 /* This must happen after flags have been updated. The output
2685 section may have been created before we saw its first input
2686 section, eg. for a data statement. */
2687 bfd_init_private_section_data (section
->owner
, section
,
2688 link_info
.output_bfd
,
2689 output
->bfd_section
,
2691 if ((flags
& SEC_MERGE
) != 0)
2692 output
->bfd_section
->entsize
= section
->entsize
;
2695 if ((flags
& SEC_TIC54X_BLOCK
) != 0
2696 && bfd_get_arch (section
->owner
) == bfd_arch_tic54x
)
2698 /* FIXME: This value should really be obtained from the bfd... */
2699 output
->block_value
= 128;
2702 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2703 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2705 section
->output_section
= output
->bfd_section
;
2707 if (!map_head_is_link_order
)
2709 asection
*s
= output
->bfd_section
->map_tail
.s
;
2710 output
->bfd_section
->map_tail
.s
= section
;
2711 section
->map_head
.s
= NULL
;
2712 section
->map_tail
.s
= s
;
2714 s
->map_head
.s
= section
;
2716 output
->bfd_section
->map_head
.s
= section
;
2719 /* Add a section reference to the list. */
2720 new_section
= new_stat (lang_input_section
, ptr
);
2721 new_section
->section
= section
;
2722 new_section
->pattern
= pattern
;
2725 /* Handle wildcard sorting. This returns the lang_input_section which
2726 should follow the one we are going to create for SECTION and FILE,
2727 based on the sorting requirements of WILD. It returns NULL if the
2728 new section should just go at the end of the current list. */
2730 static lang_statement_union_type
*
2731 wild_sort (lang_wild_statement_type
*wild
,
2732 struct wildcard_list
*sec
,
2733 lang_input_statement_type
*file
,
2736 lang_statement_union_type
*l
;
2738 if (!wild
->filenames_sorted
2739 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
2742 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
2744 lang_input_section_type
*ls
;
2746 if (l
->header
.type
!= lang_input_section_enum
)
2748 ls
= &l
->input_section
;
2750 /* Sorting by filename takes precedence over sorting by section
2753 if (wild
->filenames_sorted
)
2755 const char *fn
, *ln
;
2759 /* The PE support for the .idata section as generated by
2760 dlltool assumes that files will be sorted by the name of
2761 the archive and then the name of the file within the
2764 if (file
->the_bfd
!= NULL
2765 && file
->the_bfd
->my_archive
!= NULL
)
2767 fn
= bfd_get_filename (file
->the_bfd
->my_archive
);
2772 fn
= file
->filename
;
2776 if (ls
->section
->owner
->my_archive
!= NULL
)
2778 ln
= bfd_get_filename (ls
->section
->owner
->my_archive
);
2783 ln
= bfd_get_filename (ls
->section
->owner
);
2787 i
= filename_cmp (fn
, ln
);
2796 fn
= file
->filename
;
2798 ln
= bfd_get_filename (ls
->section
->owner
);
2800 i
= filename_cmp (fn
, ln
);
2808 /* Here either the files are not sorted by name, or we are
2809 looking at the sections for this file. */
2812 && sec
->spec
.sorted
!= none
2813 && sec
->spec
.sorted
!= by_none
)
2814 if (compare_section (sec
->spec
.sorted
, section
, ls
->section
) < 0)
2821 /* Expand a wild statement for a particular FILE. SECTION may be
2822 NULL, in which case it is a wild card. */
2825 output_section_callback (lang_wild_statement_type
*ptr
,
2826 struct wildcard_list
*sec
,
2828 lang_input_statement_type
*file
,
2831 lang_statement_union_type
*before
;
2832 lang_output_section_statement_type
*os
;
2834 os
= (lang_output_section_statement_type
*) output
;
2836 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2837 if (unique_section_p (section
, os
))
2840 before
= wild_sort (ptr
, sec
, file
, section
);
2842 /* Here BEFORE points to the lang_input_section which
2843 should follow the one we are about to add. If BEFORE
2844 is NULL, then the section should just go at the end
2845 of the current list. */
2848 lang_add_section (&ptr
->children
, section
, ptr
->section_list
,
2849 ptr
->section_flag_list
, os
);
2852 lang_statement_list_type list
;
2853 lang_statement_union_type
**pp
;
2855 lang_list_init (&list
);
2856 lang_add_section (&list
, section
, ptr
->section_list
,
2857 ptr
->section_flag_list
, os
);
2859 /* If we are discarding the section, LIST.HEAD will
2861 if (list
.head
!= NULL
)
2863 ASSERT (list
.head
->header
.next
== NULL
);
2865 for (pp
= &ptr
->children
.head
;
2867 pp
= &(*pp
)->header
.next
)
2868 ASSERT (*pp
!= NULL
);
2870 list
.head
->header
.next
= *pp
;
2876 /* Check if all sections in a wild statement for a particular FILE
2880 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2881 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2883 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2886 lang_output_section_statement_type
*os
;
2888 os
= (lang_output_section_statement_type
*) output
;
2890 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2891 if (unique_section_p (section
, os
))
2894 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2895 os
->all_input_readonly
= FALSE
;
2898 /* This is passed a file name which must have been seen already and
2899 added to the statement tree. We will see if it has been opened
2900 already and had its symbols read. If not then we'll read it. */
2902 static lang_input_statement_type
*
2903 lookup_name (const char *name
)
2905 lang_input_statement_type
*search
;
2907 for (search
= (void *) input_file_chain
.head
;
2909 search
= search
->next_real_file
)
2911 /* Use the local_sym_name as the name of the file that has
2912 already been loaded as filename might have been transformed
2913 via the search directory lookup mechanism. */
2914 const char *filename
= search
->local_sym_name
;
2916 if (filename
!= NULL
2917 && filename_cmp (filename
, name
) == 0)
2923 /* Arrange to splice the input statement added by new_afile into
2924 statement_list after the current input_file_chain tail.
2925 We know input_file_chain is not an empty list, and that
2926 lookup_name was called via open_input_bfds. Later calls to
2927 lookup_name should always match an existing input_statement. */
2928 lang_statement_union_type
**tail
= stat_ptr
->tail
;
2929 lang_statement_union_type
**after
2930 = (void *) ((char *) input_file_chain
.tail
2931 - offsetof (lang_input_statement_type
, next_real_file
)
2932 + offsetof (lang_input_statement_type
, header
.next
));
2933 lang_statement_union_type
*rest
= *after
;
2934 stat_ptr
->tail
= after
;
2935 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2936 default_target
, NULL
);
2937 *stat_ptr
->tail
= rest
;
2939 stat_ptr
->tail
= tail
;
2942 /* If we have already added this file, or this file is not real
2943 don't add this file. */
2944 if (search
->flags
.loaded
|| !search
->flags
.real
)
2947 if (!load_symbols (search
, NULL
))
2953 /* Save LIST as a list of libraries whose symbols should not be exported. */
2958 struct excluded_lib
*next
;
2960 static struct excluded_lib
*excluded_libs
;
2963 add_excluded_libs (const char *list
)
2965 const char *p
= list
, *end
;
2969 struct excluded_lib
*entry
;
2970 end
= strpbrk (p
, ",:");
2972 end
= p
+ strlen (p
);
2973 entry
= (struct excluded_lib
*) xmalloc (sizeof (*entry
));
2974 entry
->next
= excluded_libs
;
2975 entry
->name
= (char *) xmalloc (end
- p
+ 1);
2976 memcpy (entry
->name
, p
, end
- p
);
2977 entry
->name
[end
- p
] = '\0';
2978 excluded_libs
= entry
;
2986 check_excluded_libs (bfd
*abfd
)
2988 struct excluded_lib
*lib
= excluded_libs
;
2992 int len
= strlen (lib
->name
);
2993 const char *filename
= lbasename (bfd_get_filename (abfd
));
2995 if (strcmp (lib
->name
, "ALL") == 0)
2997 abfd
->no_export
= TRUE
;
3001 if (filename_ncmp (lib
->name
, filename
, len
) == 0
3002 && (filename
[len
] == '\0'
3003 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
3004 && filename
[len
+ 2] == '\0')))
3006 abfd
->no_export
= TRUE
;
3014 /* Get the symbols for an input file. */
3017 load_symbols (lang_input_statement_type
*entry
,
3018 lang_statement_list_type
*place
)
3022 if (entry
->flags
.loaded
)
3025 ldfile_open_file (entry
);
3027 /* Do not process further if the file was missing. */
3028 if (entry
->flags
.missing_file
)
3031 if (trace_files
|| verbose
)
3032 info_msg ("%pI\n", entry
);
3034 if (!bfd_check_format (entry
->the_bfd
, bfd_archive
)
3035 && !bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
3038 struct lang_input_statement_flags save_flags
;
3041 err
= bfd_get_error ();
3043 /* See if the emulation has some special knowledge. */
3044 if (ldemul_unrecognized_file (entry
))
3047 if (err
== bfd_error_file_ambiguously_recognized
)
3051 einfo (_("%P: %pB: file not recognized: %E;"
3052 " matching formats:"), entry
->the_bfd
);
3053 for (p
= matching
; *p
!= NULL
; p
++)
3057 else if (err
!= bfd_error_file_not_recognized
3059 einfo (_("%F%P: %pB: file not recognized: %E\n"), entry
->the_bfd
);
3061 bfd_close (entry
->the_bfd
);
3062 entry
->the_bfd
= NULL
;
3064 /* Try to interpret the file as a linker script. */
3065 save_flags
= input_flags
;
3066 ldfile_open_command_file (entry
->filename
);
3068 push_stat_ptr (place
);
3069 input_flags
.add_DT_NEEDED_for_regular
3070 = entry
->flags
.add_DT_NEEDED_for_regular
;
3071 input_flags
.add_DT_NEEDED_for_dynamic
3072 = entry
->flags
.add_DT_NEEDED_for_dynamic
;
3073 input_flags
.whole_archive
= entry
->flags
.whole_archive
;
3074 input_flags
.dynamic
= entry
->flags
.dynamic
;
3076 ldfile_assumed_script
= TRUE
;
3077 parser_input
= input_script
;
3078 current_input_file
= entry
->filename
;
3080 current_input_file
= NULL
;
3081 ldfile_assumed_script
= FALSE
;
3083 /* missing_file is sticky. sysrooted will already have been
3084 restored when seeing EOF in yyparse, but no harm to restore
3086 save_flags
.missing_file
|= input_flags
.missing_file
;
3087 input_flags
= save_flags
;
3091 entry
->flags
.loaded
= TRUE
;
3096 if (ldemul_recognized_file (entry
))
3099 /* We don't call ldlang_add_file for an archive. Instead, the
3100 add_symbols entry point will call ldlang_add_file, via the
3101 add_archive_element callback, for each element of the archive
3103 switch (bfd_get_format (entry
->the_bfd
))
3109 if (!entry
->flags
.reload
)
3110 ldlang_add_file (entry
);
3114 check_excluded_libs (entry
->the_bfd
);
3116 bfd_set_usrdata (entry
->the_bfd
, entry
);
3117 if (entry
->flags
.whole_archive
)
3120 bfd_boolean loaded
= TRUE
;
3125 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
3130 if (!bfd_check_format (member
, bfd_object
))
3132 einfo (_("%F%P: %pB: member %pB in archive is not an object\n"),
3133 entry
->the_bfd
, member
);
3138 if (!(*link_info
.callbacks
3139 ->add_archive_element
) (&link_info
, member
,
3140 "--whole-archive", &subsbfd
))
3143 /* Potentially, the add_archive_element hook may have set a
3144 substitute BFD for us. */
3145 if (!bfd_link_add_symbols (subsbfd
, &link_info
))
3147 einfo (_("%F%P: %pB: error adding symbols: %E\n"), member
);
3152 entry
->flags
.loaded
= loaded
;
3158 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
3159 entry
->flags
.loaded
= TRUE
;
3161 einfo (_("%F%P: %pB: error adding symbols: %E\n"), entry
->the_bfd
);
3163 return entry
->flags
.loaded
;
3166 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
3167 may be NULL, indicating that it is a wildcard. Separate
3168 lang_input_section statements are created for each part of the
3169 expansion; they are added after the wild statement S. OUTPUT is
3170 the output section. */
3173 wild (lang_wild_statement_type
*s
,
3174 const char *target ATTRIBUTE_UNUSED
,
3175 lang_output_section_statement_type
*output
)
3177 struct wildcard_list
*sec
;
3179 if (s
->handler_data
[0]
3180 && s
->handler_data
[0]->spec
.sorted
== by_name
3181 && !s
->filenames_sorted
)
3183 lang_section_bst_type
*tree
;
3185 walk_wild (s
, output_section_callback_fast
, output
);
3190 output_section_callback_tree_to_list (s
, tree
, output
);
3195 walk_wild (s
, output_section_callback
, output
);
3197 if (default_common_section
== NULL
)
3198 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
3199 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
3201 /* Remember the section that common is going to in case we
3202 later get something which doesn't know where to put it. */
3203 default_common_section
= output
;
3208 /* Return TRUE iff target is the sought target. */
3211 get_target (const bfd_target
*target
, void *data
)
3213 const char *sought
= (const char *) data
;
3215 return strcmp (target
->name
, sought
) == 0;
3218 /* Like strcpy() but convert to lower case as well. */
3221 stricpy (char *dest
, const char *src
)
3225 while ((c
= *src
++) != 0)
3226 *dest
++ = TOLOWER (c
);
3231 /* Remove the first occurrence of needle (if any) in haystack
3235 strcut (char *haystack
, const char *needle
)
3237 haystack
= strstr (haystack
, needle
);
3243 for (src
= haystack
+ strlen (needle
); *src
;)
3244 *haystack
++ = *src
++;
3250 /* Compare two target format name strings.
3251 Return a value indicating how "similar" they are. */
3254 name_compare (const char *first
, const char *second
)
3260 copy1
= (char *) xmalloc (strlen (first
) + 1);
3261 copy2
= (char *) xmalloc (strlen (second
) + 1);
3263 /* Convert the names to lower case. */
3264 stricpy (copy1
, first
);
3265 stricpy (copy2
, second
);
3267 /* Remove size and endian strings from the name. */
3268 strcut (copy1
, "big");
3269 strcut (copy1
, "little");
3270 strcut (copy2
, "big");
3271 strcut (copy2
, "little");
3273 /* Return a value based on how many characters match,
3274 starting from the beginning. If both strings are
3275 the same then return 10 * their length. */
3276 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
3277 if (copy1
[result
] == 0)
3289 /* Set by closest_target_match() below. */
3290 static const bfd_target
*winner
;
3292 /* Scan all the valid bfd targets looking for one that has the endianness
3293 requirement that was specified on the command line, and is the nearest
3294 match to the original output target. */
3297 closest_target_match (const bfd_target
*target
, void *data
)
3299 const bfd_target
*original
= (const bfd_target
*) data
;
3301 if (command_line
.endian
== ENDIAN_BIG
3302 && target
->byteorder
!= BFD_ENDIAN_BIG
)
3305 if (command_line
.endian
== ENDIAN_LITTLE
3306 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
3309 /* Must be the same flavour. */
3310 if (target
->flavour
!= original
->flavour
)
3313 /* Ignore generic big and little endian elf vectors. */
3314 if (strcmp (target
->name
, "elf32-big") == 0
3315 || strcmp (target
->name
, "elf64-big") == 0
3316 || strcmp (target
->name
, "elf32-little") == 0
3317 || strcmp (target
->name
, "elf64-little") == 0)
3320 /* If we have not found a potential winner yet, then record this one. */
3327 /* Oh dear, we now have two potential candidates for a successful match.
3328 Compare their names and choose the better one. */
3329 if (name_compare (target
->name
, original
->name
)
3330 > name_compare (winner
->name
, original
->name
))
3333 /* Keep on searching until wqe have checked them all. */
3337 /* Return the BFD target format of the first input file. */
3340 get_first_input_target (void)
3342 const char *target
= NULL
;
3344 LANG_FOR_EACH_INPUT_STATEMENT (s
)
3346 if (s
->header
.type
== lang_input_statement_enum
3349 ldfile_open_file (s
);
3351 if (s
->the_bfd
!= NULL
3352 && bfd_check_format (s
->the_bfd
, bfd_object
))
3354 target
= bfd_get_target (s
->the_bfd
);
3366 lang_get_output_target (void)
3370 /* Has the user told us which output format to use? */
3371 if (output_target
!= NULL
)
3372 return output_target
;
3374 /* No - has the current target been set to something other than
3376 if (current_target
!= default_target
&& current_target
!= NULL
)
3377 return current_target
;
3379 /* No - can we determine the format of the first input file? */
3380 target
= get_first_input_target ();
3384 /* Failed - use the default output target. */
3385 return default_target
;
3388 /* Open the output file. */
3391 open_output (const char *name
)
3393 output_target
= lang_get_output_target ();
3395 /* Has the user requested a particular endianness on the command
3397 if (command_line
.endian
!= ENDIAN_UNSET
)
3399 /* Get the chosen target. */
3400 const bfd_target
*target
3401 = bfd_iterate_over_targets (get_target
, (void *) output_target
);
3403 /* If the target is not supported, we cannot do anything. */
3406 enum bfd_endian desired_endian
;
3408 if (command_line
.endian
== ENDIAN_BIG
)
3409 desired_endian
= BFD_ENDIAN_BIG
;
3411 desired_endian
= BFD_ENDIAN_LITTLE
;
3413 /* See if the target has the wrong endianness. This should
3414 not happen if the linker script has provided big and
3415 little endian alternatives, but some scrips don't do
3417 if (target
->byteorder
!= desired_endian
)
3419 /* If it does, then see if the target provides
3420 an alternative with the correct endianness. */
3421 if (target
->alternative_target
!= NULL
3422 && (target
->alternative_target
->byteorder
== desired_endian
))
3423 output_target
= target
->alternative_target
->name
;
3426 /* Try to find a target as similar as possible to
3427 the default target, but which has the desired
3428 endian characteristic. */
3429 bfd_iterate_over_targets (closest_target_match
,
3432 /* Oh dear - we could not find any targets that
3433 satisfy our requirements. */
3435 einfo (_("%P: warning: could not find any targets"
3436 " that match endianness requirement\n"));
3438 output_target
= winner
->name
;
3444 link_info
.output_bfd
= bfd_openw (name
, output_target
);
3446 if (link_info
.output_bfd
== NULL
)
3448 if (bfd_get_error () == bfd_error_invalid_target
)
3449 einfo (_("%F%P: target %s not found\n"), output_target
);
3451 einfo (_("%F%P: cannot open output file %s: %E\n"), name
);
3454 delete_output_file_on_failure
= TRUE
;
3456 if (!bfd_set_format (link_info
.output_bfd
, bfd_object
))
3457 einfo (_("%F%P: %s: can not make object file: %E\n"), name
);
3458 if (!bfd_set_arch_mach (link_info
.output_bfd
,
3459 ldfile_output_architecture
,
3460 ldfile_output_machine
))
3461 einfo (_("%F%P: %s: can not set architecture: %E\n"), name
);
3463 link_info
.hash
= bfd_link_hash_table_create (link_info
.output_bfd
);
3464 if (link_info
.hash
== NULL
)
3465 einfo (_("%F%P: can not create hash table: %E\n"));
3467 bfd_set_gp_size (link_info
.output_bfd
, g_switch_value
);
3471 ldlang_open_output (lang_statement_union_type
*statement
)
3473 switch (statement
->header
.type
)
3475 case lang_output_statement_enum
:
3476 ASSERT (link_info
.output_bfd
== NULL
);
3477 open_output (statement
->output_statement
.name
);
3478 ldemul_set_output_arch ();
3479 if (config
.magic_demand_paged
3480 && !bfd_link_relocatable (&link_info
))
3481 link_info
.output_bfd
->flags
|= D_PAGED
;
3483 link_info
.output_bfd
->flags
&= ~D_PAGED
;
3484 if (config
.text_read_only
)
3485 link_info
.output_bfd
->flags
|= WP_TEXT
;
3487 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
3488 if (link_info
.traditional_format
)
3489 link_info
.output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
3491 link_info
.output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
3494 case lang_target_statement_enum
:
3495 current_target
= statement
->target_statement
.target
;
3503 init_opb (asection
*s
)
3508 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
3510 && (s
->flags
& SEC_ELF_OCTETS
) != 0)
3513 x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3514 ldfile_output_machine
);
3516 while ((x
& 1) == 0)
3524 /* Open all the input files. */
3528 OPEN_BFD_NORMAL
= 0,
3532 #if BFD_SUPPORTS_PLUGINS
3533 static lang_input_statement_type
*plugin_insert
= NULL
;
3534 static struct bfd_link_hash_entry
*plugin_undefs
= NULL
;
3538 open_input_bfds (lang_statement_union_type
*s
, enum open_bfd_mode mode
)
3540 for (; s
!= NULL
; s
= s
->header
.next
)
3542 switch (s
->header
.type
)
3544 case lang_constructors_statement_enum
:
3545 open_input_bfds (constructor_list
.head
, mode
);
3547 case lang_output_section_statement_enum
:
3548 open_input_bfds (s
->output_section_statement
.children
.head
, mode
);
3550 case lang_wild_statement_enum
:
3551 /* Maybe we should load the file's symbols. */
3552 if ((mode
& OPEN_BFD_RESCAN
) == 0
3553 && s
->wild_statement
.filename
3554 && !wildcardp (s
->wild_statement
.filename
)
3555 && !archive_path (s
->wild_statement
.filename
))
3556 lookup_name (s
->wild_statement
.filename
);
3557 open_input_bfds (s
->wild_statement
.children
.head
, mode
);
3559 case lang_group_statement_enum
:
3561 struct bfd_link_hash_entry
*undefs
;
3562 #if BFD_SUPPORTS_PLUGINS
3563 lang_input_statement_type
*plugin_insert_save
;
3566 /* We must continually search the entries in the group
3567 until no new symbols are added to the list of undefined
3572 #if BFD_SUPPORTS_PLUGINS
3573 plugin_insert_save
= plugin_insert
;
3575 undefs
= link_info
.hash
->undefs_tail
;
3576 open_input_bfds (s
->group_statement
.children
.head
,
3577 mode
| OPEN_BFD_FORCE
);
3579 while (undefs
!= link_info
.hash
->undefs_tail
3580 #if BFD_SUPPORTS_PLUGINS
3581 /* Objects inserted by a plugin, which are loaded
3582 before we hit this loop, may have added new
3584 || (plugin_insert
!= plugin_insert_save
&& plugin_undefs
)
3589 case lang_target_statement_enum
:
3590 current_target
= s
->target_statement
.target
;
3592 case lang_input_statement_enum
:
3593 if (s
->input_statement
.flags
.real
)
3595 lang_statement_union_type
**os_tail
;
3596 lang_statement_list_type add
;
3599 s
->input_statement
.target
= current_target
;
3601 /* If we are being called from within a group, and this
3602 is an archive which has already been searched, then
3603 force it to be researched unless the whole archive
3604 has been loaded already. Do the same for a rescan.
3605 Likewise reload --as-needed shared libs. */
3606 if (mode
!= OPEN_BFD_NORMAL
3607 #if BFD_SUPPORTS_PLUGINS
3608 && ((mode
& OPEN_BFD_RESCAN
) == 0
3609 || plugin_insert
== NULL
)
3611 && s
->input_statement
.flags
.loaded
3612 && (abfd
= s
->input_statement
.the_bfd
) != NULL
3613 && ((bfd_get_format (abfd
) == bfd_archive
3614 && !s
->input_statement
.flags
.whole_archive
)
3615 || (bfd_get_format (abfd
) == bfd_object
3616 && ((abfd
->flags
) & DYNAMIC
) != 0
3617 && s
->input_statement
.flags
.add_DT_NEEDED_for_regular
3618 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3619 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)))
3621 s
->input_statement
.flags
.loaded
= FALSE
;
3622 s
->input_statement
.flags
.reload
= TRUE
;
3625 os_tail
= lang_os_list
.tail
;
3626 lang_list_init (&add
);
3628 if (!load_symbols (&s
->input_statement
, &add
))
3629 config
.make_executable
= FALSE
;
3631 if (add
.head
!= NULL
)
3633 /* If this was a script with output sections then
3634 tack any added statements on to the end of the
3635 list. This avoids having to reorder the output
3636 section statement list. Very likely the user
3637 forgot -T, and whatever we do here will not meet
3638 naive user expectations. */
3639 if (os_tail
!= lang_os_list
.tail
)
3641 einfo (_("%P: warning: %s contains output sections;"
3642 " did you forget -T?\n"),
3643 s
->input_statement
.filename
);
3644 *stat_ptr
->tail
= add
.head
;
3645 stat_ptr
->tail
= add
.tail
;
3649 *add
.tail
= s
->header
.next
;
3650 s
->header
.next
= add
.head
;
3654 #if BFD_SUPPORTS_PLUGINS
3655 /* If we have found the point at which a plugin added new
3656 files, clear plugin_insert to enable archive rescan. */
3657 if (&s
->input_statement
== plugin_insert
)
3658 plugin_insert
= NULL
;
3661 case lang_assignment_statement_enum
:
3662 if (s
->assignment_statement
.exp
->type
.node_class
!= etree_assert
)
3663 exp_fold_tree_no_dot (s
->assignment_statement
.exp
);
3670 /* Exit if any of the files were missing. */
3671 if (input_flags
.missing_file
)
3675 #ifdef ENABLE_LIBCTF
3676 /* Emit CTF errors and warnings. fp can be NULL to report errors/warnings
3677 that happened specifically at CTF open time. */
3679 lang_ctf_errs_warnings (ctf_dict_t
*fp
)
3681 ctf_next_t
*i
= NULL
;
3686 while ((text
= ctf_errwarning_next (fp
, &i
, &is_warning
, &err
)) != NULL
)
3688 einfo (_("%s: %s\n"), is_warning
? _("CTF warning"): _("CTF error"),
3692 if (err
!= ECTF_NEXT_END
)
3694 einfo (_("CTF error: cannot get CTF errors: `%s'\n"),
3698 /* `err' returns errors from the error/warning iterator in particular.
3699 These never assert. But if we have an fp, that could have recorded
3700 an assertion failure: assert if it has done so. */
3701 ASSERT (!fp
|| ctf_errno (fp
) != ECTF_INTERNAL
);
3704 /* Open the CTF sections in the input files with libctf: if any were opened,
3705 create a fake input file that we'll write the merged CTF data to later
3709 ldlang_open_ctf (void)
3714 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3718 /* Incoming files from the compiler have a single ctf_dict_t in them
3719 (which is presented to us by the libctf API in a ctf_archive_t
3720 wrapper): files derived from a previous relocatable link have a CTF
3721 archive containing possibly many CTF files. */
3723 if ((file
->the_ctf
= ctf_bfdopen (file
->the_bfd
, &err
)) == NULL
)
3725 if (err
!= ECTF_NOCTFDATA
)
3727 lang_ctf_errs_warnings (NULL
);
3728 einfo (_("%P: warning: CTF section in %pB not loaded; "
3729 "its types will be discarded: %s\n"), file
->the_bfd
,
3735 /* Prevent the contents of this section from being written, while
3736 requiring the section itself to be duplicated in the output, but only
3738 /* This section must exist if ctf_bfdopen() succeeded. */
3739 sect
= bfd_get_section_by_name (file
->the_bfd
, ".ctf");
3741 sect
->flags
|= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
| SEC_LINKER_CREATED
;
3744 sect
->flags
|= SEC_EXCLUDE
;
3754 if ((ctf_output
= ctf_create (&err
)) != NULL
)
3757 einfo (_("%P: warning: CTF output not created: `%s'\n"),
3760 LANG_FOR_EACH_INPUT_STATEMENT (errfile
)
3761 ctf_close (errfile
->the_ctf
);
3764 /* Merge together CTF sections. After this, only the symtab-dependent
3765 function and data object sections need adjustment. */
3768 lang_merge_ctf (void)
3770 asection
*output_sect
;
3776 output_sect
= bfd_get_section_by_name (link_info
.output_bfd
, ".ctf");
3778 /* If the section was discarded, don't waste time merging. */
3779 if (output_sect
== NULL
)
3781 ctf_dict_close (ctf_output
);
3784 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3786 ctf_close (file
->the_ctf
);
3787 file
->the_ctf
= NULL
;
3792 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3797 /* Takes ownership of file->the_ctf. */
3798 if (ctf_link_add_ctf (ctf_output
, file
->the_ctf
, file
->filename
) < 0)
3800 einfo (_("%P: warning: CTF section in %pB cannot be linked: `%s'\n"),
3801 file
->the_bfd
, ctf_errmsg (ctf_errno (ctf_output
)));
3802 ctf_close (file
->the_ctf
);
3803 file
->the_ctf
= NULL
;
3808 if (!config
.ctf_share_duplicated
)
3809 flags
= CTF_LINK_SHARE_UNCONFLICTED
;
3811 flags
= CTF_LINK_SHARE_DUPLICATED
;
3812 if (!config
.ctf_variables
)
3813 flags
|= CTF_LINK_OMIT_VARIABLES_SECTION
;
3814 if (bfd_link_relocatable (&link_info
))
3815 flags
|= CTF_LINK_NO_FILTER_REPORTED_SYMS
;
3817 if (ctf_link (ctf_output
, flags
) < 0)
3819 lang_ctf_errs_warnings (ctf_output
);
3820 einfo (_("%P: warning: CTF linking failed; "
3821 "output will have no CTF section: %s\n"),
3822 ctf_errmsg (ctf_errno (ctf_output
)));
3825 output_sect
->size
= 0;
3826 output_sect
->flags
|= SEC_EXCLUDE
;
3829 /* Output any lingering errors that didn't come from ctf_link. */
3830 lang_ctf_errs_warnings (ctf_output
);
3833 /* Let the emulation acquire strings from the dynamic strtab to help it optimize
3834 the CTF, if supported. */
3837 ldlang_ctf_acquire_strings (struct elf_strtab_hash
*dynstrtab
)
3839 ldemul_acquire_strings_for_ctf (ctf_output
, dynstrtab
);
3842 /* Inform the emulation about the addition of a new dynamic symbol, in BFD
3844 void ldlang_ctf_new_dynsym (int symidx
, struct elf_internal_sym
*sym
)
3846 ldemul_new_dynsym_for_ctf (ctf_output
, symidx
, sym
);
3849 /* Write out the CTF section. Called early, if the emulation isn't going to
3850 need to dedup against the strtab and symtab, then possibly called from the
3851 target linker code if the dedup has happened. */
3853 lang_write_ctf (int late
)
3856 asection
*output_sect
;
3863 /* Emit CTF late if this emulation says it can do so. */
3864 if (ldemul_emit_ctf_early ())
3869 if (!ldemul_emit_ctf_early ())
3873 /* Inform the emulation that all the symbols that will be received have
3876 ldemul_new_dynsym_for_ctf (ctf_output
, 0, NULL
);
3880 output_sect
= bfd_get_section_by_name (link_info
.output_bfd
, ".ctf");
3883 output_sect
->contents
= ctf_link_write (ctf_output
, &output_size
,
3884 CTF_COMPRESSION_THRESHOLD
);
3885 output_sect
->size
= output_size
;
3886 output_sect
->flags
|= SEC_IN_MEMORY
| SEC_KEEP
;
3888 lang_ctf_errs_warnings (ctf_output
);
3889 if (!output_sect
->contents
)
3891 einfo (_("%P: warning: CTF section emission failed; "
3892 "output will have no CTF section: %s\n"),
3893 ctf_errmsg (ctf_errno (ctf_output
)));
3894 output_sect
->size
= 0;
3895 output_sect
->flags
|= SEC_EXCLUDE
;
3899 /* This also closes every CTF input file used in the link. */
3900 ctf_dict_close (ctf_output
);
3903 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3904 file
->the_ctf
= NULL
;
3907 /* Write out the CTF section late, if the emulation needs that. */
3910 ldlang_write_ctf_late (void)
3912 /* Trigger a "late call", if the emulation needs one. */
3918 ldlang_open_ctf (void)
3920 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3924 /* If built without CTF, warn and delete all CTF sections from the output.
3925 (The alternative would be to simply concatenate them, which does not
3926 yield a valid CTF section.) */
3928 if ((sect
= bfd_get_section_by_name (file
->the_bfd
, ".ctf")) != NULL
)
3930 einfo (_("%P: warning: CTF section in %pB not linkable: "
3931 "%P was built without support for CTF\n"), file
->the_bfd
);
3933 sect
->flags
|= SEC_EXCLUDE
;
3938 static void lang_merge_ctf (void) {}
3940 ldlang_ctf_acquire_strings (struct elf_strtab_hash
*dynstrtab
3941 ATTRIBUTE_UNUSED
) {}
3943 ldlang_ctf_new_dynsym (int symidx ATTRIBUTE_UNUSED
,
3944 struct elf_internal_sym
*sym ATTRIBUTE_UNUSED
) {}
3945 static void lang_write_ctf (int late ATTRIBUTE_UNUSED
) {}
3946 void ldlang_write_ctf_late (void) {}
3949 /* Add the supplied name to the symbol table as an undefined reference.
3950 This is a two step process as the symbol table doesn't even exist at
3951 the time the ld command line is processed. First we put the name
3952 on a list, then, once the output file has been opened, transfer the
3953 name to the symbol table. */
3955 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3957 #define ldlang_undef_chain_list_head entry_symbol.next
3960 ldlang_add_undef (const char *const name
, bfd_boolean cmdline ATTRIBUTE_UNUSED
)
3962 ldlang_undef_chain_list_type
*new_undef
;
3964 new_undef
= stat_alloc (sizeof (*new_undef
));
3965 new_undef
->next
= ldlang_undef_chain_list_head
;
3966 ldlang_undef_chain_list_head
= new_undef
;
3968 new_undef
->name
= xstrdup (name
);
3970 if (link_info
.output_bfd
!= NULL
)
3971 insert_undefined (new_undef
->name
);
3974 /* Insert NAME as undefined in the symbol table. */
3977 insert_undefined (const char *name
)
3979 struct bfd_link_hash_entry
*h
;
3981 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
3983 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
3984 if (h
->type
== bfd_link_hash_new
)
3986 h
->type
= bfd_link_hash_undefined
;
3987 h
->u
.undef
.abfd
= NULL
;
3988 h
->non_ir_ref_regular
= TRUE
;
3989 bfd_link_add_undef (link_info
.hash
, h
);
3993 /* Run through the list of undefineds created above and place them
3994 into the linker hash table as undefined symbols belonging to the
3998 lang_place_undefineds (void)
4000 ldlang_undef_chain_list_type
*ptr
;
4002 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
4003 insert_undefined (ptr
->name
);
4006 /* Mark -u symbols against garbage collection. */
4009 lang_mark_undefineds (void)
4011 ldlang_undef_chain_list_type
*ptr
;
4013 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
4014 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
4016 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*)
4017 bfd_link_hash_lookup (link_info
.hash
, ptr
->name
, FALSE
, FALSE
, TRUE
);
4023 /* Structure used to build the list of symbols that the user has required
4026 struct require_defined_symbol
4029 struct require_defined_symbol
*next
;
4032 /* The list of symbols that the user has required be defined. */
4034 static struct require_defined_symbol
*require_defined_symbol_list
;
4036 /* Add a new symbol NAME to the list of symbols that are required to be
4040 ldlang_add_require_defined (const char *const name
)
4042 struct require_defined_symbol
*ptr
;
4044 ldlang_add_undef (name
, TRUE
);
4045 ptr
= stat_alloc (sizeof (*ptr
));
4046 ptr
->next
= require_defined_symbol_list
;
4047 ptr
->name
= strdup (name
);
4048 require_defined_symbol_list
= ptr
;
4051 /* Check that all symbols the user required to be defined, are defined,
4052 raise an error if we find a symbol that is not defined. */
4055 ldlang_check_require_defined_symbols (void)
4057 struct require_defined_symbol
*ptr
;
4059 for (ptr
= require_defined_symbol_list
; ptr
!= NULL
; ptr
= ptr
->next
)
4061 struct bfd_link_hash_entry
*h
;
4063 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
,
4064 FALSE
, FALSE
, TRUE
);
4066 || (h
->type
!= bfd_link_hash_defined
4067 && h
->type
!= bfd_link_hash_defweak
))
4068 einfo(_("%X%P: required symbol `%s' not defined\n"), ptr
->name
);
4072 /* Check for all readonly or some readwrite sections. */
4075 check_input_sections
4076 (lang_statement_union_type
*s
,
4077 lang_output_section_statement_type
*output_section_statement
)
4079 for (; s
!= NULL
; s
= s
->header
.next
)
4081 switch (s
->header
.type
)
4083 case lang_wild_statement_enum
:
4084 walk_wild (&s
->wild_statement
, check_section_callback
,
4085 output_section_statement
);
4086 if (!output_section_statement
->all_input_readonly
)
4089 case lang_constructors_statement_enum
:
4090 check_input_sections (constructor_list
.head
,
4091 output_section_statement
);
4092 if (!output_section_statement
->all_input_readonly
)
4095 case lang_group_statement_enum
:
4096 check_input_sections (s
->group_statement
.children
.head
,
4097 output_section_statement
);
4098 if (!output_section_statement
->all_input_readonly
)
4107 /* Update wildcard statements if needed. */
4110 update_wild_statements (lang_statement_union_type
*s
)
4112 struct wildcard_list
*sec
;
4114 switch (sort_section
)
4124 for (; s
!= NULL
; s
= s
->header
.next
)
4126 switch (s
->header
.type
)
4131 case lang_wild_statement_enum
:
4132 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
4134 /* Don't sort .init/.fini sections. */
4135 if (strcmp (sec
->spec
.name
, ".init") != 0
4136 && strcmp (sec
->spec
.name
, ".fini") != 0)
4137 switch (sec
->spec
.sorted
)
4140 sec
->spec
.sorted
= sort_section
;
4143 if (sort_section
== by_alignment
)
4144 sec
->spec
.sorted
= by_name_alignment
;
4147 if (sort_section
== by_name
)
4148 sec
->spec
.sorted
= by_alignment_name
;
4155 case lang_constructors_statement_enum
:
4156 update_wild_statements (constructor_list
.head
);
4159 case lang_output_section_statement_enum
:
4160 update_wild_statements
4161 (s
->output_section_statement
.children
.head
);
4164 case lang_group_statement_enum
:
4165 update_wild_statements (s
->group_statement
.children
.head
);
4173 /* Open input files and attach to output sections. */
4176 map_input_to_output_sections
4177 (lang_statement_union_type
*s
, const char *target
,
4178 lang_output_section_statement_type
*os
)
4180 for (; s
!= NULL
; s
= s
->header
.next
)
4182 lang_output_section_statement_type
*tos
;
4185 switch (s
->header
.type
)
4187 case lang_wild_statement_enum
:
4188 wild (&s
->wild_statement
, target
, os
);
4190 case lang_constructors_statement_enum
:
4191 map_input_to_output_sections (constructor_list
.head
,
4195 case lang_output_section_statement_enum
:
4196 tos
= &s
->output_section_statement
;
4197 if (tos
->constraint
== ONLY_IF_RW
4198 || tos
->constraint
== ONLY_IF_RO
)
4200 tos
->all_input_readonly
= TRUE
;
4201 check_input_sections (tos
->children
.head
, tos
);
4202 if (tos
->all_input_readonly
!= (tos
->constraint
== ONLY_IF_RO
))
4203 tos
->constraint
= -1;
4205 if (tos
->constraint
>= 0)
4206 map_input_to_output_sections (tos
->children
.head
,
4210 case lang_output_statement_enum
:
4212 case lang_target_statement_enum
:
4213 target
= s
->target_statement
.target
;
4215 case lang_group_statement_enum
:
4216 map_input_to_output_sections (s
->group_statement
.children
.head
,
4220 case lang_data_statement_enum
:
4221 /* Make sure that any sections mentioned in the expression
4223 exp_init_os (s
->data_statement
.exp
);
4224 /* The output section gets CONTENTS, ALLOC and LOAD, but
4225 these may be overridden by the script. */
4226 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
;
4227 switch (os
->sectype
)
4229 case normal_section
:
4230 case overlay_section
:
4231 case first_overlay_section
:
4233 case noalloc_section
:
4234 flags
= SEC_HAS_CONTENTS
;
4236 case noload_section
:
4237 if (bfd_get_flavour (link_info
.output_bfd
)
4238 == bfd_target_elf_flavour
)
4239 flags
= SEC_NEVER_LOAD
| SEC_ALLOC
;
4241 flags
= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
;
4244 if (os
->bfd_section
== NULL
)
4245 init_os (os
, flags
| SEC_READONLY
);
4247 os
->bfd_section
->flags
|= flags
;
4249 case lang_input_section_enum
:
4251 case lang_fill_statement_enum
:
4252 case lang_object_symbols_statement_enum
:
4253 case lang_reloc_statement_enum
:
4254 case lang_padding_statement_enum
:
4255 case lang_input_statement_enum
:
4256 if (os
!= NULL
&& os
->bfd_section
== NULL
)
4259 case lang_assignment_statement_enum
:
4260 if (os
!= NULL
&& os
->bfd_section
== NULL
)
4263 /* Make sure that any sections mentioned in the assignment
4265 exp_init_os (s
->assignment_statement
.exp
);
4267 case lang_address_statement_enum
:
4268 /* Mark the specified section with the supplied address.
4269 If this section was actually a segment marker, then the
4270 directive is ignored if the linker script explicitly
4271 processed the segment marker. Originally, the linker
4272 treated segment directives (like -Ttext on the
4273 command-line) as section directives. We honor the
4274 section directive semantics for backwards compatibility;
4275 linker scripts that do not specifically check for
4276 SEGMENT_START automatically get the old semantics. */
4277 if (!s
->address_statement
.segment
4278 || !s
->address_statement
.segment
->used
)
4280 const char *name
= s
->address_statement
.section_name
;
4282 /* Create the output section statement here so that
4283 orphans with a set address will be placed after other
4284 script sections. If we let the orphan placement code
4285 place them in amongst other sections then the address
4286 will affect following script sections, which is
4287 likely to surprise naive users. */
4288 tos
= lang_output_section_statement_lookup (name
, 0, 1);
4289 tos
->addr_tree
= s
->address_statement
.address
;
4290 if (tos
->bfd_section
== NULL
)
4294 case lang_insert_statement_enum
:
4300 /* An insert statement snips out all the linker statements from the
4301 start of the list and places them after the output section
4302 statement specified by the insert. This operation is complicated
4303 by the fact that we keep a doubly linked list of output section
4304 statements as well as the singly linked list of all statements.
4305 FIXME someday: Twiddling with the list not only moves statements
4306 from the user's script but also input and group statements that are
4307 built from command line object files and --start-group. We only
4308 get away with this because the list pointers used by file_chain
4309 and input_file_chain are not reordered, and processing via
4310 statement_list after this point mostly ignores input statements.
4311 One exception is the map file, where LOAD and START GROUP/END GROUP
4312 can end up looking odd. */
4315 process_insert_statements (lang_statement_union_type
**start
)
4317 lang_statement_union_type
**s
;
4318 lang_output_section_statement_type
*first_os
= NULL
;
4319 lang_output_section_statement_type
*last_os
= NULL
;
4320 lang_output_section_statement_type
*os
;
4325 if ((*s
)->header
.type
== lang_output_section_statement_enum
)
4327 /* Keep pointers to the first and last output section
4328 statement in the sequence we may be about to move. */
4329 os
= &(*s
)->output_section_statement
;
4331 ASSERT (last_os
== NULL
|| last_os
->next
== os
);
4334 /* Set constraint negative so that lang_output_section_find
4335 won't match this output section statement. At this
4336 stage in linking constraint has values in the range
4337 [-1, ONLY_IN_RW]. */
4338 last_os
->constraint
= -2 - last_os
->constraint
;
4339 if (first_os
== NULL
)
4342 else if ((*s
)->header
.type
== lang_group_statement_enum
)
4344 /* A user might put -T between --start-group and
4345 --end-group. One way this odd construct might arise is
4346 from a wrapper around ld to change library search
4347 behaviour. For example:
4349 exec real_ld --start-group "$@" --end-group
4350 This isn't completely unreasonable so go looking inside a
4351 group statement for insert statements. */
4352 process_insert_statements (&(*s
)->group_statement
.children
.head
);
4354 else if ((*s
)->header
.type
== lang_insert_statement_enum
)
4356 lang_insert_statement_type
*i
= &(*s
)->insert_statement
;
4357 lang_output_section_statement_type
*where
;
4358 lang_statement_union_type
**ptr
;
4359 lang_statement_union_type
*first
;
4361 if (link_info
.non_contiguous_regions
)
4363 einfo (_("warning: INSERT statement in linker script is "
4364 "incompatible with --enable-non-contiguous-regions.\n"));
4367 where
= lang_output_section_find (i
->where
);
4368 if (where
!= NULL
&& i
->is_before
)
4371 where
= where
->prev
;
4372 while (where
!= NULL
&& where
->constraint
< 0);
4376 einfo (_("%F%P: %s not found for insert\n"), i
->where
);
4380 /* Deal with reordering the output section statement list. */
4381 if (last_os
!= NULL
)
4383 asection
*first_sec
, *last_sec
;
4384 struct lang_output_section_statement_struct
**next
;
4386 /* Snip out the output sections we are moving. */
4387 first_os
->prev
->next
= last_os
->next
;
4388 if (last_os
->next
== NULL
)
4390 next
= &first_os
->prev
->next
;
4391 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4394 last_os
->next
->prev
= first_os
->prev
;
4395 /* Add them in at the new position. */
4396 last_os
->next
= where
->next
;
4397 if (where
->next
== NULL
)
4399 next
= &last_os
->next
;
4400 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4403 where
->next
->prev
= last_os
;
4404 first_os
->prev
= where
;
4405 where
->next
= first_os
;
4407 /* Move the bfd sections in the same way. */
4410 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4412 os
->constraint
= -2 - os
->constraint
;
4413 if (os
->bfd_section
!= NULL
4414 && os
->bfd_section
->owner
!= NULL
)
4416 last_sec
= os
->bfd_section
;
4417 if (first_sec
== NULL
)
4418 first_sec
= last_sec
;
4423 if (last_sec
!= NULL
)
4425 asection
*sec
= where
->bfd_section
;
4427 sec
= output_prev_sec_find (where
);
4429 /* The place we want to insert must come after the
4430 sections we are moving. So if we find no
4431 section or if the section is the same as our
4432 last section, then no move is needed. */
4433 if (sec
!= NULL
&& sec
!= last_sec
)
4435 /* Trim them off. */
4436 if (first_sec
->prev
!= NULL
)
4437 first_sec
->prev
->next
= last_sec
->next
;
4439 link_info
.output_bfd
->sections
= last_sec
->next
;
4440 if (last_sec
->next
!= NULL
)
4441 last_sec
->next
->prev
= first_sec
->prev
;
4443 link_info
.output_bfd
->section_last
= first_sec
->prev
;
4445 last_sec
->next
= sec
->next
;
4446 if (sec
->next
!= NULL
)
4447 sec
->next
->prev
= last_sec
;
4449 link_info
.output_bfd
->section_last
= last_sec
;
4450 first_sec
->prev
= sec
;
4451 sec
->next
= first_sec
;
4459 ptr
= insert_os_after (where
);
4460 /* Snip everything from the start of the list, up to and
4461 including the insert statement we are currently processing. */
4463 *start
= (*s
)->header
.next
;
4464 /* Add them back where they belong, minus the insert. */
4467 statement_list
.tail
= s
;
4472 s
= &(*s
)->header
.next
;
4475 /* Undo constraint twiddling. */
4476 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4478 os
->constraint
= -2 - os
->constraint
;
4484 /* An output section might have been removed after its statement was
4485 added. For example, ldemul_before_allocation can remove dynamic
4486 sections if they turn out to be not needed. Clean them up here. */
4489 strip_excluded_output_sections (void)
4491 lang_output_section_statement_type
*os
;
4493 /* Run lang_size_sections (if not already done). */
4494 if (expld
.phase
!= lang_mark_phase_enum
)
4496 expld
.phase
= lang_mark_phase_enum
;
4497 expld
.dataseg
.phase
= exp_seg_none
;
4498 one_lang_size_sections_pass (NULL
, FALSE
);
4499 lang_reset_memory_regions ();
4502 for (os
= (void *) lang_os_list
.head
;
4506 asection
*output_section
;
4507 bfd_boolean exclude
;
4509 if (os
->constraint
< 0)
4512 output_section
= os
->bfd_section
;
4513 if (output_section
== NULL
)
4516 exclude
= (output_section
->rawsize
== 0
4517 && (output_section
->flags
& SEC_KEEP
) == 0
4518 && !bfd_section_removed_from_list (link_info
.output_bfd
,
4521 /* Some sections have not yet been sized, notably .gnu.version,
4522 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
4523 input sections, so don't drop output sections that have such
4524 input sections unless they are also marked SEC_EXCLUDE. */
4525 if (exclude
&& output_section
->map_head
.s
!= NULL
)
4529 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
4530 if ((s
->flags
& SEC_EXCLUDE
) == 0
4531 && ((s
->flags
& SEC_LINKER_CREATED
) != 0
4532 || link_info
.emitrelocations
))
4541 /* We don't set bfd_section to NULL since bfd_section of the
4542 removed output section statement may still be used. */
4543 if (!os
->update_dot
)
4545 output_section
->flags
|= SEC_EXCLUDE
;
4546 bfd_section_list_remove (link_info
.output_bfd
, output_section
);
4547 link_info
.output_bfd
->section_count
--;
4552 /* Called from ldwrite to clear out asection.map_head and
4553 asection.map_tail for use as link_orders in ldwrite. */
4556 lang_clear_os_map (void)
4558 lang_output_section_statement_type
*os
;
4560 if (map_head_is_link_order
)
4563 for (os
= (void *) lang_os_list
.head
;
4567 asection
*output_section
;
4569 if (os
->constraint
< 0)
4572 output_section
= os
->bfd_section
;
4573 if (output_section
== NULL
)
4576 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
4577 output_section
->map_head
.link_order
= NULL
;
4578 output_section
->map_tail
.link_order
= NULL
;
4581 /* Stop future calls to lang_add_section from messing with map_head
4582 and map_tail link_order fields. */
4583 map_head_is_link_order
= TRUE
;
4587 print_output_section_statement
4588 (lang_output_section_statement_type
*output_section_statement
)
4590 asection
*section
= output_section_statement
->bfd_section
;
4593 if (output_section_statement
!= abs_output_section
)
4595 minfo ("\n%s", output_section_statement
->name
);
4597 if (section
!= NULL
)
4599 print_dot
= section
->vma
;
4601 len
= strlen (output_section_statement
->name
);
4602 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4607 while (len
< SECTION_NAME_MAP_LENGTH
)
4613 minfo ("0x%V %W", section
->vma
, TO_ADDR (section
->size
));
4615 if (section
->vma
!= section
->lma
)
4616 minfo (_(" load address 0x%V"), section
->lma
);
4618 if (output_section_statement
->update_dot_tree
!= NULL
)
4619 exp_fold_tree (output_section_statement
->update_dot_tree
,
4620 bfd_abs_section_ptr
, &print_dot
);
4626 print_statement_list (output_section_statement
->children
.head
,
4627 output_section_statement
);
4631 print_assignment (lang_assignment_statement_type
*assignment
,
4632 lang_output_section_statement_type
*output_section
)
4639 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4642 if (assignment
->exp
->type
.node_class
== etree_assert
)
4645 tree
= assignment
->exp
->assert_s
.child
;
4649 const char *dst
= assignment
->exp
->assign
.dst
;
4651 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
4652 tree
= assignment
->exp
;
4655 osec
= output_section
->bfd_section
;
4657 osec
= bfd_abs_section_ptr
;
4659 if (assignment
->exp
->type
.node_class
!= etree_provide
)
4660 exp_fold_tree (tree
, osec
, &print_dot
);
4662 expld
.result
.valid_p
= FALSE
;
4664 if (expld
.result
.valid_p
)
4668 if (assignment
->exp
->type
.node_class
== etree_assert
4670 || expld
.assign_name
!= NULL
)
4672 value
= expld
.result
.value
;
4674 if (expld
.result
.section
!= NULL
)
4675 value
+= expld
.result
.section
->vma
;
4677 minfo ("0x%V", value
);
4683 struct bfd_link_hash_entry
*h
;
4685 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
4686 FALSE
, FALSE
, TRUE
);
4688 && (h
->type
== bfd_link_hash_defined
4689 || h
->type
== bfd_link_hash_defweak
))
4691 value
= h
->u
.def
.value
;
4692 value
+= h
->u
.def
.section
->output_section
->vma
;
4693 value
+= h
->u
.def
.section
->output_offset
;
4695 minfo ("[0x%V]", value
);
4698 minfo ("[unresolved]");
4703 if (assignment
->exp
->type
.node_class
== etree_provide
)
4704 minfo ("[!provide]");
4711 expld
.assign_name
= NULL
;
4714 exp_print_tree (assignment
->exp
);
4719 print_input_statement (lang_input_statement_type
*statm
)
4721 if (statm
->filename
!= NULL
)
4722 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
4725 /* Print all symbols defined in a particular section. This is called
4726 via bfd_link_hash_traverse, or by print_all_symbols. */
4729 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
4731 asection
*sec
= (asection
*) ptr
;
4733 if ((hash_entry
->type
== bfd_link_hash_defined
4734 || hash_entry
->type
== bfd_link_hash_defweak
)
4735 && sec
== hash_entry
->u
.def
.section
)
4739 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4742 (hash_entry
->u
.def
.value
4743 + hash_entry
->u
.def
.section
->output_offset
4744 + hash_entry
->u
.def
.section
->output_section
->vma
));
4746 minfo (" %pT\n", hash_entry
->root
.string
);
4753 hash_entry_addr_cmp (const void *a
, const void *b
)
4755 const struct bfd_link_hash_entry
*l
= *(const struct bfd_link_hash_entry
**)a
;
4756 const struct bfd_link_hash_entry
*r
= *(const struct bfd_link_hash_entry
**)b
;
4758 if (l
->u
.def
.value
< r
->u
.def
.value
)
4760 else if (l
->u
.def
.value
> r
->u
.def
.value
)
4767 print_all_symbols (asection
*sec
)
4769 input_section_userdata_type
*ud
= bfd_section_userdata (sec
);
4770 struct map_symbol_def
*def
;
4771 struct bfd_link_hash_entry
**entries
;
4777 *ud
->map_symbol_def_tail
= 0;
4779 /* Sort the symbols by address. */
4780 entries
= (struct bfd_link_hash_entry
**)
4781 obstack_alloc (&map_obstack
,
4782 ud
->map_symbol_def_count
* sizeof (*entries
));
4784 for (i
= 0, def
= ud
->map_symbol_def_head
; def
; def
= def
->next
, i
++)
4785 entries
[i
] = def
->entry
;
4787 qsort (entries
, ud
->map_symbol_def_count
, sizeof (*entries
),
4788 hash_entry_addr_cmp
);
4790 /* Print the symbols. */
4791 for (i
= 0; i
< ud
->map_symbol_def_count
; i
++)
4792 ldemul_print_symbol (entries
[i
], sec
);
4794 obstack_free (&map_obstack
, entries
);
4797 /* Print information about an input section to the map file. */
4800 print_input_section (asection
*i
, bfd_boolean is_discarded
)
4802 bfd_size_type size
= i
->size
;
4809 minfo ("%s", i
->name
);
4811 len
= 1 + strlen (i
->name
);
4812 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4817 while (len
< SECTION_NAME_MAP_LENGTH
)
4823 if (i
->output_section
!= NULL
4824 && i
->output_section
->owner
== link_info
.output_bfd
)
4825 addr
= i
->output_section
->vma
+ i
->output_offset
;
4833 minfo ("0x%V %W %pB\n", addr
, TO_ADDR (size
), i
->owner
);
4835 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
4837 len
= SECTION_NAME_MAP_LENGTH
+ 3;
4849 minfo (_("%W (size before relaxing)\n"), TO_ADDR (i
->rawsize
));
4852 if (i
->output_section
!= NULL
4853 && i
->output_section
->owner
== link_info
.output_bfd
)
4855 if (link_info
.reduce_memory_overheads
)
4856 bfd_link_hash_traverse (link_info
.hash
, ldemul_print_symbol
, i
);
4858 print_all_symbols (i
);
4860 /* Update print_dot, but make sure that we do not move it
4861 backwards - this could happen if we have overlays and a
4862 later overlay is shorter than an earier one. */
4863 if (addr
+ TO_ADDR (size
) > print_dot
)
4864 print_dot
= addr
+ TO_ADDR (size
);
4869 print_fill_statement (lang_fill_statement_type
*fill
)
4873 fputs (" FILL mask 0x", config
.map_file
);
4874 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
4875 fprintf (config
.map_file
, "%02x", *p
);
4876 fputs ("\n", config
.map_file
);
4880 print_data_statement (lang_data_statement_type
*data
)
4887 init_opb (data
->output_section
);
4888 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4891 addr
= data
->output_offset
;
4892 if (data
->output_section
!= NULL
)
4893 addr
+= data
->output_section
->vma
;
4921 if (size
< TO_SIZE ((unsigned) 1))
4922 size
= TO_SIZE ((unsigned) 1);
4923 minfo ("0x%V %W %s 0x%v", addr
, TO_ADDR (size
), name
, data
->value
);
4925 if (data
->exp
->type
.node_class
!= etree_value
)
4928 exp_print_tree (data
->exp
);
4933 print_dot
= addr
+ TO_ADDR (size
);
4936 /* Print an address statement. These are generated by options like
4940 print_address_statement (lang_address_statement_type
*address
)
4942 minfo (_("Address of section %s set to "), address
->section_name
);
4943 exp_print_tree (address
->address
);
4947 /* Print a reloc statement. */
4950 print_reloc_statement (lang_reloc_statement_type
*reloc
)
4956 init_opb (reloc
->output_section
);
4957 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4960 addr
= reloc
->output_offset
;
4961 if (reloc
->output_section
!= NULL
)
4962 addr
+= reloc
->output_section
->vma
;
4964 size
= bfd_get_reloc_size (reloc
->howto
);
4966 minfo ("0x%V %W RELOC %s ", addr
, TO_ADDR (size
), reloc
->howto
->name
);
4968 if (reloc
->name
!= NULL
)
4969 minfo ("%s+", reloc
->name
);
4971 minfo ("%s+", reloc
->section
->name
);
4973 exp_print_tree (reloc
->addend_exp
);
4977 print_dot
= addr
+ TO_ADDR (size
);
4981 print_padding_statement (lang_padding_statement_type
*s
)
4986 init_opb (s
->output_section
);
4989 len
= sizeof " *fill*" - 1;
4990 while (len
< SECTION_NAME_MAP_LENGTH
)
4996 addr
= s
->output_offset
;
4997 if (s
->output_section
!= NULL
)
4998 addr
+= s
->output_section
->vma
;
4999 minfo ("0x%V %W ", addr
, TO_ADDR (s
->size
));
5001 if (s
->fill
->size
!= 0)
5005 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
5006 fprintf (config
.map_file
, "%02x", *p
);
5011 print_dot
= addr
+ TO_ADDR (s
->size
);
5015 print_wild_statement (lang_wild_statement_type
*w
,
5016 lang_output_section_statement_type
*os
)
5018 struct wildcard_list
*sec
;
5022 if (w
->exclude_name_list
)
5025 minfo ("EXCLUDE_FILE(%s", w
->exclude_name_list
->name
);
5026 for (tmp
= w
->exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
5027 minfo (" %s", tmp
->name
);
5031 if (w
->filenames_sorted
)
5032 minfo ("SORT_BY_NAME(");
5033 if (w
->filename
!= NULL
)
5034 minfo ("%s", w
->filename
);
5037 if (w
->filenames_sorted
)
5041 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
5043 int closing_paren
= 0;
5045 switch (sec
->spec
.sorted
)
5051 minfo ("SORT_BY_NAME(");
5056 minfo ("SORT_BY_ALIGNMENT(");
5060 case by_name_alignment
:
5061 minfo ("SORT_BY_NAME(SORT_BY_ALIGNMENT(");
5065 case by_alignment_name
:
5066 minfo ("SORT_BY_ALIGNMENT(SORT_BY_NAME(");
5071 minfo ("SORT_NONE(");
5075 case by_init_priority
:
5076 minfo ("SORT_BY_INIT_PRIORITY(");
5081 if (sec
->spec
.exclude_name_list
!= NULL
)
5084 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
5085 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
5086 minfo (" %s", tmp
->name
);
5089 if (sec
->spec
.name
!= NULL
)
5090 minfo ("%s", sec
->spec
.name
);
5093 for (;closing_paren
> 0; closing_paren
--)
5102 print_statement_list (w
->children
.head
, os
);
5105 /* Print a group statement. */
5108 print_group (lang_group_statement_type
*s
,
5109 lang_output_section_statement_type
*os
)
5111 fprintf (config
.map_file
, "START GROUP\n");
5112 print_statement_list (s
->children
.head
, os
);
5113 fprintf (config
.map_file
, "END GROUP\n");
5116 /* Print the list of statements in S.
5117 This can be called for any statement type. */
5120 print_statement_list (lang_statement_union_type
*s
,
5121 lang_output_section_statement_type
*os
)
5125 print_statement (s
, os
);
5130 /* Print the first statement in statement list S.
5131 This can be called for any statement type. */
5134 print_statement (lang_statement_union_type
*s
,
5135 lang_output_section_statement_type
*os
)
5137 switch (s
->header
.type
)
5140 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
5143 case lang_constructors_statement_enum
:
5144 if (constructor_list
.head
!= NULL
)
5146 if (constructors_sorted
)
5147 minfo (" SORT (CONSTRUCTORS)\n");
5149 minfo (" CONSTRUCTORS\n");
5150 print_statement_list (constructor_list
.head
, os
);
5153 case lang_wild_statement_enum
:
5154 print_wild_statement (&s
->wild_statement
, os
);
5156 case lang_address_statement_enum
:
5157 print_address_statement (&s
->address_statement
);
5159 case lang_object_symbols_statement_enum
:
5160 minfo (" CREATE_OBJECT_SYMBOLS\n");
5162 case lang_fill_statement_enum
:
5163 print_fill_statement (&s
->fill_statement
);
5165 case lang_data_statement_enum
:
5166 print_data_statement (&s
->data_statement
);
5168 case lang_reloc_statement_enum
:
5169 print_reloc_statement (&s
->reloc_statement
);
5171 case lang_input_section_enum
:
5172 print_input_section (s
->input_section
.section
, FALSE
);
5174 case lang_padding_statement_enum
:
5175 print_padding_statement (&s
->padding_statement
);
5177 case lang_output_section_statement_enum
:
5178 print_output_section_statement (&s
->output_section_statement
);
5180 case lang_assignment_statement_enum
:
5181 print_assignment (&s
->assignment_statement
, os
);
5183 case lang_target_statement_enum
:
5184 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
5186 case lang_output_statement_enum
:
5187 minfo ("OUTPUT(%s", s
->output_statement
.name
);
5188 if (output_target
!= NULL
)
5189 minfo (" %s", output_target
);
5192 case lang_input_statement_enum
:
5193 print_input_statement (&s
->input_statement
);
5195 case lang_group_statement_enum
:
5196 print_group (&s
->group_statement
, os
);
5198 case lang_insert_statement_enum
:
5199 minfo ("INSERT %s %s\n",
5200 s
->insert_statement
.is_before
? "BEFORE" : "AFTER",
5201 s
->insert_statement
.where
);
5207 print_statements (void)
5209 print_statement_list (statement_list
.head
, abs_output_section
);
5212 /* Print the first N statements in statement list S to STDERR.
5213 If N == 0, nothing is printed.
5214 If N < 0, the entire list is printed.
5215 Intended to be called from GDB. */
5218 dprint_statement (lang_statement_union_type
*s
, int n
)
5220 FILE *map_save
= config
.map_file
;
5222 config
.map_file
= stderr
;
5225 print_statement_list (s
, abs_output_section
);
5228 while (s
&& --n
>= 0)
5230 print_statement (s
, abs_output_section
);
5235 config
.map_file
= map_save
;
5239 insert_pad (lang_statement_union_type
**ptr
,
5241 bfd_size_type alignment_needed
,
5242 asection
*output_section
,
5245 static fill_type zero_fill
;
5246 lang_statement_union_type
*pad
= NULL
;
5248 if (ptr
!= &statement_list
.head
)
5249 pad
= ((lang_statement_union_type
*)
5250 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
5252 && pad
->header
.type
== lang_padding_statement_enum
5253 && pad
->padding_statement
.output_section
== output_section
)
5255 /* Use the existing pad statement. */
5257 else if ((pad
= *ptr
) != NULL
5258 && pad
->header
.type
== lang_padding_statement_enum
5259 && pad
->padding_statement
.output_section
== output_section
)
5261 /* Use the existing pad statement. */
5265 /* Make a new padding statement, linked into existing chain. */
5266 pad
= stat_alloc (sizeof (lang_padding_statement_type
));
5267 pad
->header
.next
= *ptr
;
5269 pad
->header
.type
= lang_padding_statement_enum
;
5270 pad
->padding_statement
.output_section
= output_section
;
5273 pad
->padding_statement
.fill
= fill
;
5275 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
5276 pad
->padding_statement
.size
= alignment_needed
;
5277 if (!(output_section
->flags
& SEC_FIXED_SIZE
))
5278 output_section
->size
= TO_SIZE (dot
+ TO_ADDR (alignment_needed
)
5279 - output_section
->vma
);
5282 /* Work out how much this section will move the dot point. */
5286 (lang_statement_union_type
**this_ptr
,
5287 lang_output_section_statement_type
*output_section_statement
,
5289 bfd_boolean
*removed
,
5292 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
5293 asection
*i
= is
->section
;
5294 asection
*o
= output_section_statement
->bfd_section
;
5297 if (link_info
.non_contiguous_regions
)
5299 /* If the input section I has already been successfully assigned
5300 to an output section other than O, don't bother with it and
5301 let the caller remove it from the list. Keep processing in
5302 case we have already handled O, because the repeated passes
5303 have reinitialized its size. */
5304 if (i
->already_assigned
&& i
->already_assigned
!= o
)
5311 if (i
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
5312 i
->output_offset
= i
->vma
- o
->vma
;
5313 else if (((i
->flags
& SEC_EXCLUDE
) != 0)
5314 || output_section_statement
->ignored
)
5315 i
->output_offset
= dot
- o
->vma
;
5318 bfd_size_type alignment_needed
;
5320 /* Align this section first to the input sections requirement,
5321 then to the output section's requirement. If this alignment
5322 is greater than any seen before, then record it too. Perform
5323 the alignment by inserting a magic 'padding' statement. */
5325 if (output_section_statement
->subsection_alignment
!= NULL
)
5327 = exp_get_power (output_section_statement
->subsection_alignment
,
5328 "subsection alignment");
5330 if (o
->alignment_power
< i
->alignment_power
)
5331 o
->alignment_power
= i
->alignment_power
;
5333 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
5335 if (alignment_needed
!= 0)
5337 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
5338 dot
+= alignment_needed
;
5341 if (link_info
.non_contiguous_regions
)
5343 /* If I would overflow O, let the caller remove I from the
5345 if (output_section_statement
->region
)
5347 bfd_vma end
= output_section_statement
->region
->origin
5348 + output_section_statement
->region
->length
;
5350 if (dot
+ TO_ADDR (i
->size
) > end
)
5352 if (i
->flags
& SEC_LINKER_CREATED
)
5353 einfo (_("%F%P: Output section '%s' not large enough for the "
5354 "linker-created stubs section '%s'.\n"),
5355 i
->output_section
->name
, i
->name
);
5357 if (i
->rawsize
&& i
->rawsize
!= i
->size
)
5358 einfo (_("%F%P: Relaxation not supported with "
5359 "--enable-non-contiguous-regions (section '%s' "
5360 "would overflow '%s' after it changed size).\n"),
5361 i
->name
, i
->output_section
->name
);
5365 i
->output_section
= NULL
;
5371 /* Remember where in the output section this input section goes. */
5372 i
->output_offset
= dot
- o
->vma
;
5374 /* Mark how big the output section must be to contain this now. */
5375 dot
+= TO_ADDR (i
->size
);
5376 if (!(o
->flags
& SEC_FIXED_SIZE
))
5377 o
->size
= TO_SIZE (dot
- o
->vma
);
5379 if (link_info
.non_contiguous_regions
)
5381 /* Record that I was successfully assigned to O, and update
5382 its actual output section too. */
5383 i
->already_assigned
= o
;
5384 i
->output_section
= o
;
5398 sort_sections_by_lma (const void *arg1
, const void *arg2
)
5400 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
5401 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
5403 if (sec1
->lma
< sec2
->lma
)
5405 else if (sec1
->lma
> sec2
->lma
)
5407 else if (sec1
->id
< sec2
->id
)
5409 else if (sec1
->id
> sec2
->id
)
5416 sort_sections_by_vma (const void *arg1
, const void *arg2
)
5418 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
5419 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
5421 if (sec1
->vma
< sec2
->vma
)
5423 else if (sec1
->vma
> sec2
->vma
)
5425 else if (sec1
->id
< sec2
->id
)
5427 else if (sec1
->id
> sec2
->id
)
5433 #define IS_TBSS(s) \
5434 ((s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == SEC_THREAD_LOCAL)
5436 #define IGNORE_SECTION(s) \
5437 ((s->flags & SEC_ALLOC) == 0 || IS_TBSS (s))
5439 /* Check to see if any allocated sections overlap with other allocated
5440 sections. This can happen if a linker script specifies the output
5441 section addresses of the two sections. Also check whether any memory
5442 region has overflowed. */
5445 lang_check_section_addresses (void)
5448 struct check_sec
*sections
;
5453 bfd_vma p_start
= 0;
5455 lang_memory_region_type
*m
;
5456 bfd_boolean overlays
;
5458 /* Detect address space overflow on allocated sections. */
5459 addr_mask
= ((bfd_vma
) 1 <<
5460 (bfd_arch_bits_per_address (link_info
.output_bfd
) - 1)) - 1;
5461 addr_mask
= (addr_mask
<< 1) + 1;
5462 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5463 if ((s
->flags
& SEC_ALLOC
) != 0)
5465 s_end
= (s
->vma
+ s
->size
) & addr_mask
;
5466 if (s_end
!= 0 && s_end
< (s
->vma
& addr_mask
))
5467 einfo (_("%X%P: section %s VMA wraps around address space\n"),
5471 s_end
= (s
->lma
+ s
->size
) & addr_mask
;
5472 if (s_end
!= 0 && s_end
< (s
->lma
& addr_mask
))
5473 einfo (_("%X%P: section %s LMA wraps around address space\n"),
5478 if (bfd_count_sections (link_info
.output_bfd
) <= 1)
5481 count
= bfd_count_sections (link_info
.output_bfd
);
5482 sections
= XNEWVEC (struct check_sec
, count
);
5484 /* Scan all sections in the output list. */
5486 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5488 if (IGNORE_SECTION (s
)
5492 sections
[count
].sec
= s
;
5493 sections
[count
].warned
= FALSE
;
5503 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_lma
);
5505 /* First check section LMAs. There should be no overlap of LMAs on
5506 loadable sections, even with overlays. */
5507 for (p
= NULL
, i
= 0; i
< count
; i
++)
5509 s
= sections
[i
].sec
;
5511 if ((s
->flags
& SEC_LOAD
) != 0)
5514 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5516 /* Look for an overlap. We have sorted sections by lma, so
5517 we know that s_start >= p_start. Besides the obvious
5518 case of overlap when the current section starts before
5519 the previous one ends, we also must have overlap if the
5520 previous section wraps around the address space. */
5522 && (s_start
<= p_end
5523 || p_end
< p_start
))
5525 einfo (_("%X%P: section %s LMA [%V,%V]"
5526 " overlaps section %s LMA [%V,%V]\n"),
5527 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5528 sections
[i
].warned
= TRUE
;
5536 /* If any non-zero size allocated section (excluding tbss) starts at
5537 exactly the same VMA as another such section, then we have
5538 overlays. Overlays generated by the OVERLAY keyword will have
5539 this property. It is possible to intentionally generate overlays
5540 that fail this test, but it would be unusual. */
5541 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_vma
);
5543 p_start
= sections
[0].sec
->vma
;
5544 for (i
= 1; i
< count
; i
++)
5546 s_start
= sections
[i
].sec
->vma
;
5547 if (p_start
== s_start
)
5555 /* Now check section VMAs if no overlays were detected. */
5558 for (p
= NULL
, i
= 0; i
< count
; i
++)
5560 s
= sections
[i
].sec
;
5563 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5566 && !sections
[i
].warned
5567 && (s_start
<= p_end
5568 || p_end
< p_start
))
5569 einfo (_("%X%P: section %s VMA [%V,%V]"
5570 " overlaps section %s VMA [%V,%V]\n"),
5571 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5580 /* If any memory region has overflowed, report by how much.
5581 We do not issue this diagnostic for regions that had sections
5582 explicitly placed outside their bounds; os_region_check's
5583 diagnostics are adequate for that case.
5585 FIXME: It is conceivable that m->current - (m->origin + m->length)
5586 might overflow a 32-bit integer. There is, alas, no way to print
5587 a bfd_vma quantity in decimal. */
5588 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
5589 if (m
->had_full_message
)
5591 unsigned long over
= m
->current
- (m
->origin
+ m
->length
);
5592 einfo (ngettext ("%X%P: region `%s' overflowed by %lu byte\n",
5593 "%X%P: region `%s' overflowed by %lu bytes\n",
5595 m
->name_list
.name
, over
);
5599 /* Make sure the new address is within the region. We explicitly permit the
5600 current address to be at the exact end of the region when the address is
5601 non-zero, in case the region is at the end of addressable memory and the
5602 calculation wraps around. */
5605 os_region_check (lang_output_section_statement_type
*os
,
5606 lang_memory_region_type
*region
,
5610 if ((region
->current
< region
->origin
5611 || (region
->current
- region
->origin
> region
->length
))
5612 && ((region
->current
!= region
->origin
+ region
->length
)
5617 einfo (_("%X%P: address 0x%v of %pB section `%s'"
5618 " is not within region `%s'\n"),
5620 os
->bfd_section
->owner
,
5621 os
->bfd_section
->name
,
5622 region
->name_list
.name
);
5624 else if (!region
->had_full_message
)
5626 region
->had_full_message
= TRUE
;
5628 einfo (_("%X%P: %pB section `%s' will not fit in region `%s'\n"),
5629 os
->bfd_section
->owner
,
5630 os
->bfd_section
->name
,
5631 region
->name_list
.name
);
5637 ldlang_check_relro_region (lang_statement_union_type
*s
,
5638 seg_align_type
*seg
)
5640 if (seg
->relro
== exp_seg_relro_start
)
5642 if (!seg
->relro_start_stat
)
5643 seg
->relro_start_stat
= s
;
5646 ASSERT (seg
->relro_start_stat
== s
);
5649 else if (seg
->relro
== exp_seg_relro_end
)
5651 if (!seg
->relro_end_stat
)
5652 seg
->relro_end_stat
= s
;
5655 ASSERT (seg
->relro_end_stat
== s
);
5660 /* Set the sizes for all the output sections. */
5663 lang_size_sections_1
5664 (lang_statement_union_type
**prev
,
5665 lang_output_section_statement_type
*output_section_statement
,
5669 bfd_boolean check_regions
)
5671 lang_statement_union_type
*s
;
5672 lang_statement_union_type
*prev_s
= NULL
;
5673 bfd_boolean removed_prev_s
= FALSE
;
5675 /* Size up the sections from their constituent parts. */
5676 for (s
= *prev
; s
!= NULL
; prev_s
= s
, s
= s
->header
.next
)
5678 bfd_boolean removed
=FALSE
;
5680 switch (s
->header
.type
)
5682 case lang_output_section_statement_enum
:
5684 bfd_vma newdot
, after
, dotdelta
;
5685 lang_output_section_statement_type
*os
;
5686 lang_memory_region_type
*r
;
5687 int section_alignment
= 0;
5689 os
= &s
->output_section_statement
;
5690 init_opb (os
->bfd_section
);
5691 if (os
->constraint
== -1)
5694 /* FIXME: We shouldn't need to zero section vmas for ld -r
5695 here, in lang_insert_orphan, or in the default linker scripts.
5696 This is covering for coff backend linker bugs. See PR6945. */
5697 if (os
->addr_tree
== NULL
5698 && bfd_link_relocatable (&link_info
)
5699 && (bfd_get_flavour (link_info
.output_bfd
)
5700 == bfd_target_coff_flavour
))
5701 os
->addr_tree
= exp_intop (0);
5702 if (os
->addr_tree
!= NULL
)
5704 os
->processed_vma
= FALSE
;
5705 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
5707 if (expld
.result
.valid_p
)
5709 dot
= expld
.result
.value
;
5710 if (expld
.result
.section
!= NULL
)
5711 dot
+= expld
.result
.section
->vma
;
5713 else if (expld
.phase
!= lang_mark_phase_enum
)
5714 einfo (_("%F%P:%pS: non constant or forward reference"
5715 " address expression for section %s\n"),
5716 os
->addr_tree
, os
->name
);
5719 if (os
->bfd_section
== NULL
)
5720 /* This section was removed or never actually created. */
5723 /* If this is a COFF shared library section, use the size and
5724 address from the input section. FIXME: This is COFF
5725 specific; it would be cleaner if there were some other way
5726 to do this, but nothing simple comes to mind. */
5727 if (((bfd_get_flavour (link_info
.output_bfd
)
5728 == bfd_target_ecoff_flavour
)
5729 || (bfd_get_flavour (link_info
.output_bfd
)
5730 == bfd_target_coff_flavour
))
5731 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
5735 if (os
->children
.head
== NULL
5736 || os
->children
.head
->header
.next
!= NULL
5737 || (os
->children
.head
->header
.type
5738 != lang_input_section_enum
))
5739 einfo (_("%X%P: internal error on COFF shared library"
5740 " section %s\n"), os
->name
);
5742 input
= os
->children
.head
->input_section
.section
;
5743 bfd_set_section_vma (os
->bfd_section
,
5744 bfd_section_vma (input
));
5745 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5746 os
->bfd_section
->size
= input
->size
;
5752 if (bfd_is_abs_section (os
->bfd_section
))
5754 /* No matter what happens, an abs section starts at zero. */
5755 ASSERT (os
->bfd_section
->vma
== 0);
5759 if (os
->addr_tree
== NULL
)
5761 /* No address specified for this section, get one
5762 from the region specification. */
5763 if (os
->region
== NULL
5764 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
5765 && os
->region
->name_list
.name
[0] == '*'
5766 && strcmp (os
->region
->name_list
.name
,
5767 DEFAULT_MEMORY_REGION
) == 0))
5769 os
->region
= lang_memory_default (os
->bfd_section
);
5772 /* If a loadable section is using the default memory
5773 region, and some non default memory regions were
5774 defined, issue an error message. */
5776 && !IGNORE_SECTION (os
->bfd_section
)
5777 && !bfd_link_relocatable (&link_info
)
5779 && strcmp (os
->region
->name_list
.name
,
5780 DEFAULT_MEMORY_REGION
) == 0
5781 && lang_memory_region_list
!= NULL
5782 && (strcmp (lang_memory_region_list
->name_list
.name
,
5783 DEFAULT_MEMORY_REGION
) != 0
5784 || lang_memory_region_list
->next
!= NULL
)
5785 && lang_sizing_iteration
== 1)
5787 /* By default this is an error rather than just a
5788 warning because if we allocate the section to the
5789 default memory region we can end up creating an
5790 excessively large binary, or even seg faulting when
5791 attempting to perform a negative seek. See
5792 sources.redhat.com/ml/binutils/2003-04/msg00423.html
5793 for an example of this. This behaviour can be
5794 overridden by the using the --no-check-sections
5796 if (command_line
.check_section_addresses
)
5797 einfo (_("%F%P: error: no memory region specified"
5798 " for loadable section `%s'\n"),
5799 bfd_section_name (os
->bfd_section
));
5801 einfo (_("%P: warning: no memory region specified"
5802 " for loadable section `%s'\n"),
5803 bfd_section_name (os
->bfd_section
));
5806 newdot
= os
->region
->current
;
5807 section_alignment
= os
->bfd_section
->alignment_power
;
5810 section_alignment
= exp_get_power (os
->section_alignment
,
5811 "section alignment");
5813 /* Align to what the section needs. */
5814 if (section_alignment
> 0)
5816 bfd_vma savedot
= newdot
;
5819 newdot
= align_power (newdot
, section_alignment
);
5820 dotdelta
= newdot
- savedot
;
5822 if (lang_sizing_iteration
== 1)
5824 else if (lang_sizing_iteration
> 1)
5826 /* Only report adjustments that would change
5827 alignment from what we have already reported. */
5828 diff
= newdot
- os
->bfd_section
->vma
;
5829 if (!(diff
& (((bfd_vma
) 1 << section_alignment
) - 1)))
5833 && (config
.warn_section_align
5834 || os
->addr_tree
!= NULL
))
5835 einfo (_("%P: warning: "
5836 "start of section %s changed by %ld\n"),
5837 os
->name
, (long) diff
);
5840 bfd_set_section_vma (os
->bfd_section
, newdot
);
5842 os
->bfd_section
->output_offset
= 0;
5845 lang_size_sections_1 (&os
->children
.head
, os
,
5846 os
->fill
, newdot
, relax
, check_regions
);
5848 os
->processed_vma
= TRUE
;
5850 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5851 /* Except for some special linker created sections,
5852 no output section should change from zero size
5853 after strip_excluded_output_sections. A non-zero
5854 size on an ignored section indicates that some
5855 input section was not sized early enough. */
5856 ASSERT (os
->bfd_section
->size
== 0);
5859 dot
= os
->bfd_section
->vma
;
5861 /* Put the section within the requested block size, or
5862 align at the block boundary. */
5864 + TO_ADDR (os
->bfd_section
->size
)
5865 + os
->block_value
- 1)
5866 & - (bfd_vma
) os
->block_value
);
5868 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5869 os
->bfd_section
->size
= TO_SIZE (after
5870 - os
->bfd_section
->vma
);
5873 /* Set section lma. */
5876 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
5880 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
5881 os
->bfd_section
->lma
= lma
;
5883 else if (os
->lma_region
!= NULL
)
5885 bfd_vma lma
= os
->lma_region
->current
;
5887 if (os
->align_lma_with_input
)
5891 /* When LMA_REGION is the same as REGION, align the LMA
5892 as we did for the VMA, possibly including alignment
5893 from the bfd section. If a different region, then
5894 only align according to the value in the output
5896 if (os
->lma_region
!= os
->region
)
5897 section_alignment
= exp_get_power (os
->section_alignment
,
5898 "section alignment");
5899 if (section_alignment
> 0)
5900 lma
= align_power (lma
, section_alignment
);
5902 os
->bfd_section
->lma
= lma
;
5904 else if (r
->last_os
!= NULL
5905 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5910 last
= r
->last_os
->output_section_statement
.bfd_section
;
5912 /* A backwards move of dot should be accompanied by
5913 an explicit assignment to the section LMA (ie.
5914 os->load_base set) because backwards moves can
5915 create overlapping LMAs. */
5917 && os
->bfd_section
->size
!= 0
5918 && dot
+ TO_ADDR (os
->bfd_section
->size
) <= last
->vma
)
5920 /* If dot moved backwards then leave lma equal to
5921 vma. This is the old default lma, which might
5922 just happen to work when the backwards move is
5923 sufficiently large. Nag if this changes anything,
5924 so people can fix their linker scripts. */
5926 if (last
->vma
!= last
->lma
)
5927 einfo (_("%P: warning: dot moved backwards "
5928 "before `%s'\n"), os
->name
);
5932 /* If this is an overlay, set the current lma to that
5933 at the end of the previous section. */
5934 if (os
->sectype
== overlay_section
)
5935 lma
= last
->lma
+ TO_ADDR (last
->size
);
5937 /* Otherwise, keep the same lma to vma relationship
5938 as the previous section. */
5940 lma
= os
->bfd_section
->vma
+ last
->lma
- last
->vma
;
5942 if (section_alignment
> 0)
5943 lma
= align_power (lma
, section_alignment
);
5944 os
->bfd_section
->lma
= lma
;
5947 os
->processed_lma
= TRUE
;
5949 /* Keep track of normal sections using the default
5950 lma region. We use this to set the lma for
5951 following sections. Overlays or other linker
5952 script assignment to lma might mean that the
5953 default lma == vma is incorrect.
5954 To avoid warnings about dot moving backwards when using
5955 -Ttext, don't start tracking sections until we find one
5956 of non-zero size or with lma set differently to vma.
5957 Do this tracking before we short-cut the loop so that we
5958 track changes for the case where the section size is zero,
5959 but the lma is set differently to the vma. This is
5960 important, if an orphan section is placed after an
5961 otherwise empty output section that has an explicit lma
5962 set, we want that lma reflected in the orphans lma. */
5963 if (((!IGNORE_SECTION (os
->bfd_section
)
5964 && (os
->bfd_section
->size
!= 0
5965 || (r
->last_os
== NULL
5966 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
5967 || (r
->last_os
!= NULL
5968 && dot
>= (r
->last_os
->output_section_statement
5969 .bfd_section
->vma
))))
5970 || os
->sectype
== first_overlay_section
)
5971 && os
->lma_region
== NULL
5972 && !bfd_link_relocatable (&link_info
))
5975 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5978 /* .tbss sections effectively have zero size. */
5979 if (!IS_TBSS (os
->bfd_section
)
5980 || bfd_link_relocatable (&link_info
))
5981 dotdelta
= TO_ADDR (os
->bfd_section
->size
);
5986 if (os
->update_dot_tree
!= 0)
5987 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5989 /* Update dot in the region ?
5990 We only do this if the section is going to be allocated,
5991 since unallocated sections do not contribute to the region's
5992 overall size in memory. */
5993 if (os
->region
!= NULL
5994 && (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)))
5996 os
->region
->current
= dot
;
5999 /* Make sure the new address is within the region. */
6000 os_region_check (os
, os
->region
, os
->addr_tree
,
6001 os
->bfd_section
->vma
);
6003 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
6004 && ((os
->bfd_section
->flags
& SEC_LOAD
)
6005 || os
->align_lma_with_input
))
6007 os
->lma_region
->current
= os
->bfd_section
->lma
+ dotdelta
;
6010 os_region_check (os
, os
->lma_region
, NULL
,
6011 os
->bfd_section
->lma
);
6017 case lang_constructors_statement_enum
:
6018 dot
= lang_size_sections_1 (&constructor_list
.head
,
6019 output_section_statement
,
6020 fill
, dot
, relax
, check_regions
);
6023 case lang_data_statement_enum
:
6025 unsigned int size
= 0;
6027 s
->data_statement
.output_offset
=
6028 dot
- output_section_statement
->bfd_section
->vma
;
6029 s
->data_statement
.output_section
=
6030 output_section_statement
->bfd_section
;
6032 /* We might refer to provided symbols in the expression, and
6033 need to mark them as needed. */
6034 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
6036 switch (s
->data_statement
.type
)
6054 if (size
< TO_SIZE ((unsigned) 1))
6055 size
= TO_SIZE ((unsigned) 1);
6056 dot
+= TO_ADDR (size
);
6057 if (!(output_section_statement
->bfd_section
->flags
6059 output_section_statement
->bfd_section
->size
6060 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
6065 case lang_reloc_statement_enum
:
6069 s
->reloc_statement
.output_offset
=
6070 dot
- output_section_statement
->bfd_section
->vma
;
6071 s
->reloc_statement
.output_section
=
6072 output_section_statement
->bfd_section
;
6073 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
6074 dot
+= TO_ADDR (size
);
6075 if (!(output_section_statement
->bfd_section
->flags
6077 output_section_statement
->bfd_section
->size
6078 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
6082 case lang_wild_statement_enum
:
6083 dot
= lang_size_sections_1 (&s
->wild_statement
.children
.head
,
6084 output_section_statement
,
6085 fill
, dot
, relax
, check_regions
);
6088 case lang_object_symbols_statement_enum
:
6089 link_info
.create_object_symbols_section
6090 = output_section_statement
->bfd_section
;
6091 output_section_statement
->bfd_section
->flags
|= SEC_KEEP
;
6094 case lang_output_statement_enum
:
6095 case lang_target_statement_enum
:
6098 case lang_input_section_enum
:
6102 i
= s
->input_section
.section
;
6107 if (!bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
6108 einfo (_("%F%P: can't relax section: %E\n"));
6112 dot
= size_input_section (prev
, output_section_statement
,
6113 fill
, &removed
, dot
);
6117 case lang_input_statement_enum
:
6120 case lang_fill_statement_enum
:
6121 s
->fill_statement
.output_section
=
6122 output_section_statement
->bfd_section
;
6124 fill
= s
->fill_statement
.fill
;
6127 case lang_assignment_statement_enum
:
6129 bfd_vma newdot
= dot
;
6130 etree_type
*tree
= s
->assignment_statement
.exp
;
6132 expld
.dataseg
.relro
= exp_seg_relro_none
;
6134 exp_fold_tree (tree
,
6135 output_section_statement
->bfd_section
,
6138 ldlang_check_relro_region (s
, &expld
.dataseg
);
6140 expld
.dataseg
.relro
= exp_seg_relro_none
;
6142 /* This symbol may be relative to this section. */
6143 if ((tree
->type
.node_class
== etree_provided
6144 || tree
->type
.node_class
== etree_assign
)
6145 && (tree
->assign
.dst
[0] != '.'
6146 || tree
->assign
.dst
[1] != '\0'))
6147 output_section_statement
->update_dot
= 1;
6149 if (!output_section_statement
->ignored
)
6151 if (output_section_statement
== abs_output_section
)
6153 /* If we don't have an output section, then just adjust
6154 the default memory address. */
6155 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
6156 FALSE
)->current
= newdot
;
6158 else if (newdot
!= dot
)
6160 /* Insert a pad after this statement. We can't
6161 put the pad before when relaxing, in case the
6162 assignment references dot. */
6163 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
6164 output_section_statement
->bfd_section
, dot
);
6166 /* Don't neuter the pad below when relaxing. */
6169 /* If dot is advanced, this implies that the section
6170 should have space allocated to it, unless the
6171 user has explicitly stated that the section
6172 should not be allocated. */
6173 if (output_section_statement
->sectype
!= noalloc_section
6174 && (output_section_statement
->sectype
!= noload_section
6175 || (bfd_get_flavour (link_info
.output_bfd
)
6176 == bfd_target_elf_flavour
)))
6177 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
6184 case lang_padding_statement_enum
:
6185 /* If this is the first time lang_size_sections is called,
6186 we won't have any padding statements. If this is the
6187 second or later passes when relaxing, we should allow
6188 padding to shrink. If padding is needed on this pass, it
6189 will be added back in. */
6190 s
->padding_statement
.size
= 0;
6192 /* Make sure output_offset is valid. If relaxation shrinks
6193 the section and this pad isn't needed, it's possible to
6194 have output_offset larger than the final size of the
6195 section. bfd_set_section_contents will complain even for
6196 a pad size of zero. */
6197 s
->padding_statement
.output_offset
6198 = dot
- output_section_statement
->bfd_section
->vma
;
6201 case lang_group_statement_enum
:
6202 dot
= lang_size_sections_1 (&s
->group_statement
.children
.head
,
6203 output_section_statement
,
6204 fill
, dot
, relax
, check_regions
);
6207 case lang_insert_statement_enum
:
6210 /* We can only get here when relaxing is turned on. */
6211 case lang_address_statement_enum
:
6219 /* If an input section doesn't fit in the current output
6220 section, remove it from the list. Handle the case where we
6221 have to remove an input_section statement here: there is a
6222 special case to remove the first element of the list. */
6223 if (link_info
.non_contiguous_regions
&& removed
)
6225 /* If we removed the first element during the previous
6226 iteration, override the loop assignment of prev_s. */
6232 /* If there was a real previous input section, just skip
6234 prev_s
->header
.next
=s
->header
.next
;
6236 removed_prev_s
= FALSE
;
6240 /* Remove the first input section of the list. */
6241 *prev
= s
->header
.next
;
6242 removed_prev_s
= TRUE
;
6245 /* Move to next element, unless we removed the head of the
6247 if (!removed_prev_s
)
6248 prev
= &s
->header
.next
;
6252 prev
= &s
->header
.next
;
6253 removed_prev_s
= FALSE
;
6259 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
6260 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
6261 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
6262 segments. We are allowed an opportunity to override this decision. */
6265 ldlang_override_segment_assignment (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6266 bfd
*abfd ATTRIBUTE_UNUSED
,
6267 asection
*current_section
,
6268 asection
*previous_section
,
6269 bfd_boolean new_segment
)
6271 lang_output_section_statement_type
*cur
;
6272 lang_output_section_statement_type
*prev
;
6274 /* The checks below are only necessary when the BFD library has decided
6275 that the two sections ought to be placed into the same segment. */
6279 /* Paranoia checks. */
6280 if (current_section
== NULL
|| previous_section
== NULL
)
6283 /* If this flag is set, the target never wants code and non-code
6284 sections comingled in the same segment. */
6285 if (config
.separate_code
6286 && ((current_section
->flags
^ previous_section
->flags
) & SEC_CODE
))
6289 /* Find the memory regions associated with the two sections.
6290 We call lang_output_section_find() here rather than scanning the list
6291 of output sections looking for a matching section pointer because if
6292 we have a large number of sections then a hash lookup is faster. */
6293 cur
= lang_output_section_find (current_section
->name
);
6294 prev
= lang_output_section_find (previous_section
->name
);
6296 /* More paranoia. */
6297 if (cur
== NULL
|| prev
== NULL
)
6300 /* If the regions are different then force the sections to live in
6301 different segments. See the email thread starting at the following
6302 URL for the reasons why this is necessary:
6303 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
6304 return cur
->region
!= prev
->region
;
6308 one_lang_size_sections_pass (bfd_boolean
*relax
, bfd_boolean check_regions
)
6310 lang_statement_iteration
++;
6311 if (expld
.phase
!= lang_mark_phase_enum
)
6312 lang_sizing_iteration
++;
6313 lang_size_sections_1 (&statement_list
.head
, abs_output_section
,
6314 0, 0, relax
, check_regions
);
6318 lang_size_segment (seg_align_type
*seg
)
6320 /* If XXX_SEGMENT_ALIGN XXX_SEGMENT_END pair was seen, check whether
6321 a page could be saved in the data segment. */
6322 bfd_vma first
, last
;
6324 first
= -seg
->base
& (seg
->pagesize
- 1);
6325 last
= seg
->end
& (seg
->pagesize
- 1);
6327 && ((seg
->base
& ~(seg
->pagesize
- 1))
6328 != (seg
->end
& ~(seg
->pagesize
- 1)))
6329 && first
+ last
<= seg
->pagesize
)
6331 seg
->phase
= exp_seg_adjust
;
6335 seg
->phase
= exp_seg_done
;
6340 lang_size_relro_segment_1 (seg_align_type
*seg
)
6342 bfd_vma relro_end
, desired_end
;
6345 /* Compute the expected PT_GNU_RELRO/PT_LOAD segment end. */
6346 relro_end
= ((seg
->relro_end
+ seg
->pagesize
- 1)
6347 & ~(seg
->pagesize
- 1));
6349 /* Adjust by the offset arg of XXX_SEGMENT_RELRO_END. */
6350 desired_end
= relro_end
- seg
->relro_offset
;
6352 /* For sections in the relro segment.. */
6353 for (sec
= link_info
.output_bfd
->section_last
; sec
; sec
= sec
->prev
)
6354 if ((sec
->flags
& SEC_ALLOC
) != 0
6355 && sec
->vma
>= seg
->base
6356 && sec
->vma
< seg
->relro_end
- seg
->relro_offset
)
6358 /* Where do we want to put this section so that it ends as
6360 bfd_vma start
, end
, bump
;
6362 end
= start
= sec
->vma
;
6364 end
+= TO_ADDR (sec
->size
);
6365 bump
= desired_end
- end
;
6366 /* We'd like to increase START by BUMP, but we must heed
6367 alignment so the increase might be less than optimum. */
6369 start
&= ~(((bfd_vma
) 1 << sec
->alignment_power
) - 1);
6370 /* This is now the desired end for the previous section. */
6371 desired_end
= start
;
6374 seg
->phase
= exp_seg_relro_adjust
;
6375 ASSERT (desired_end
>= seg
->base
);
6376 seg
->base
= desired_end
;
6381 lang_size_relro_segment (bfd_boolean
*relax
, bfd_boolean check_regions
)
6383 bfd_boolean do_reset
= FALSE
;
6384 bfd_boolean do_data_relro
;
6385 bfd_vma data_initial_base
, data_relro_end
;
6387 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
6389 do_data_relro
= TRUE
;
6390 data_initial_base
= expld
.dataseg
.base
;
6391 data_relro_end
= lang_size_relro_segment_1 (&expld
.dataseg
);
6395 do_data_relro
= FALSE
;
6396 data_initial_base
= data_relro_end
= 0;
6401 lang_reset_memory_regions ();
6402 one_lang_size_sections_pass (relax
, check_regions
);
6404 /* Assignments to dot, or to output section address in a user
6405 script have increased padding over the original. Revert. */
6406 if (do_data_relro
&& expld
.dataseg
.relro_end
> data_relro_end
)
6408 expld
.dataseg
.base
= data_initial_base
;;
6413 if (!do_data_relro
&& lang_size_segment (&expld
.dataseg
))
6420 lang_size_sections (bfd_boolean
*relax
, bfd_boolean check_regions
)
6422 expld
.phase
= lang_allocating_phase_enum
;
6423 expld
.dataseg
.phase
= exp_seg_none
;
6425 one_lang_size_sections_pass (relax
, check_regions
);
6427 if (expld
.dataseg
.phase
!= exp_seg_end_seen
)
6428 expld
.dataseg
.phase
= exp_seg_done
;
6430 if (expld
.dataseg
.phase
== exp_seg_end_seen
)
6432 bfd_boolean do_reset
6433 = lang_size_relro_segment (relax
, check_regions
);
6437 lang_reset_memory_regions ();
6438 one_lang_size_sections_pass (relax
, check_regions
);
6441 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
6443 link_info
.relro_start
= expld
.dataseg
.base
;
6444 link_info
.relro_end
= expld
.dataseg
.relro_end
;
6449 static lang_output_section_statement_type
*current_section
;
6450 static lang_assignment_statement_type
*current_assign
;
6451 static bfd_boolean prefer_next_section
;
6453 /* Worker function for lang_do_assignments. Recursiveness goes here. */
6456 lang_do_assignments_1 (lang_statement_union_type
*s
,
6457 lang_output_section_statement_type
*current_os
,
6460 bfd_boolean
*found_end
)
6462 for (; s
!= NULL
; s
= s
->header
.next
)
6464 switch (s
->header
.type
)
6466 case lang_constructors_statement_enum
:
6467 dot
= lang_do_assignments_1 (constructor_list
.head
,
6468 current_os
, fill
, dot
, found_end
);
6471 case lang_output_section_statement_enum
:
6473 lang_output_section_statement_type
*os
;
6476 os
= &(s
->output_section_statement
);
6477 os
->after_end
= *found_end
;
6478 init_opb (os
->bfd_section
);
6479 if (os
->bfd_section
!= NULL
&& !os
->ignored
)
6481 if ((os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
6483 current_section
= os
;
6484 prefer_next_section
= FALSE
;
6486 dot
= os
->bfd_section
->vma
;
6488 newdot
= lang_do_assignments_1 (os
->children
.head
,
6489 os
, os
->fill
, dot
, found_end
);
6492 if (os
->bfd_section
!= NULL
)
6494 /* .tbss sections effectively have zero size. */
6495 if (!IS_TBSS (os
->bfd_section
)
6496 || bfd_link_relocatable (&link_info
))
6497 dot
+= TO_ADDR (os
->bfd_section
->size
);
6499 if (os
->update_dot_tree
!= NULL
)
6500 exp_fold_tree (os
->update_dot_tree
,
6501 bfd_abs_section_ptr
, &dot
);
6509 case lang_wild_statement_enum
:
6511 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
6512 current_os
, fill
, dot
, found_end
);
6515 case lang_object_symbols_statement_enum
:
6516 case lang_output_statement_enum
:
6517 case lang_target_statement_enum
:
6520 case lang_data_statement_enum
:
6521 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
6522 if (expld
.result
.valid_p
)
6524 s
->data_statement
.value
= expld
.result
.value
;
6525 if (expld
.result
.section
!= NULL
)
6526 s
->data_statement
.value
+= expld
.result
.section
->vma
;
6528 else if (expld
.phase
== lang_final_phase_enum
)
6529 einfo (_("%F%P: invalid data statement\n"));
6532 switch (s
->data_statement
.type
)
6550 if (size
< TO_SIZE ((unsigned) 1))
6551 size
= TO_SIZE ((unsigned) 1);
6552 dot
+= TO_ADDR (size
);
6556 case lang_reloc_statement_enum
:
6557 exp_fold_tree (s
->reloc_statement
.addend_exp
,
6558 bfd_abs_section_ptr
, &dot
);
6559 if (expld
.result
.valid_p
)
6560 s
->reloc_statement
.addend_value
= expld
.result
.value
;
6561 else if (expld
.phase
== lang_final_phase_enum
)
6562 einfo (_("%F%P: invalid reloc statement\n"));
6563 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
6566 case lang_input_section_enum
:
6568 asection
*in
= s
->input_section
.section
;
6570 if ((in
->flags
& SEC_EXCLUDE
) == 0)
6571 dot
+= TO_ADDR (in
->size
);
6575 case lang_input_statement_enum
:
6578 case lang_fill_statement_enum
:
6579 fill
= s
->fill_statement
.fill
;
6582 case lang_assignment_statement_enum
:
6583 current_assign
= &s
->assignment_statement
;
6584 if (current_assign
->exp
->type
.node_class
!= etree_assert
)
6586 const char *p
= current_assign
->exp
->assign
.dst
;
6588 if (current_os
== abs_output_section
&& p
[0] == '.' && p
[1] == 0)
6589 prefer_next_section
= TRUE
;
6593 if (strcmp (p
, "end") == 0)
6596 exp_fold_tree (s
->assignment_statement
.exp
,
6597 (current_os
->bfd_section
!= NULL
6598 ? current_os
->bfd_section
: bfd_und_section_ptr
),
6602 case lang_padding_statement_enum
:
6603 dot
+= TO_ADDR (s
->padding_statement
.size
);
6606 case lang_group_statement_enum
:
6607 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
6608 current_os
, fill
, dot
, found_end
);
6611 case lang_insert_statement_enum
:
6614 case lang_address_statement_enum
:
6626 lang_do_assignments (lang_phase_type phase
)
6628 bfd_boolean found_end
= FALSE
;
6630 current_section
= NULL
;
6631 prefer_next_section
= FALSE
;
6632 expld
.phase
= phase
;
6633 lang_statement_iteration
++;
6634 lang_do_assignments_1 (statement_list
.head
,
6635 abs_output_section
, NULL
, 0, &found_end
);
6638 /* For an assignment statement outside of an output section statement,
6639 choose the best of neighbouring output sections to use for values
6643 section_for_dot (void)
6647 /* Assignments belong to the previous output section, unless there
6648 has been an assignment to "dot", in which case following
6649 assignments belong to the next output section. (The assumption
6650 is that an assignment to "dot" is setting up the address for the
6651 next output section.) Except that past the assignment to "_end"
6652 we always associate with the previous section. This exception is
6653 for targets like SH that define an alloc .stack or other
6654 weirdness after non-alloc sections. */
6655 if (current_section
== NULL
|| prefer_next_section
)
6657 lang_statement_union_type
*stmt
;
6658 lang_output_section_statement_type
*os
;
6660 for (stmt
= (lang_statement_union_type
*) current_assign
;
6662 stmt
= stmt
->header
.next
)
6663 if (stmt
->header
.type
== lang_output_section_statement_enum
)
6666 os
= &stmt
->output_section_statement
;
6669 && (os
->bfd_section
== NULL
6670 || (os
->bfd_section
->flags
& SEC_EXCLUDE
) != 0
6671 || bfd_section_removed_from_list (link_info
.output_bfd
,
6675 if (current_section
== NULL
|| os
== NULL
|| !os
->after_end
)
6678 s
= os
->bfd_section
;
6680 s
= link_info
.output_bfd
->section_last
;
6682 && ((s
->flags
& SEC_ALLOC
) == 0
6683 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6688 return bfd_abs_section_ptr
;
6692 s
= current_section
->bfd_section
;
6694 /* The section may have been stripped. */
6696 && ((s
->flags
& SEC_EXCLUDE
) != 0
6697 || (s
->flags
& SEC_ALLOC
) == 0
6698 || (s
->flags
& SEC_THREAD_LOCAL
) != 0
6699 || bfd_section_removed_from_list (link_info
.output_bfd
, s
)))
6702 s
= link_info
.output_bfd
->sections
;
6704 && ((s
->flags
& SEC_ALLOC
) == 0
6705 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6710 return bfd_abs_section_ptr
;
6713 /* Array of __start/__stop/.startof./.sizeof/ symbols. */
6715 static struct bfd_link_hash_entry
**start_stop_syms
;
6716 static size_t start_stop_count
= 0;
6717 static size_t start_stop_alloc
= 0;
6719 /* Give start/stop SYMBOL for SEC a preliminary definition, and add it
6720 to start_stop_syms. */
6723 lang_define_start_stop (const char *symbol
, asection
*sec
)
6725 struct bfd_link_hash_entry
*h
;
6727 h
= bfd_define_start_stop (link_info
.output_bfd
, &link_info
, symbol
, sec
);
6730 if (start_stop_count
== start_stop_alloc
)
6732 start_stop_alloc
= 2 * start_stop_alloc
+ 10;
6734 = xrealloc (start_stop_syms
,
6735 start_stop_alloc
* sizeof (*start_stop_syms
));
6737 start_stop_syms
[start_stop_count
++] = h
;
6741 /* Check for input sections whose names match references to
6742 __start_SECNAME or __stop_SECNAME symbols. Give the symbols
6743 preliminary definitions. */
6746 lang_init_start_stop (void)
6750 char leading_char
= bfd_get_symbol_leading_char (link_info
.output_bfd
);
6752 for (abfd
= link_info
.input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6753 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6756 const char *secname
= s
->name
;
6758 for (ps
= secname
; *ps
!= '\0'; ps
++)
6759 if (!ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
6763 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6765 symbol
[0] = leading_char
;
6766 sprintf (symbol
+ (leading_char
!= 0), "__start_%s", secname
);
6767 lang_define_start_stop (symbol
, s
);
6769 symbol
[1] = leading_char
;
6770 memcpy (symbol
+ 1 + (leading_char
!= 0), "__stop", 6);
6771 lang_define_start_stop (symbol
+ 1, s
);
6778 /* Iterate over start_stop_syms. */
6781 foreach_start_stop (void (*func
) (struct bfd_link_hash_entry
*))
6785 for (i
= 0; i
< start_stop_count
; ++i
)
6786 func (start_stop_syms
[i
]);
6789 /* __start and __stop symbols are only supposed to be defined by the
6790 linker for orphan sections, but we now extend that to sections that
6791 map to an output section of the same name. The symbols were
6792 defined early for --gc-sections, before we mapped input to output
6793 sections, so undo those that don't satisfy this rule. */
6796 undef_start_stop (struct bfd_link_hash_entry
*h
)
6798 if (h
->ldscript_def
)
6801 if (h
->u
.def
.section
->output_section
== NULL
6802 || h
->u
.def
.section
->output_section
->owner
!= link_info
.output_bfd
6803 || strcmp (h
->u
.def
.section
->name
,
6804 h
->u
.def
.section
->output_section
->name
) != 0)
6806 asection
*sec
= bfd_get_section_by_name (link_info
.output_bfd
,
6807 h
->u
.def
.section
->name
);
6810 /* When there are more than one input sections with the same
6811 section name, SECNAME, linker picks the first one to define
6812 __start_SECNAME and __stop_SECNAME symbols. When the first
6813 input section is removed by comdat group, we need to check
6814 if there is still an output section with section name
6817 for (i
= sec
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
6818 if (strcmp (h
->u
.def
.section
->name
, i
->name
) == 0)
6820 h
->u
.def
.section
= i
;
6824 h
->type
= bfd_link_hash_undefined
;
6825 h
->u
.undef
.abfd
= NULL
;
6826 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
6828 const struct elf_backend_data
*bed
;
6829 struct elf_link_hash_entry
*eh
= (struct elf_link_hash_entry
*) h
;
6830 unsigned int was_forced
= eh
->forced_local
;
6832 bed
= get_elf_backend_data (link_info
.output_bfd
);
6833 (*bed
->elf_backend_hide_symbol
) (&link_info
, eh
, TRUE
);
6834 if (!eh
->ref_regular_nonweak
)
6835 h
->type
= bfd_link_hash_undefweak
;
6836 eh
->def_regular
= 0;
6837 eh
->forced_local
= was_forced
;
6843 lang_undef_start_stop (void)
6845 foreach_start_stop (undef_start_stop
);
6848 /* Check for output sections whose names match references to
6849 .startof.SECNAME or .sizeof.SECNAME symbols. Give the symbols
6850 preliminary definitions. */
6853 lang_init_startof_sizeof (void)
6857 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6859 const char *secname
= s
->name
;
6860 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6862 sprintf (symbol
, ".startof.%s", secname
);
6863 lang_define_start_stop (symbol
, s
);
6865 memcpy (symbol
+ 1, ".size", 5);
6866 lang_define_start_stop (symbol
+ 1, s
);
6871 /* Set .startof., .sizeof., __start and __stop symbols final values. */
6874 set_start_stop (struct bfd_link_hash_entry
*h
)
6877 || h
->type
!= bfd_link_hash_defined
)
6880 if (h
->root
.string
[0] == '.')
6882 /* .startof. or .sizeof. symbol.
6883 .startof. already has final value. */
6884 if (h
->root
.string
[2] == 'i')
6887 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6888 h
->u
.def
.section
= bfd_abs_section_ptr
;
6893 /* __start or __stop symbol. */
6894 int has_lead
= bfd_get_symbol_leading_char (link_info
.output_bfd
) != 0;
6896 h
->u
.def
.section
= h
->u
.def
.section
->output_section
;
6897 if (h
->root
.string
[4 + has_lead
] == 'o')
6900 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6906 lang_finalize_start_stop (void)
6908 foreach_start_stop (set_start_stop
);
6914 struct bfd_link_hash_entry
*h
;
6917 if ((bfd_link_relocatable (&link_info
) && !link_info
.gc_sections
)
6918 || bfd_link_dll (&link_info
))
6919 warn
= entry_from_cmdline
;
6923 /* Force the user to specify a root when generating a relocatable with
6924 --gc-sections, unless --gc-keep-exported was also given. */
6925 if (bfd_link_relocatable (&link_info
)
6926 && link_info
.gc_sections
6927 && !link_info
.gc_keep_exported
)
6929 struct bfd_sym_chain
*sym
;
6931 for (sym
= link_info
.gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
6933 h
= bfd_link_hash_lookup (link_info
.hash
, sym
->name
,
6934 FALSE
, FALSE
, FALSE
);
6936 && (h
->type
== bfd_link_hash_defined
6937 || h
->type
== bfd_link_hash_defweak
)
6938 && !bfd_is_const_section (h
->u
.def
.section
))
6942 einfo (_("%F%P: --gc-sections requires a defined symbol root "
6943 "specified by -e or -u\n"));
6946 if (entry_symbol
.name
== NULL
)
6948 /* No entry has been specified. Look for the default entry, but
6949 don't warn if we don't find it. */
6950 entry_symbol
.name
= entry_symbol_default
;
6954 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
6955 FALSE
, FALSE
, TRUE
);
6957 && (h
->type
== bfd_link_hash_defined
6958 || h
->type
== bfd_link_hash_defweak
)
6959 && h
->u
.def
.section
->output_section
!= NULL
)
6963 val
= (h
->u
.def
.value
6964 + bfd_section_vma (h
->u
.def
.section
->output_section
)
6965 + h
->u
.def
.section
->output_offset
);
6966 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6967 einfo (_("%F%P: %s: can't set start address\n"), entry_symbol
.name
);
6974 /* We couldn't find the entry symbol. Try parsing it as a
6976 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
6979 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6980 einfo (_("%F%P: can't set start address\n"));
6986 /* Can't find the entry symbol, and it's not a number. Use
6987 the first address in the text section. */
6988 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
6992 einfo (_("%P: warning: cannot find entry symbol %s;"
6993 " defaulting to %V\n"),
6995 bfd_section_vma (ts
));
6996 if (!bfd_set_start_address (link_info
.output_bfd
,
6997 bfd_section_vma (ts
)))
6998 einfo (_("%F%P: can't set start address\n"));
7003 einfo (_("%P: warning: cannot find entry symbol %s;"
7004 " not setting start address\n"),
7011 /* This is a small function used when we want to ignore errors from
7015 ignore_bfd_errors (const char *fmt ATTRIBUTE_UNUSED
,
7016 va_list ap ATTRIBUTE_UNUSED
)
7018 /* Don't do anything. */
7021 /* Check that the architecture of all the input files is compatible
7022 with the output file. Also call the backend to let it do any
7023 other checking that is needed. */
7028 lang_input_statement_type
*file
;
7030 const bfd_arch_info_type
*compatible
;
7032 for (file
= (void *) file_chain
.head
;
7036 #if BFD_SUPPORTS_PLUGINS
7037 /* Don't check format of files claimed by plugin. */
7038 if (file
->flags
.claimed
)
7040 #endif /* BFD_SUPPORTS_PLUGINS */
7041 input_bfd
= file
->the_bfd
;
7043 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
7044 command_line
.accept_unknown_input_arch
);
7046 /* In general it is not possible to perform a relocatable
7047 link between differing object formats when the input
7048 file has relocations, because the relocations in the
7049 input format may not have equivalent representations in
7050 the output format (and besides BFD does not translate
7051 relocs for other link purposes than a final link). */
7052 if (!file
->flags
.just_syms
7053 && (bfd_link_relocatable (&link_info
)
7054 || link_info
.emitrelocations
)
7055 && (compatible
== NULL
7056 || (bfd_get_flavour (input_bfd
)
7057 != bfd_get_flavour (link_info
.output_bfd
)))
7058 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
7060 einfo (_("%F%P: relocatable linking with relocations from"
7061 " format %s (%pB) to format %s (%pB) is not supported\n"),
7062 bfd_get_target (input_bfd
), input_bfd
,
7063 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
7064 /* einfo with %F exits. */
7067 if (compatible
== NULL
)
7069 if (command_line
.warn_mismatch
)
7070 einfo (_("%X%P: %s architecture of input file `%pB'"
7071 " is incompatible with %s output\n"),
7072 bfd_printable_name (input_bfd
), input_bfd
,
7073 bfd_printable_name (link_info
.output_bfd
));
7076 /* If the input bfd has no contents, it shouldn't set the
7077 private data of the output bfd. */
7078 else if (!file
->flags
.just_syms
7079 && ((input_bfd
->flags
& DYNAMIC
) != 0
7080 || bfd_count_sections (input_bfd
) != 0))
7082 bfd_error_handler_type pfn
= NULL
;
7084 /* If we aren't supposed to warn about mismatched input
7085 files, temporarily set the BFD error handler to a
7086 function which will do nothing. We still want to call
7087 bfd_merge_private_bfd_data, since it may set up
7088 information which is needed in the output file. */
7089 if (!command_line
.warn_mismatch
)
7090 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
7091 if (!bfd_merge_private_bfd_data (input_bfd
, &link_info
))
7093 if (command_line
.warn_mismatch
)
7094 einfo (_("%X%P: failed to merge target specific data"
7095 " of file %pB\n"), input_bfd
);
7097 if (!command_line
.warn_mismatch
)
7098 bfd_set_error_handler (pfn
);
7103 /* Look through all the global common symbols and attach them to the
7104 correct section. The -sort-common command line switch may be used
7105 to roughly sort the entries by alignment. */
7110 if (link_info
.inhibit_common_definition
)
7112 if (bfd_link_relocatable (&link_info
)
7113 && !command_line
.force_common_definition
)
7116 if (!config
.sort_common
)
7117 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
7122 if (config
.sort_common
== sort_descending
)
7124 for (power
= 4; power
> 0; power
--)
7125 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7128 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7132 for (power
= 0; power
<= 4; power
++)
7133 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7135 power
= (unsigned int) -1;
7136 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
7141 /* Place one common symbol in the correct section. */
7144 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
7146 unsigned int power_of_two
;
7150 if (h
->type
!= bfd_link_hash_common
)
7154 power_of_two
= h
->u
.c
.p
->alignment_power
;
7156 if (config
.sort_common
== sort_descending
7157 && power_of_two
< *(unsigned int *) info
)
7159 else if (config
.sort_common
== sort_ascending
7160 && power_of_two
> *(unsigned int *) info
)
7163 section
= h
->u
.c
.p
->section
;
7164 if (!bfd_define_common_symbol (link_info
.output_bfd
, &link_info
, h
))
7165 einfo (_("%F%P: could not define common symbol `%pT': %E\n"),
7168 if (config
.map_file
!= NULL
)
7170 static bfd_boolean header_printed
;
7175 if (!header_printed
)
7177 minfo (_("\nAllocating common symbols\n"));
7178 minfo (_("Common symbol size file\n\n"));
7179 header_printed
= TRUE
;
7182 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
7183 DMGL_ANSI
| DMGL_PARAMS
);
7186 minfo ("%s", h
->root
.string
);
7187 len
= strlen (h
->root
.string
);
7192 len
= strlen (name
);
7208 if (size
<= 0xffffffff)
7209 sprintf (buf
, "%lx", (unsigned long) size
);
7211 sprintf_vma (buf
, size
);
7221 minfo ("%pB\n", section
->owner
);
7227 /* Handle a single orphan section S, placing the orphan into an appropriate
7228 output section. The effects of the --orphan-handling command line
7229 option are handled here. */
7232 ldlang_place_orphan (asection
*s
)
7234 if (config
.orphan_handling
== orphan_handling_discard
)
7236 lang_output_section_statement_type
*os
;
7237 os
= lang_output_section_statement_lookup (DISCARD_SECTION_NAME
, 0, 1);
7238 if (os
->addr_tree
== NULL
7239 && (bfd_link_relocatable (&link_info
)
7240 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
7241 os
->addr_tree
= exp_intop (0);
7242 lang_add_section (&os
->children
, s
, NULL
, NULL
, os
);
7246 lang_output_section_statement_type
*os
;
7247 const char *name
= s
->name
;
7250 if (config
.orphan_handling
== orphan_handling_error
)
7251 einfo (_("%X%P: error: unplaced orphan section `%pA' from `%pB'\n"),
7254 if (config
.unique_orphan_sections
|| unique_section_p (s
, NULL
))
7255 constraint
= SPECIAL
;
7257 os
= ldemul_place_orphan (s
, name
, constraint
);
7260 os
= lang_output_section_statement_lookup (name
, constraint
, 1);
7261 if (os
->addr_tree
== NULL
7262 && (bfd_link_relocatable (&link_info
)
7263 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
7264 os
->addr_tree
= exp_intop (0);
7265 lang_add_section (&os
->children
, s
, NULL
, NULL
, os
);
7268 if (config
.orphan_handling
== orphan_handling_warn
)
7269 einfo (_("%P: warning: orphan section `%pA' from `%pB' being "
7270 "placed in section `%s'\n"),
7271 s
, s
->owner
, os
->name
);
7275 /* Run through the input files and ensure that every input section has
7276 somewhere to go. If one is found without a destination then create
7277 an input request and place it into the statement tree. */
7280 lang_place_orphans (void)
7282 LANG_FOR_EACH_INPUT_STATEMENT (file
)
7286 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
7288 if (s
->output_section
== NULL
)
7290 /* This section of the file is not attached, root
7291 around for a sensible place for it to go. */
7293 if (file
->flags
.just_syms
)
7294 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
7295 else if (lang_discard_section_p (s
))
7296 s
->output_section
= bfd_abs_section_ptr
;
7297 else if (strcmp (s
->name
, "COMMON") == 0)
7299 /* This is a lonely common section which must have
7300 come from an archive. We attach to the section
7301 with the wildcard. */
7302 if (!bfd_link_relocatable (&link_info
)
7303 || command_line
.force_common_definition
)
7305 if (default_common_section
== NULL
)
7306 default_common_section
7307 = lang_output_section_statement_lookup (".bss", 0, 1);
7308 lang_add_section (&default_common_section
->children
, s
,
7309 NULL
, NULL
, default_common_section
);
7313 ldlang_place_orphan (s
);
7320 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
7322 flagword
*ptr_flags
;
7324 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
7330 /* PR 17900: An exclamation mark in the attributes reverses
7331 the sense of any of the attributes that follow. */
7334 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
7338 *ptr_flags
|= SEC_ALLOC
;
7342 *ptr_flags
|= SEC_READONLY
;
7346 *ptr_flags
|= SEC_DATA
;
7350 *ptr_flags
|= SEC_CODE
;
7355 *ptr_flags
|= SEC_LOAD
;
7359 einfo (_("%F%P: invalid character %c (%d) in flags\n"),
7367 /* Call a function on each real input file. This function will be
7368 called on an archive, but not on the elements. */
7371 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
7373 lang_input_statement_type
*f
;
7375 for (f
= (void *) input_file_chain
.head
;
7377 f
= f
->next_real_file
)
7382 /* Call a function on each real file. The function will be called on
7383 all the elements of an archive which are included in the link, but
7384 will not be called on the archive file itself. */
7387 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
7389 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7397 ldlang_add_file (lang_input_statement_type
*entry
)
7399 lang_statement_append (&file_chain
, entry
, &entry
->next
);
7401 /* The BFD linker needs to have a list of all input BFDs involved in
7403 ASSERT (link_info
.input_bfds_tail
!= &entry
->the_bfd
->link
.next
7404 && entry
->the_bfd
->link
.next
== NULL
);
7405 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
7407 *link_info
.input_bfds_tail
= entry
->the_bfd
;
7408 link_info
.input_bfds_tail
= &entry
->the_bfd
->link
.next
;
7409 bfd_set_usrdata (entry
->the_bfd
, entry
);
7410 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
7412 /* Look through the sections and check for any which should not be
7413 included in the link. We need to do this now, so that we can
7414 notice when the backend linker tries to report multiple
7415 definition errors for symbols which are in sections we aren't
7416 going to link. FIXME: It might be better to entirely ignore
7417 symbols which are defined in sections which are going to be
7418 discarded. This would require modifying the backend linker for
7419 each backend which might set the SEC_LINK_ONCE flag. If we do
7420 this, we should probably handle SEC_EXCLUDE in the same way. */
7422 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
7426 lang_add_output (const char *name
, int from_script
)
7428 /* Make -o on command line override OUTPUT in script. */
7429 if (!had_output_filename
|| !from_script
)
7431 output_filename
= name
;
7432 had_output_filename
= TRUE
;
7436 lang_output_section_statement_type
*
7437 lang_enter_output_section_statement (const char *output_section_statement_name
,
7438 etree_type
*address_exp
,
7439 enum section_type sectype
,
7441 etree_type
*subalign
,
7444 int align_with_input
)
7446 lang_output_section_statement_type
*os
;
7448 os
= lang_output_section_statement_lookup (output_section_statement_name
,
7450 current_section
= os
;
7452 if (os
->addr_tree
== NULL
)
7454 os
->addr_tree
= address_exp
;
7456 os
->sectype
= sectype
;
7457 if (sectype
!= noload_section
)
7458 os
->flags
= SEC_NO_FLAGS
;
7460 os
->flags
= SEC_NEVER_LOAD
;
7461 os
->block_value
= 1;
7463 /* Make next things chain into subchain of this. */
7464 push_stat_ptr (&os
->children
);
7466 os
->align_lma_with_input
= align_with_input
== ALIGN_WITH_INPUT
;
7467 if (os
->align_lma_with_input
&& align
!= NULL
)
7468 einfo (_("%F%P:%pS: error: align with input and explicit align specified\n"),
7471 os
->subsection_alignment
= subalign
;
7472 os
->section_alignment
= align
;
7474 os
->load_base
= ebase
;
7481 lang_output_statement_type
*new_stmt
;
7483 new_stmt
= new_stat (lang_output_statement
, stat_ptr
);
7484 new_stmt
->name
= output_filename
;
7487 /* Reset the current counters in the regions. */
7490 lang_reset_memory_regions (void)
7492 lang_memory_region_type
*p
= lang_memory_region_list
;
7494 lang_output_section_statement_type
*os
;
7496 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
7498 p
->current
= p
->origin
;
7502 for (os
= (void *) lang_os_list
.head
;
7506 os
->processed_vma
= FALSE
;
7507 os
->processed_lma
= FALSE
;
7510 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
7512 /* Save the last size for possible use by bfd_relax_section. */
7513 o
->rawsize
= o
->size
;
7514 if (!(o
->flags
& SEC_FIXED_SIZE
))
7519 /* Worker for lang_gc_sections_1. */
7522 gc_section_callback (lang_wild_statement_type
*ptr
,
7523 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7525 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7526 void *data ATTRIBUTE_UNUSED
)
7528 /* If the wild pattern was marked KEEP, the member sections
7529 should be as well. */
7530 if (ptr
->keep_sections
)
7531 section
->flags
|= SEC_KEEP
;
7534 /* Iterate over sections marking them against GC. */
7537 lang_gc_sections_1 (lang_statement_union_type
*s
)
7539 for (; s
!= NULL
; s
= s
->header
.next
)
7541 switch (s
->header
.type
)
7543 case lang_wild_statement_enum
:
7544 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
7546 case lang_constructors_statement_enum
:
7547 lang_gc_sections_1 (constructor_list
.head
);
7549 case lang_output_section_statement_enum
:
7550 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
7552 case lang_group_statement_enum
:
7553 lang_gc_sections_1 (s
->group_statement
.children
.head
);
7562 lang_gc_sections (void)
7564 /* Keep all sections so marked in the link script. */
7565 lang_gc_sections_1 (statement_list
.head
);
7567 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
7568 the special case of .stabstr debug info. (See bfd/stabs.c)
7569 Twiddle the flag here, to simplify later linker code. */
7570 if (bfd_link_relocatable (&link_info
))
7572 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7575 #if BFD_SUPPORTS_PLUGINS
7576 if (f
->flags
.claimed
)
7579 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7580 if ((sec
->flags
& SEC_DEBUGGING
) == 0
7581 || strcmp (sec
->name
, ".stabstr") != 0)
7582 sec
->flags
&= ~SEC_EXCLUDE
;
7586 if (link_info
.gc_sections
)
7587 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
7590 /* Worker for lang_find_relro_sections_1. */
7593 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
7594 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7596 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7599 /* Discarded, excluded and ignored sections effectively have zero
7601 if (section
->output_section
!= NULL
7602 && section
->output_section
->owner
== link_info
.output_bfd
7603 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
7604 && !IGNORE_SECTION (section
)
7605 && section
->size
!= 0)
7607 bfd_boolean
*has_relro_section
= (bfd_boolean
*) data
;
7608 *has_relro_section
= TRUE
;
7612 /* Iterate over sections for relro sections. */
7615 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
7616 seg_align_type
*seg
,
7617 bfd_boolean
*has_relro_section
)
7619 if (*has_relro_section
)
7622 for (; s
!= NULL
; s
= s
->header
.next
)
7624 if (s
== seg
->relro_end_stat
)
7627 switch (s
->header
.type
)
7629 case lang_wild_statement_enum
:
7630 walk_wild (&s
->wild_statement
,
7631 find_relro_section_callback
,
7634 case lang_constructors_statement_enum
:
7635 lang_find_relro_sections_1 (constructor_list
.head
,
7636 seg
, has_relro_section
);
7638 case lang_output_section_statement_enum
:
7639 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
7640 seg
, has_relro_section
);
7642 case lang_group_statement_enum
:
7643 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
7644 seg
, has_relro_section
);
7653 lang_find_relro_sections (void)
7655 bfd_boolean has_relro_section
= FALSE
;
7657 /* Check all sections in the link script. */
7659 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
7660 &expld
.dataseg
, &has_relro_section
);
7662 if (!has_relro_section
)
7663 link_info
.relro
= FALSE
;
7666 /* Relax all sections until bfd_relax_section gives up. */
7669 lang_relax_sections (bfd_boolean need_layout
)
7671 if (RELAXATION_ENABLED
)
7673 /* We may need more than one relaxation pass. */
7674 int i
= link_info
.relax_pass
;
7676 /* The backend can use it to determine the current pass. */
7677 link_info
.relax_pass
= 0;
7681 /* Keep relaxing until bfd_relax_section gives up. */
7682 bfd_boolean relax_again
;
7684 link_info
.relax_trip
= -1;
7687 link_info
.relax_trip
++;
7689 /* Note: pe-dll.c does something like this also. If you find
7690 you need to change this code, you probably need to change
7691 pe-dll.c also. DJ */
7693 /* Do all the assignments with our current guesses as to
7695 lang_do_assignments (lang_assigning_phase_enum
);
7697 /* We must do this after lang_do_assignments, because it uses
7699 lang_reset_memory_regions ();
7701 /* Perform another relax pass - this time we know where the
7702 globals are, so can make a better guess. */
7703 relax_again
= FALSE
;
7704 lang_size_sections (&relax_again
, FALSE
);
7706 while (relax_again
);
7708 link_info
.relax_pass
++;
7715 /* Final extra sizing to report errors. */
7716 lang_do_assignments (lang_assigning_phase_enum
);
7717 lang_reset_memory_regions ();
7718 lang_size_sections (NULL
, TRUE
);
7722 #if BFD_SUPPORTS_PLUGINS
7723 /* Find the insert point for the plugin's replacement files. We
7724 place them after the first claimed real object file, or if the
7725 first claimed object is an archive member, after the last real
7726 object file immediately preceding the archive. In the event
7727 no objects have been claimed at all, we return the first dummy
7728 object file on the list as the insert point; that works, but
7729 the callee must be careful when relinking the file_chain as it
7730 is not actually on that chain, only the statement_list and the
7731 input_file list; in that case, the replacement files must be
7732 inserted at the head of the file_chain. */
7734 static lang_input_statement_type
*
7735 find_replacements_insert_point (bfd_boolean
*before
)
7737 lang_input_statement_type
*claim1
, *lastobject
;
7738 lastobject
= (void *) input_file_chain
.head
;
7739 for (claim1
= (void *) file_chain
.head
;
7741 claim1
= claim1
->next
)
7743 if (claim1
->flags
.claimed
)
7745 *before
= claim1
->flags
.claim_archive
;
7746 return claim1
->flags
.claim_archive
? lastobject
: claim1
;
7748 /* Update lastobject if this is a real object file. */
7749 if (claim1
->the_bfd
!= NULL
&& claim1
->the_bfd
->my_archive
== NULL
)
7750 lastobject
= claim1
;
7752 /* No files were claimed by the plugin. Choose the last object
7753 file found on the list (maybe the first, dummy entry) as the
7759 /* Find where to insert ADD, an archive element or shared library
7760 added during a rescan. */
7762 static lang_input_statement_type
**
7763 find_rescan_insertion (lang_input_statement_type
*add
)
7765 bfd
*add_bfd
= add
->the_bfd
;
7766 lang_input_statement_type
*f
;
7767 lang_input_statement_type
*last_loaded
= NULL
;
7768 lang_input_statement_type
*before
= NULL
;
7769 lang_input_statement_type
**iter
= NULL
;
7771 if (add_bfd
->my_archive
!= NULL
)
7772 add_bfd
= add_bfd
->my_archive
;
7774 /* First look through the input file chain, to find an object file
7775 before the one we've rescanned. Normal object files always
7776 appear on both the input file chain and the file chain, so this
7777 lets us get quickly to somewhere near the correct place on the
7778 file chain if it is full of archive elements. Archives don't
7779 appear on the file chain, but if an element has been extracted
7780 then their input_statement->next points at it. */
7781 for (f
= (void *) input_file_chain
.head
;
7783 f
= f
->next_real_file
)
7785 if (f
->the_bfd
== add_bfd
)
7787 before
= last_loaded
;
7788 if (f
->next
!= NULL
)
7789 return &f
->next
->next
;
7791 if (f
->the_bfd
!= NULL
&& f
->next
!= NULL
)
7795 for (iter
= before
? &before
->next
: &file_chain
.head
->input_statement
.next
;
7797 iter
= &(*iter
)->next
)
7798 if (!(*iter
)->flags
.claim_archive
7799 && (*iter
)->the_bfd
->my_archive
== NULL
)
7805 /* Insert SRCLIST into DESTLIST after given element by chaining
7806 on FIELD as the next-pointer. (Counterintuitively does not need
7807 a pointer to the actual after-node itself, just its chain field.) */
7810 lang_list_insert_after (lang_statement_list_type
*destlist
,
7811 lang_statement_list_type
*srclist
,
7812 lang_statement_union_type
**field
)
7814 *(srclist
->tail
) = *field
;
7815 *field
= srclist
->head
;
7816 if (destlist
->tail
== field
)
7817 destlist
->tail
= srclist
->tail
;
7820 /* Detach new nodes added to DESTLIST since the time ORIGLIST
7821 was taken as a copy of it and leave them in ORIGLIST. */
7824 lang_list_remove_tail (lang_statement_list_type
*destlist
,
7825 lang_statement_list_type
*origlist
)
7827 union lang_statement_union
**savetail
;
7828 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
7829 ASSERT (origlist
->head
== destlist
->head
);
7830 savetail
= origlist
->tail
;
7831 origlist
->head
= *(savetail
);
7832 origlist
->tail
= destlist
->tail
;
7833 destlist
->tail
= savetail
;
7837 static lang_statement_union_type
**
7838 find_next_input_statement (lang_statement_union_type
**s
)
7840 for ( ; *s
; s
= &(*s
)->header
.next
)
7842 lang_statement_union_type
**t
;
7843 switch ((*s
)->header
.type
)
7845 case lang_input_statement_enum
:
7847 case lang_wild_statement_enum
:
7848 t
= &(*s
)->wild_statement
.children
.head
;
7850 case lang_group_statement_enum
:
7851 t
= &(*s
)->group_statement
.children
.head
;
7853 case lang_output_section_statement_enum
:
7854 t
= &(*s
)->output_section_statement
.children
.head
;
7859 t
= find_next_input_statement (t
);
7865 #endif /* BFD_SUPPORTS_PLUGINS */
7867 /* Add NAME to the list of garbage collection entry points. */
7870 lang_add_gc_name (const char *name
)
7872 struct bfd_sym_chain
*sym
;
7877 sym
= stat_alloc (sizeof (*sym
));
7879 sym
->next
= link_info
.gc_sym_list
;
7881 link_info
.gc_sym_list
= sym
;
7884 /* Check relocations. */
7887 lang_check_relocs (void)
7889 if (link_info
.check_relocs_after_open_input
)
7893 for (abfd
= link_info
.input_bfds
;
7894 abfd
!= (bfd
*) NULL
; abfd
= abfd
->link
.next
)
7895 if (!bfd_link_check_relocs (abfd
, &link_info
))
7897 /* No object output, fail return. */
7898 config
.make_executable
= FALSE
;
7899 /* Note: we do not abort the loop, but rather
7900 continue the scan in case there are other
7901 bad relocations to report. */
7906 /* Look through all output sections looking for places where we can
7907 propagate forward the lma region. */
7910 lang_propagate_lma_regions (void)
7912 lang_output_section_statement_type
*os
;
7914 for (os
= (void *) lang_os_list
.head
;
7918 if (os
->prev
!= NULL
7919 && os
->lma_region
== NULL
7920 && os
->load_base
== NULL
7921 && os
->addr_tree
== NULL
7922 && os
->region
== os
->prev
->region
)
7923 os
->lma_region
= os
->prev
->lma_region
;
7930 /* Finalize dynamic list. */
7931 if (link_info
.dynamic_list
)
7932 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
7934 current_target
= default_target
;
7936 /* Open the output file. */
7937 lang_for_each_statement (ldlang_open_output
);
7940 ldemul_create_output_section_statements ();
7942 /* Add to the hash table all undefineds on the command line. */
7943 lang_place_undefineds ();
7945 if (!bfd_section_already_linked_table_init ())
7946 einfo (_("%F%P: can not create hash table: %E\n"));
7948 /* A first pass through the memory regions ensures that if any region
7949 references a symbol for its origin or length then this symbol will be
7950 added to the symbol table. Having these symbols in the symbol table
7951 means that when we call open_input_bfds PROVIDE statements will
7952 trigger to provide any needed symbols. The regions origins and
7953 lengths are not assigned as a result of this call. */
7954 lang_do_memory_regions (FALSE
);
7956 /* Create a bfd for each input file. */
7957 current_target
= default_target
;
7958 lang_statement_iteration
++;
7959 open_input_bfds (statement_list
.head
, OPEN_BFD_NORMAL
);
7961 /* Now that open_input_bfds has processed assignments and provide
7962 statements we can give values to symbolic origin/length now. */
7963 lang_do_memory_regions (TRUE
);
7965 #if BFD_SUPPORTS_PLUGINS
7966 if (link_info
.lto_plugin_active
)
7968 lang_statement_list_type added
;
7969 lang_statement_list_type files
, inputfiles
;
7971 /* Now all files are read, let the plugin(s) decide if there
7972 are any more to be added to the link before we call the
7973 emulation's after_open hook. We create a private list of
7974 input statements for this purpose, which we will eventually
7975 insert into the global statement list after the first claimed
7978 /* We need to manipulate all three chains in synchrony. */
7980 inputfiles
= input_file_chain
;
7981 if (plugin_call_all_symbols_read ())
7982 einfo (_("%F%P: %s: plugin reported error after all symbols read\n"),
7983 plugin_error_plugin ());
7984 link_info
.lto_all_symbols_read
= TRUE
;
7985 /* Open any newly added files, updating the file chains. */
7986 plugin_undefs
= link_info
.hash
->undefs_tail
;
7987 open_input_bfds (*added
.tail
, OPEN_BFD_NORMAL
);
7988 if (plugin_undefs
== link_info
.hash
->undefs_tail
)
7989 plugin_undefs
= NULL
;
7990 /* Restore the global list pointer now they have all been added. */
7991 lang_list_remove_tail (stat_ptr
, &added
);
7992 /* And detach the fresh ends of the file lists. */
7993 lang_list_remove_tail (&file_chain
, &files
);
7994 lang_list_remove_tail (&input_file_chain
, &inputfiles
);
7995 /* Were any new files added? */
7996 if (added
.head
!= NULL
)
7998 /* If so, we will insert them into the statement list immediately
7999 after the first input file that was claimed by the plugin,
8000 unless that file was an archive in which case it is inserted
8001 immediately before. */
8003 lang_statement_union_type
**prev
;
8004 plugin_insert
= find_replacements_insert_point (&before
);
8005 /* If a plugin adds input files without having claimed any, we
8006 don't really have a good idea where to place them. Just putting
8007 them at the start or end of the list is liable to leave them
8008 outside the crtbegin...crtend range. */
8009 ASSERT (plugin_insert
!= NULL
);
8010 /* Splice the new statement list into the old one. */
8011 prev
= &plugin_insert
->header
.next
;
8014 prev
= find_next_input_statement (prev
);
8015 if (*prev
!= (void *) plugin_insert
->next_real_file
)
8017 /* We didn't find the expected input statement.
8018 Fall back to adding after plugin_insert. */
8019 prev
= &plugin_insert
->header
.next
;
8022 lang_list_insert_after (stat_ptr
, &added
, prev
);
8023 /* Likewise for the file chains. */
8024 lang_list_insert_after (&input_file_chain
, &inputfiles
,
8025 (void *) &plugin_insert
->next_real_file
);
8026 /* We must be careful when relinking file_chain; we may need to
8027 insert the new files at the head of the list if the insert
8028 point chosen is the dummy first input file. */
8029 if (plugin_insert
->filename
)
8030 lang_list_insert_after (&file_chain
, &files
,
8031 (void *) &plugin_insert
->next
);
8033 lang_list_insert_after (&file_chain
, &files
, &file_chain
.head
);
8035 /* Rescan archives in case new undefined symbols have appeared. */
8037 lang_statement_iteration
++;
8038 open_input_bfds (statement_list
.head
, OPEN_BFD_RESCAN
);
8039 lang_list_remove_tail (&file_chain
, &files
);
8040 while (files
.head
!= NULL
)
8042 lang_input_statement_type
**insert
;
8043 lang_input_statement_type
**iter
, *temp
;
8046 insert
= find_rescan_insertion (&files
.head
->input_statement
);
8047 /* All elements from an archive can be added at once. */
8048 iter
= &files
.head
->input_statement
.next
;
8049 my_arch
= files
.head
->input_statement
.the_bfd
->my_archive
;
8050 if (my_arch
!= NULL
)
8051 for (; *iter
!= NULL
; iter
= &(*iter
)->next
)
8052 if ((*iter
)->the_bfd
->my_archive
!= my_arch
)
8055 *insert
= &files
.head
->input_statement
;
8056 files
.head
= (lang_statement_union_type
*) *iter
;
8058 if (my_arch
!= NULL
)
8060 lang_input_statement_type
*parent
= bfd_usrdata (my_arch
);
8062 parent
->next
= (lang_input_statement_type
*)
8064 - offsetof (lang_input_statement_type
, next
));
8069 #endif /* BFD_SUPPORTS_PLUGINS */
8071 /* Make sure that nobody has tried to add a symbol to this list
8073 ASSERT (link_info
.gc_sym_list
== NULL
);
8075 link_info
.gc_sym_list
= &entry_symbol
;
8077 if (entry_symbol
.name
== NULL
)
8079 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
8081 /* entry_symbol is normally initialied by a ENTRY definition in the
8082 linker script or the -e command line option. But if neither of
8083 these have been used, the target specific backend may still have
8084 provided an entry symbol via a call to lang_default_entry().
8085 Unfortunately this value will not be processed until lang_end()
8086 is called, long after this function has finished. So detect this
8087 case here and add the target's entry symbol to the list of starting
8088 points for garbage collection resolution. */
8089 lang_add_gc_name (entry_symbol_default
);
8092 lang_add_gc_name (link_info
.init_function
);
8093 lang_add_gc_name (link_info
.fini_function
);
8095 ldemul_after_open ();
8096 if (config
.map_file
!= NULL
)
8097 lang_print_asneeded ();
8101 bfd_section_already_linked_table_free ();
8103 /* Make sure that we're not mixing architectures. We call this
8104 after all the input files have been opened, but before we do any
8105 other processing, so that any operations merge_private_bfd_data
8106 does on the output file will be known during the rest of the
8110 /* Handle .exports instead of a version script if we're told to do so. */
8111 if (command_line
.version_exports_section
)
8112 lang_do_version_exports_section ();
8114 /* Build all sets based on the information gathered from the input
8116 ldctor_build_sets ();
8118 /* Give initial values for __start and __stop symbols, so that ELF
8119 gc_sections will keep sections referenced by these symbols. Must
8120 be done before lang_do_assignments below. */
8121 if (config
.build_constructors
)
8122 lang_init_start_stop ();
8124 /* PR 13683: We must rerun the assignments prior to running garbage
8125 collection in order to make sure that all symbol aliases are resolved. */
8126 lang_do_assignments (lang_mark_phase_enum
);
8127 expld
.phase
= lang_first_phase_enum
;
8129 /* Size up the common data. */
8132 /* Remove unreferenced sections if asked to. */
8133 lang_gc_sections ();
8135 lang_mark_undefineds ();
8137 /* Check relocations. */
8138 lang_check_relocs ();
8140 ldemul_after_check_relocs ();
8142 /* Update wild statements. */
8143 update_wild_statements (statement_list
.head
);
8145 /* Run through the contours of the script and attach input sections
8146 to the correct output sections. */
8147 lang_statement_iteration
++;
8148 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
8150 /* Start at the statement immediately after the special abs_section
8151 output statement, so that it isn't reordered. */
8152 process_insert_statements (&lang_os_list
.head
->header
.next
);
8154 ldemul_before_place_orphans ();
8156 /* Find any sections not attached explicitly and handle them. */
8157 lang_place_orphans ();
8159 if (!bfd_link_relocatable (&link_info
))
8163 /* Merge SEC_MERGE sections. This has to be done after GC of
8164 sections, so that GCed sections are not merged, but before
8165 assigning dynamic symbols, since removing whole input sections
8167 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
8169 /* Look for a text section and set the readonly attribute in it. */
8170 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
8174 if (config
.text_read_only
)
8175 found
->flags
|= SEC_READONLY
;
8177 found
->flags
&= ~SEC_READONLY
;
8181 /* Merge together CTF sections. After this, only the symtab-dependent
8182 function and data object sections need adjustment. */
8185 /* Emit the CTF, iff the emulation doesn't need to do late emission after
8186 examining things laid out late, like the strtab. */
8189 /* Copy forward lma regions for output sections in same lma region. */
8190 lang_propagate_lma_regions ();
8192 /* Defining __start/__stop symbols early for --gc-sections to work
8193 around a glibc build problem can result in these symbols being
8194 defined when they should not be. Fix them now. */
8195 if (config
.build_constructors
)
8196 lang_undef_start_stop ();
8198 /* Define .startof./.sizeof. symbols with preliminary values before
8199 dynamic symbols are created. */
8200 if (!bfd_link_relocatable (&link_info
))
8201 lang_init_startof_sizeof ();
8203 /* Do anything special before sizing sections. This is where ELF
8204 and other back-ends size dynamic sections. */
8205 ldemul_before_allocation ();
8207 /* We must record the program headers before we try to fix the
8208 section positions, since they will affect SIZEOF_HEADERS. */
8209 lang_record_phdrs ();
8211 /* Check relro sections. */
8212 if (link_info
.relro
&& !bfd_link_relocatable (&link_info
))
8213 lang_find_relro_sections ();
8215 /* Size up the sections. */
8216 lang_size_sections (NULL
, !RELAXATION_ENABLED
);
8218 /* See if anything special should be done now we know how big
8219 everything is. This is where relaxation is done. */
8220 ldemul_after_allocation ();
8222 /* Fix any __start, __stop, .startof. or .sizeof. symbols. */
8223 lang_finalize_start_stop ();
8225 /* Do all the assignments again, to report errors. Assignment
8226 statements are processed multiple times, updating symbols; In
8227 open_input_bfds, lang_do_assignments, and lang_size_sections.
8228 Since lang_relax_sections calls lang_do_assignments, symbols are
8229 also updated in ldemul_after_allocation. */
8230 lang_do_assignments (lang_final_phase_enum
);
8234 /* Convert absolute symbols to section relative. */
8235 ldexp_finalize_syms ();
8237 /* Make sure that the section addresses make sense. */
8238 if (command_line
.check_section_addresses
)
8239 lang_check_section_addresses ();
8241 /* Check any required symbols are known. */
8242 ldlang_check_require_defined_symbols ();
8247 /* EXPORTED TO YACC */
8250 lang_add_wild (struct wildcard_spec
*filespec
,
8251 struct wildcard_list
*section_list
,
8252 bfd_boolean keep_sections
)
8254 struct wildcard_list
*curr
, *next
;
8255 lang_wild_statement_type
*new_stmt
;
8257 /* Reverse the list as the parser puts it back to front. */
8258 for (curr
= section_list
, section_list
= NULL
;
8260 section_list
= curr
, curr
= next
)
8263 curr
->next
= section_list
;
8266 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
8268 if (strcmp (filespec
->name
, "*") == 0)
8269 filespec
->name
= NULL
;
8270 else if (!wildcardp (filespec
->name
))
8271 lang_has_input_file
= TRUE
;
8274 new_stmt
= new_stat (lang_wild_statement
, stat_ptr
);
8275 new_stmt
->filename
= NULL
;
8276 new_stmt
->filenames_sorted
= FALSE
;
8277 new_stmt
->section_flag_list
= NULL
;
8278 new_stmt
->exclude_name_list
= NULL
;
8279 if (filespec
!= NULL
)
8281 new_stmt
->filename
= filespec
->name
;
8282 new_stmt
->filenames_sorted
= filespec
->sorted
== by_name
;
8283 new_stmt
->section_flag_list
= filespec
->section_flag_list
;
8284 new_stmt
->exclude_name_list
= filespec
->exclude_name_list
;
8286 new_stmt
->section_list
= section_list
;
8287 new_stmt
->keep_sections
= keep_sections
;
8288 lang_list_init (&new_stmt
->children
);
8289 analyze_walk_wild_section_handler (new_stmt
);
8293 lang_section_start (const char *name
, etree_type
*address
,
8294 const segment_type
*segment
)
8296 lang_address_statement_type
*ad
;
8298 ad
= new_stat (lang_address_statement
, stat_ptr
);
8299 ad
->section_name
= name
;
8300 ad
->address
= address
;
8301 ad
->segment
= segment
;
8304 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
8305 because of a -e argument on the command line, or zero if this is
8306 called by ENTRY in a linker script. Command line arguments take
8310 lang_add_entry (const char *name
, bfd_boolean cmdline
)
8312 if (entry_symbol
.name
== NULL
8314 || !entry_from_cmdline
)
8316 entry_symbol
.name
= name
;
8317 entry_from_cmdline
= cmdline
;
8321 /* Set the default start symbol to NAME. .em files should use this,
8322 not lang_add_entry, to override the use of "start" if neither the
8323 linker script nor the command line specifies an entry point. NAME
8324 must be permanently allocated. */
8326 lang_default_entry (const char *name
)
8328 entry_symbol_default
= name
;
8332 lang_add_target (const char *name
)
8334 lang_target_statement_type
*new_stmt
;
8336 new_stmt
= new_stat (lang_target_statement
, stat_ptr
);
8337 new_stmt
->target
= name
;
8341 lang_add_map (const char *name
)
8348 map_option_f
= TRUE
;
8356 lang_add_fill (fill_type
*fill
)
8358 lang_fill_statement_type
*new_stmt
;
8360 new_stmt
= new_stat (lang_fill_statement
, stat_ptr
);
8361 new_stmt
->fill
= fill
;
8365 lang_add_data (int type
, union etree_union
*exp
)
8367 lang_data_statement_type
*new_stmt
;
8369 new_stmt
= new_stat (lang_data_statement
, stat_ptr
);
8370 new_stmt
->exp
= exp
;
8371 new_stmt
->type
= type
;
8374 /* Create a new reloc statement. RELOC is the BFD relocation type to
8375 generate. HOWTO is the corresponding howto structure (we could
8376 look this up, but the caller has already done so). SECTION is the
8377 section to generate a reloc against, or NAME is the name of the
8378 symbol to generate a reloc against. Exactly one of SECTION and
8379 NAME must be NULL. ADDEND is an expression for the addend. */
8382 lang_add_reloc (bfd_reloc_code_real_type reloc
,
8383 reloc_howto_type
*howto
,
8386 union etree_union
*addend
)
8388 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
8392 p
->section
= section
;
8394 p
->addend_exp
= addend
;
8396 p
->addend_value
= 0;
8397 p
->output_section
= NULL
;
8398 p
->output_offset
= 0;
8401 lang_assignment_statement_type
*
8402 lang_add_assignment (etree_type
*exp
)
8404 lang_assignment_statement_type
*new_stmt
;
8406 new_stmt
= new_stat (lang_assignment_statement
, stat_ptr
);
8407 new_stmt
->exp
= exp
;
8412 lang_add_attribute (enum statement_enum attribute
)
8414 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
8418 lang_startup (const char *name
)
8420 if (first_file
->filename
!= NULL
)
8422 einfo (_("%F%P: multiple STARTUP files\n"));
8424 first_file
->filename
= name
;
8425 first_file
->local_sym_name
= name
;
8426 first_file
->flags
.real
= TRUE
;
8430 lang_float (bfd_boolean maybe
)
8432 lang_float_flag
= maybe
;
8436 /* Work out the load- and run-time regions from a script statement, and
8437 store them in *LMA_REGION and *REGION respectively.
8439 MEMSPEC is the name of the run-time region, or the value of
8440 DEFAULT_MEMORY_REGION if the statement didn't specify one.
8441 LMA_MEMSPEC is the name of the load-time region, or null if the
8442 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
8443 had an explicit load address.
8445 It is an error to specify both a load region and a load address. */
8448 lang_get_regions (lang_memory_region_type
**region
,
8449 lang_memory_region_type
**lma_region
,
8450 const char *memspec
,
8451 const char *lma_memspec
,
8452 bfd_boolean have_lma
,
8453 bfd_boolean have_vma
)
8455 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
8457 /* If no runtime region or VMA has been specified, but the load region
8458 has been specified, then use the load region for the runtime region
8460 if (lma_memspec
!= NULL
8462 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
8463 *region
= *lma_region
;
8465 *region
= lang_memory_region_lookup (memspec
, FALSE
);
8467 if (have_lma
&& lma_memspec
!= 0)
8468 einfo (_("%X%P:%pS: section has both a load address and a load region\n"),
8473 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
8474 lang_output_section_phdr_list
*phdrs
,
8475 const char *lma_memspec
)
8477 lang_get_regions (¤t_section
->region
,
8478 ¤t_section
->lma_region
,
8479 memspec
, lma_memspec
,
8480 current_section
->load_base
!= NULL
,
8481 current_section
->addr_tree
!= NULL
);
8483 current_section
->fill
= fill
;
8484 current_section
->phdrs
= phdrs
;
8488 /* Set the output format type. -oformat overrides scripts. */
8491 lang_add_output_format (const char *format
,
8496 if (output_target
== NULL
|| !from_script
)
8498 if (command_line
.endian
== ENDIAN_BIG
8501 else if (command_line
.endian
== ENDIAN_LITTLE
8505 output_target
= format
;
8510 lang_add_insert (const char *where
, int is_before
)
8512 lang_insert_statement_type
*new_stmt
;
8514 new_stmt
= new_stat (lang_insert_statement
, stat_ptr
);
8515 new_stmt
->where
= where
;
8516 new_stmt
->is_before
= is_before
;
8517 saved_script_handle
= previous_script_handle
;
8520 /* Enter a group. This creates a new lang_group_statement, and sets
8521 stat_ptr to build new statements within the group. */
8524 lang_enter_group (void)
8526 lang_group_statement_type
*g
;
8528 g
= new_stat (lang_group_statement
, stat_ptr
);
8529 lang_list_init (&g
->children
);
8530 push_stat_ptr (&g
->children
);
8533 /* Leave a group. This just resets stat_ptr to start writing to the
8534 regular list of statements again. Note that this will not work if
8535 groups can occur inside anything else which can adjust stat_ptr,
8536 but currently they can't. */
8539 lang_leave_group (void)
8544 /* Add a new program header. This is called for each entry in a PHDRS
8545 command in a linker script. */
8548 lang_new_phdr (const char *name
,
8550 bfd_boolean filehdr
,
8555 struct lang_phdr
*n
, **pp
;
8558 n
= stat_alloc (sizeof (struct lang_phdr
));
8561 n
->type
= exp_get_vma (type
, 0, "program header type");
8562 n
->filehdr
= filehdr
;
8567 hdrs
= n
->type
== 1 && (phdrs
|| filehdr
);
8569 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
8572 && !((*pp
)->filehdr
|| (*pp
)->phdrs
))
8574 einfo (_("%X%P:%pS: PHDRS and FILEHDR are not supported"
8575 " when prior PT_LOAD headers lack them\n"), NULL
);
8582 /* Record the program header information in the output BFD. FIXME: We
8583 should not be calling an ELF specific function here. */
8586 lang_record_phdrs (void)
8590 lang_output_section_phdr_list
*last
;
8591 struct lang_phdr
*l
;
8592 lang_output_section_statement_type
*os
;
8595 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
8598 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
8605 for (os
= (void *) lang_os_list
.head
;
8609 lang_output_section_phdr_list
*pl
;
8611 if (os
->constraint
< 0)
8619 if (os
->sectype
== noload_section
8620 || os
->bfd_section
== NULL
8621 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
8624 /* Don't add orphans to PT_INTERP header. */
8630 lang_output_section_statement_type
*tmp_os
;
8632 /* If we have not run across a section with a program
8633 header assigned to it yet, then scan forwards to find
8634 one. This prevents inconsistencies in the linker's
8635 behaviour when a script has specified just a single
8636 header and there are sections in that script which are
8637 not assigned to it, and which occur before the first
8638 use of that header. See here for more details:
8639 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
8640 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
8643 last
= tmp_os
->phdrs
;
8647 einfo (_("%F%P: no sections assigned to phdrs\n"));
8652 if (os
->bfd_section
== NULL
)
8655 for (; pl
!= NULL
; pl
= pl
->next
)
8657 if (strcmp (pl
->name
, l
->name
) == 0)
8662 secs
= (asection
**) xrealloc (secs
,
8663 alc
* sizeof (asection
*));
8665 secs
[c
] = os
->bfd_section
;
8672 if (l
->flags
== NULL
)
8675 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
8680 at
= exp_get_vma (l
->at
, 0, "phdr load address");
8682 if (!bfd_record_phdr (link_info
.output_bfd
, l
->type
,
8683 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
8684 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
8685 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
8690 /* Make sure all the phdr assignments succeeded. */
8691 for (os
= (void *) lang_os_list
.head
;
8695 lang_output_section_phdr_list
*pl
;
8697 if (os
->constraint
< 0
8698 || os
->bfd_section
== NULL
)
8701 for (pl
= os
->phdrs
;
8704 if (!pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
8705 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
8706 os
->name
, pl
->name
);
8710 /* Record a list of sections which may not be cross referenced. */
8713 lang_add_nocrossref (lang_nocrossref_type
*l
)
8715 struct lang_nocrossrefs
*n
;
8717 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
8718 n
->next
= nocrossref_list
;
8720 n
->onlyfirst
= FALSE
;
8721 nocrossref_list
= n
;
8723 /* Set notice_all so that we get informed about all symbols. */
8724 link_info
.notice_all
= TRUE
;
8727 /* Record a section that cannot be referenced from a list of sections. */
8730 lang_add_nocrossref_to (lang_nocrossref_type
*l
)
8732 lang_add_nocrossref (l
);
8733 nocrossref_list
->onlyfirst
= TRUE
;
8736 /* Overlay handling. We handle overlays with some static variables. */
8738 /* The overlay virtual address. */
8739 static etree_type
*overlay_vma
;
8740 /* And subsection alignment. */
8741 static etree_type
*overlay_subalign
;
8743 /* An expression for the maximum section size seen so far. */
8744 static etree_type
*overlay_max
;
8746 /* A list of all the sections in this overlay. */
8748 struct overlay_list
{
8749 struct overlay_list
*next
;
8750 lang_output_section_statement_type
*os
;
8753 static struct overlay_list
*overlay_list
;
8755 /* Start handling an overlay. */
8758 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
8760 /* The grammar should prevent nested overlays from occurring. */
8761 ASSERT (overlay_vma
== NULL
8762 && overlay_subalign
== NULL
8763 && overlay_max
== NULL
);
8765 overlay_vma
= vma_expr
;
8766 overlay_subalign
= subalign
;
8769 /* Start a section in an overlay. We handle this by calling
8770 lang_enter_output_section_statement with the correct VMA.
8771 lang_leave_overlay sets up the LMA and memory regions. */
8774 lang_enter_overlay_section (const char *name
)
8776 struct overlay_list
*n
;
8779 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
8780 0, overlay_subalign
, 0, 0, 0);
8782 /* If this is the first section, then base the VMA of future
8783 sections on this one. This will work correctly even if `.' is
8784 used in the addresses. */
8785 if (overlay_list
== NULL
)
8786 overlay_vma
= exp_nameop (ADDR
, name
);
8788 /* Remember the section. */
8789 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
8790 n
->os
= current_section
;
8791 n
->next
= overlay_list
;
8794 size
= exp_nameop (SIZEOF
, name
);
8796 /* Arrange to work out the maximum section end address. */
8797 if (overlay_max
== NULL
)
8800 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
8803 /* Finish a section in an overlay. There isn't any special to do
8807 lang_leave_overlay_section (fill_type
*fill
,
8808 lang_output_section_phdr_list
*phdrs
)
8815 name
= current_section
->name
;
8817 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
8818 region and that no load-time region has been specified. It doesn't
8819 really matter what we say here, since lang_leave_overlay will
8821 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
8823 /* Define the magic symbols. */
8825 clean
= (char *) xmalloc (strlen (name
) + 1);
8827 for (s1
= name
; *s1
!= '\0'; s1
++)
8828 if (ISALNUM (*s1
) || *s1
== '_')
8832 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_start_");
8833 sprintf (buf
, "__load_start_%s", clean
);
8834 lang_add_assignment (exp_provide (buf
,
8835 exp_nameop (LOADADDR
, name
),
8838 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_stop_");
8839 sprintf (buf
, "__load_stop_%s", clean
);
8840 lang_add_assignment (exp_provide (buf
,
8842 exp_nameop (LOADADDR
, name
),
8843 exp_nameop (SIZEOF
, name
)),
8849 /* Finish an overlay. If there are any overlay wide settings, this
8850 looks through all the sections in the overlay and sets them. */
8853 lang_leave_overlay (etree_type
*lma_expr
,
8856 const char *memspec
,
8857 lang_output_section_phdr_list
*phdrs
,
8858 const char *lma_memspec
)
8860 lang_memory_region_type
*region
;
8861 lang_memory_region_type
*lma_region
;
8862 struct overlay_list
*l
;
8863 lang_nocrossref_type
*nocrossref
;
8865 lang_get_regions (®ion
, &lma_region
,
8866 memspec
, lma_memspec
,
8867 lma_expr
!= NULL
, FALSE
);
8871 /* After setting the size of the last section, set '.' to end of the
8873 if (overlay_list
!= NULL
)
8875 overlay_list
->os
->update_dot
= 1;
8876 overlay_list
->os
->update_dot_tree
8877 = exp_assign (".", exp_binop ('+', overlay_vma
, overlay_max
), FALSE
);
8883 struct overlay_list
*next
;
8885 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
8888 l
->os
->region
= region
;
8889 l
->os
->lma_region
= lma_region
;
8891 /* The first section has the load address specified in the
8892 OVERLAY statement. The rest are worked out from that.
8893 The base address is not needed (and should be null) if
8894 an LMA region was specified. */
8897 l
->os
->load_base
= lma_expr
;
8898 l
->os
->sectype
= first_overlay_section
;
8900 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
8901 l
->os
->phdrs
= phdrs
;
8905 lang_nocrossref_type
*nc
;
8907 nc
= (lang_nocrossref_type
*) xmalloc (sizeof *nc
);
8908 nc
->name
= l
->os
->name
;
8909 nc
->next
= nocrossref
;
8918 if (nocrossref
!= NULL
)
8919 lang_add_nocrossref (nocrossref
);
8922 overlay_list
= NULL
;
8924 overlay_subalign
= NULL
;
8927 /* Version handling. This is only useful for ELF. */
8929 /* If PREV is NULL, return first version pattern matching particular symbol.
8930 If PREV is non-NULL, return first version pattern matching particular
8931 symbol after PREV (previously returned by lang_vers_match). */
8933 static struct bfd_elf_version_expr
*
8934 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
8935 struct bfd_elf_version_expr
*prev
,
8939 const char *cxx_sym
= sym
;
8940 const char *java_sym
= sym
;
8941 struct bfd_elf_version_expr
*expr
= NULL
;
8942 enum demangling_styles curr_style
;
8944 curr_style
= CURRENT_DEMANGLING_STYLE
;
8945 cplus_demangle_set_style (no_demangling
);
8946 c_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_NO_OPTS
);
8949 cplus_demangle_set_style (curr_style
);
8951 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8953 cxx_sym
= bfd_demangle (link_info
.output_bfd
, sym
,
8954 DMGL_PARAMS
| DMGL_ANSI
);
8958 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8960 java_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_JAVA
);
8965 if (head
->htab
&& (prev
== NULL
|| prev
->literal
))
8967 struct bfd_elf_version_expr e
;
8969 switch (prev
? prev
->mask
: 0)
8972 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
8975 expr
= (struct bfd_elf_version_expr
*)
8976 htab_find ((htab_t
) head
->htab
, &e
);
8977 while (expr
&& strcmp (expr
->pattern
, c_sym
) == 0)
8978 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
8984 case BFD_ELF_VERSION_C_TYPE
:
8985 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8987 e
.pattern
= cxx_sym
;
8988 expr
= (struct bfd_elf_version_expr
*)
8989 htab_find ((htab_t
) head
->htab
, &e
);
8990 while (expr
&& strcmp (expr
->pattern
, cxx_sym
) == 0)
8991 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
8997 case BFD_ELF_VERSION_CXX_TYPE
:
8998 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
9000 e
.pattern
= java_sym
;
9001 expr
= (struct bfd_elf_version_expr
*)
9002 htab_find ((htab_t
) head
->htab
, &e
);
9003 while (expr
&& strcmp (expr
->pattern
, java_sym
) == 0)
9004 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
9015 /* Finally, try the wildcards. */
9016 if (prev
== NULL
|| prev
->literal
)
9017 expr
= head
->remaining
;
9020 for (; expr
; expr
= expr
->next
)
9027 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
9030 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
9032 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
9036 if (fnmatch (expr
->pattern
, s
, 0) == 0)
9042 free ((char *) c_sym
);
9044 free ((char *) cxx_sym
);
9045 if (java_sym
!= sym
)
9046 free ((char *) java_sym
);
9050 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
9051 return a pointer to the symbol name with any backslash quotes removed. */
9054 realsymbol (const char *pattern
)
9057 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
9058 char *s
, *symbol
= (char *) xmalloc (strlen (pattern
) + 1);
9060 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
9062 /* It is a glob pattern only if there is no preceding
9066 /* Remove the preceding backslash. */
9073 if (*p
== '?' || *p
== '*' || *p
== '[')
9080 backslash
= *p
== '\\';
9096 /* This is called for each variable name or match expression. NEW_NAME is
9097 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
9098 pattern to be matched against symbol names. */
9100 struct bfd_elf_version_expr
*
9101 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
9102 const char *new_name
,
9104 bfd_boolean literal_p
)
9106 struct bfd_elf_version_expr
*ret
;
9108 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
9112 ret
->literal
= TRUE
;
9113 ret
->pattern
= literal_p
? new_name
: realsymbol (new_name
);
9114 if (ret
->pattern
== NULL
)
9116 ret
->pattern
= new_name
;
9117 ret
->literal
= FALSE
;
9120 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
9121 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
9122 else if (strcasecmp (lang
, "C++") == 0)
9123 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
9124 else if (strcasecmp (lang
, "Java") == 0)
9125 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
9128 einfo (_("%X%P: unknown language `%s' in version information\n"),
9130 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
9133 return ldemul_new_vers_pattern (ret
);
9136 /* This is called for each set of variable names and match
9139 struct bfd_elf_version_tree
*
9140 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
9141 struct bfd_elf_version_expr
*locals
)
9143 struct bfd_elf_version_tree
*ret
;
9145 ret
= (struct bfd_elf_version_tree
*) xcalloc (1, sizeof *ret
);
9146 ret
->globals
.list
= globals
;
9147 ret
->locals
.list
= locals
;
9148 ret
->match
= lang_vers_match
;
9149 ret
->name_indx
= (unsigned int) -1;
9153 /* This static variable keeps track of version indices. */
9155 static int version_index
;
9158 version_expr_head_hash (const void *p
)
9160 const struct bfd_elf_version_expr
*e
=
9161 (const struct bfd_elf_version_expr
*) p
;
9163 return htab_hash_string (e
->pattern
);
9167 version_expr_head_eq (const void *p1
, const void *p2
)
9169 const struct bfd_elf_version_expr
*e1
=
9170 (const struct bfd_elf_version_expr
*) p1
;
9171 const struct bfd_elf_version_expr
*e2
=
9172 (const struct bfd_elf_version_expr
*) p2
;
9174 return strcmp (e1
->pattern
, e2
->pattern
) == 0;
9178 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
9181 struct bfd_elf_version_expr
*e
, *next
;
9182 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
9184 for (e
= head
->list
; e
; e
= e
->next
)
9188 head
->mask
|= e
->mask
;
9193 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
9194 version_expr_head_eq
, NULL
);
9195 list_loc
= &head
->list
;
9196 remaining_loc
= &head
->remaining
;
9197 for (e
= head
->list
; e
; e
= next
)
9203 remaining_loc
= &e
->next
;
9207 void **loc
= htab_find_slot ((htab_t
) head
->htab
, e
, INSERT
);
9211 struct bfd_elf_version_expr
*e1
, *last
;
9213 e1
= (struct bfd_elf_version_expr
*) *loc
;
9217 if (e1
->mask
== e
->mask
)
9225 while (e1
&& strcmp (e1
->pattern
, e
->pattern
) == 0);
9229 /* This is a duplicate. */
9230 /* FIXME: Memory leak. Sometimes pattern is not
9231 xmalloced alone, but in larger chunk of memory. */
9232 /* free (e->pattern); */
9237 e
->next
= last
->next
;
9245 list_loc
= &e
->next
;
9249 *remaining_loc
= NULL
;
9250 *list_loc
= head
->remaining
;
9253 head
->remaining
= head
->list
;
9256 /* This is called when we know the name and dependencies of the
9260 lang_register_vers_node (const char *name
,
9261 struct bfd_elf_version_tree
*version
,
9262 struct bfd_elf_version_deps
*deps
)
9264 struct bfd_elf_version_tree
*t
, **pp
;
9265 struct bfd_elf_version_expr
*e1
;
9270 if (link_info
.version_info
!= NULL
9271 && (name
[0] == '\0' || link_info
.version_info
->name
[0] == '\0'))
9273 einfo (_("%X%P: anonymous version tag cannot be combined"
9274 " with other version tags\n"));
9279 /* Make sure this node has a unique name. */
9280 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9281 if (strcmp (t
->name
, name
) == 0)
9282 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
9284 lang_finalize_version_expr_head (&version
->globals
);
9285 lang_finalize_version_expr_head (&version
->locals
);
9287 /* Check the global and local match names, and make sure there
9288 aren't any duplicates. */
9290 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
9292 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9294 struct bfd_elf_version_expr
*e2
;
9296 if (t
->locals
.htab
&& e1
->literal
)
9298 e2
= (struct bfd_elf_version_expr
*)
9299 htab_find ((htab_t
) t
->locals
.htab
, e1
);
9300 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
9302 if (e1
->mask
== e2
->mask
)
9303 einfo (_("%X%P: duplicate expression `%s'"
9304 " in version information\n"), e1
->pattern
);
9308 else if (!e1
->literal
)
9309 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
9310 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
9311 && e1
->mask
== e2
->mask
)
9312 einfo (_("%X%P: duplicate expression `%s'"
9313 " in version information\n"), e1
->pattern
);
9317 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
9319 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9321 struct bfd_elf_version_expr
*e2
;
9323 if (t
->globals
.htab
&& e1
->literal
)
9325 e2
= (struct bfd_elf_version_expr
*)
9326 htab_find ((htab_t
) t
->globals
.htab
, e1
);
9327 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
9329 if (e1
->mask
== e2
->mask
)
9330 einfo (_("%X%P: duplicate expression `%s'"
9331 " in version information\n"),
9336 else if (!e1
->literal
)
9337 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
9338 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
9339 && e1
->mask
== e2
->mask
)
9340 einfo (_("%X%P: duplicate expression `%s'"
9341 " in version information\n"), e1
->pattern
);
9345 version
->deps
= deps
;
9346 version
->name
= name
;
9347 if (name
[0] != '\0')
9350 version
->vernum
= version_index
;
9353 version
->vernum
= 0;
9355 for (pp
= &link_info
.version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
9360 /* This is called when we see a version dependency. */
9362 struct bfd_elf_version_deps
*
9363 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
9365 struct bfd_elf_version_deps
*ret
;
9366 struct bfd_elf_version_tree
*t
;
9368 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
9371 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9373 if (strcmp (t
->name
, name
) == 0)
9375 ret
->version_needed
= t
;
9380 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
9382 ret
->version_needed
= NULL
;
9387 lang_do_version_exports_section (void)
9389 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
9391 LANG_FOR_EACH_INPUT_STATEMENT (is
)
9393 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
9401 contents
= (char *) xmalloc (len
);
9402 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
9403 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
9406 while (p
< contents
+ len
)
9408 greg
= lang_new_vers_pattern (greg
, p
, NULL
, FALSE
);
9409 p
= strchr (p
, '\0') + 1;
9412 /* Do not free the contents, as we used them creating the regex. */
9414 /* Do not include this section in the link. */
9415 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
9418 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, FALSE
);
9419 lang_register_vers_node (command_line
.version_exports_section
,
9420 lang_new_vers_node (greg
, lreg
), NULL
);
9423 /* Evaluate LENGTH and ORIGIN parts of MEMORY spec. This is initially
9424 called with UPDATE_REGIONS_P set to FALSE, in this case no errors are
9425 thrown, however, references to symbols in the origin and length fields
9426 will be pushed into the symbol table, this allows PROVIDE statements to
9427 then provide these symbols. This function is called a second time with
9428 UPDATE_REGIONS_P set to TRUE, this time the we update the actual region
9429 data structures, and throw errors if missing symbols are encountered. */
9432 lang_do_memory_regions (bfd_boolean update_regions_p
)
9434 lang_memory_region_type
*r
= lang_memory_region_list
;
9436 for (; r
!= NULL
; r
= r
->next
)
9440 exp_fold_tree_no_dot (r
->origin_exp
);
9441 if (update_regions_p
)
9443 if (expld
.result
.valid_p
)
9445 r
->origin
= expld
.result
.value
;
9446 r
->current
= r
->origin
;
9449 einfo (_("%P: invalid origin for memory region %s\n"),
9455 exp_fold_tree_no_dot (r
->length_exp
);
9456 if (update_regions_p
)
9458 if (expld
.result
.valid_p
)
9459 r
->length
= expld
.result
.value
;
9461 einfo (_("%P: invalid length for memory region %s\n"),
9469 lang_add_unique (const char *name
)
9471 struct unique_sections
*ent
;
9473 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
9474 if (strcmp (ent
->name
, name
) == 0)
9477 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
9478 ent
->name
= xstrdup (name
);
9479 ent
->next
= unique_section_list
;
9480 unique_section_list
= ent
;
9483 /* Append the list of dynamic symbols to the existing one. */
9486 lang_append_dynamic_list (struct bfd_elf_dynamic_list
**list_p
,
9487 struct bfd_elf_version_expr
*dynamic
)
9491 struct bfd_elf_version_expr
*tail
;
9492 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
9494 tail
->next
= (*list_p
)->head
.list
;
9495 (*list_p
)->head
.list
= dynamic
;
9499 struct bfd_elf_dynamic_list
*d
;
9501 d
= (struct bfd_elf_dynamic_list
*) xcalloc (1, sizeof *d
);
9502 d
->head
.list
= dynamic
;
9503 d
->match
= lang_vers_match
;
9508 /* Append the list of C++ typeinfo dynamic symbols to the existing
9512 lang_append_dynamic_list_cpp_typeinfo (void)
9514 const char *symbols
[] =
9516 "typeinfo name for*",
9519 struct bfd_elf_version_expr
*dynamic
= NULL
;
9522 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9523 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9526 lang_append_dynamic_list (&link_info
.dynamic_list
, dynamic
);
9529 /* Append the list of C++ operator new and delete dynamic symbols to the
9533 lang_append_dynamic_list_cpp_new (void)
9535 const char *symbols
[] =
9540 struct bfd_elf_version_expr
*dynamic
= NULL
;
9543 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9544 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9547 lang_append_dynamic_list (&link_info
.dynamic_list
, dynamic
);
9550 /* Scan a space and/or comma separated string of features. */
9553 lang_ld_feature (char *str
)
9561 while (*p
== ',' || ISSPACE (*p
))
9566 while (*q
&& *q
!= ',' && !ISSPACE (*q
))
9570 if (strcasecmp (p
, "SANE_EXPR") == 0)
9571 config
.sane_expr
= TRUE
;
9573 einfo (_("%X%P: unknown feature `%s'\n"), p
);
9579 /* Pretty print memory amount. */
9582 lang_print_memory_size (bfd_vma sz
)
9584 if ((sz
& 0x3fffffff) == 0)
9585 printf ("%10" BFD_VMA_FMT
"u GB", sz
>> 30);
9586 else if ((sz
& 0xfffff) == 0)
9587 printf ("%10" BFD_VMA_FMT
"u MB", sz
>> 20);
9588 else if ((sz
& 0x3ff) == 0)
9589 printf ("%10" BFD_VMA_FMT
"u KB", sz
>> 10);
9591 printf (" %10" BFD_VMA_FMT
"u B", sz
);
9594 /* Implement --print-memory-usage: disply per region memory usage. */
9597 lang_print_memory_usage (void)
9599 lang_memory_region_type
*r
;
9601 printf ("Memory region Used Size Region Size %%age Used\n");
9602 for (r
= lang_memory_region_list
; r
->next
!= NULL
; r
= r
->next
)
9604 bfd_vma used_length
= r
->current
- r
->origin
;
9606 printf ("%16s: ",r
->name_list
.name
);
9607 lang_print_memory_size (used_length
);
9608 lang_print_memory_size ((bfd_vma
) r
->length
);
9612 double percent
= used_length
* 100.0 / r
->length
;
9613 printf (" %6.2f%%", percent
);