1 /* Linker command language support.
2 Copyright (C) 1991-2020 Free Software Foundation, Inc.
4 This file is part of the GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
24 #include "libiberty.h"
25 #include "filenames.h"
26 #include "safe-ctype.h"
47 #endif /* ENABLE_PLUGINS */
50 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
53 /* Convert between addresses in bytes and sizes in octets.
54 For currently supported targets, octets_per_byte is always a power
55 of two, so we can use shifts. */
56 #define TO_ADDR(X) ((X) >> opb_shift)
57 #define TO_SIZE(X) ((X) << opb_shift)
59 /* Local variables. */
60 static struct obstack stat_obstack
;
61 static struct obstack map_obstack
;
63 #define obstack_chunk_alloc xmalloc
64 #define obstack_chunk_free free
65 static const char *entry_symbol_default
= "start";
66 static bfd_boolean map_head_is_link_order
= FALSE
;
67 static lang_output_section_statement_type
*default_common_section
;
68 static bfd_boolean map_option_f
;
69 static bfd_vma print_dot
;
70 static lang_input_statement_type
*first_file
;
71 static const char *current_target
;
72 /* Header for list of statements corresponding to any files involved in the
73 link, either specified from the command-line or added implicitely (eg.
74 archive member used to resolved undefined symbol, wildcard statement from
75 linker script, etc.). Next pointer is in next field of a
76 lang_statement_header_type (reached via header field in a
77 lang_statement_union). */
78 static lang_statement_list_type statement_list
;
79 static lang_statement_list_type
*stat_save
[10];
80 static lang_statement_list_type
**stat_save_ptr
= &stat_save
[0];
81 static struct unique_sections
*unique_section_list
;
82 static struct asneeded_minfo
*asneeded_list_head
;
83 static unsigned int opb_shift
= 0;
85 /* Forward declarations. */
86 static void exp_init_os (etree_type
*);
87 static lang_input_statement_type
*lookup_name (const char *);
88 static void insert_undefined (const char *);
89 static bfd_boolean
sort_def_symbol (struct bfd_link_hash_entry
*, void *);
90 static void print_statement (lang_statement_union_type
*,
91 lang_output_section_statement_type
*);
92 static void print_statement_list (lang_statement_union_type
*,
93 lang_output_section_statement_type
*);
94 static void print_statements (void);
95 static void print_input_section (asection
*, bfd_boolean
);
96 static bfd_boolean
lang_one_common (struct bfd_link_hash_entry
*, void *);
97 static void lang_record_phdrs (void);
98 static void lang_do_version_exports_section (void);
99 static void lang_finalize_version_expr_head
100 (struct bfd_elf_version_expr_head
*);
101 static void lang_do_memory_regions (void);
103 /* Exported variables. */
104 const char *output_target
;
105 lang_output_section_statement_type
*abs_output_section
;
106 lang_statement_list_type lang_os_list
;
107 lang_statement_list_type
*stat_ptr
= &statement_list
;
108 /* Header for list of statements corresponding to files used in the final
109 executable. This can be either object file specified on the command-line
110 or library member resolving an undefined reference. Next pointer is in next
111 field of a lang_input_statement_type (reached via input_statement field in a
112 lang_statement_union). */
113 lang_statement_list_type file_chain
= { NULL
, NULL
};
114 /* Header for list of statements corresponding to files specified on the
115 command-line for linking. It thus contains real object files and archive
116 but not archive members. Next pointer is in next_real_file field of a
117 lang_input_statement_type statement (reached via input_statement field in a
118 lang_statement_union). */
119 lang_statement_list_type input_file_chain
;
120 struct bfd_sym_chain entry_symbol
= { NULL
, NULL
};
121 const char *entry_section
= ".text";
122 struct lang_input_statement_flags input_flags
;
123 bfd_boolean entry_from_cmdline
;
124 bfd_boolean undef_from_cmdline
;
125 bfd_boolean lang_has_input_file
= FALSE
;
126 bfd_boolean had_output_filename
= FALSE
;
127 bfd_boolean lang_float_flag
= FALSE
;
128 bfd_boolean delete_output_file_on_failure
= FALSE
;
129 struct lang_phdr
*lang_phdr_list
;
130 struct lang_nocrossrefs
*nocrossref_list
;
131 struct asneeded_minfo
**asneeded_list_tail
;
132 static ctf_file_t
*ctf_output
;
134 /* Functions that traverse the linker script and might evaluate
135 DEFINED() need to increment this at the start of the traversal. */
136 int lang_statement_iteration
= 0;
138 /* Count times through one_lang_size_sections_pass after mark phase. */
139 static int lang_sizing_iteration
= 0;
141 /* Return TRUE if the PATTERN argument is a wildcard pattern.
142 Although backslashes are treated specially if a pattern contains
143 wildcards, we do not consider the mere presence of a backslash to
144 be enough to cause the pattern to be treated as a wildcard.
145 That lets us handle DOS filenames more naturally. */
146 #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
148 #define new_stat(x, y) \
149 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
151 #define outside_section_address(q) \
152 ((q)->output_offset + (q)->output_section->vma)
154 #define outside_symbol_address(q) \
155 ((q)->value + outside_section_address (q->section))
157 #define SECTION_NAME_MAP_LENGTH (16)
159 /* CTF sections smaller than this are not compressed: compression of
160 dictionaries this small doesn't gain much, and this lets consumers mmap the
161 sections directly out of the ELF file and use them with no decompression
162 overhead if they want to. */
163 #define CTF_COMPRESSION_THRESHOLD 4096
166 stat_alloc (size_t size
)
168 return obstack_alloc (&stat_obstack
, size
);
172 name_match (const char *pattern
, const char *name
)
174 if (wildcardp (pattern
))
175 return fnmatch (pattern
, name
, 0);
176 return strcmp (pattern
, name
);
179 /* If PATTERN is of the form archive:file, return a pointer to the
180 separator. If not, return NULL. */
183 archive_path (const char *pattern
)
187 if (link_info
.path_separator
== 0)
190 p
= strchr (pattern
, link_info
.path_separator
);
191 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
192 if (p
== NULL
|| link_info
.path_separator
!= ':')
195 /* Assume a match on the second char is part of drive specifier,
196 as in "c:\silly.dos". */
197 if (p
== pattern
+ 1 && ISALPHA (*pattern
))
198 p
= strchr (p
+ 1, link_info
.path_separator
);
203 /* Given that FILE_SPEC results in a non-NULL SEP result from archive_path,
204 return whether F matches FILE_SPEC. */
207 input_statement_is_archive_path (const char *file_spec
, char *sep
,
208 lang_input_statement_type
*f
)
210 bfd_boolean match
= FALSE
;
213 || name_match (sep
+ 1, f
->filename
) == 0)
214 && ((sep
!= file_spec
)
215 == (f
->the_bfd
!= NULL
&& f
->the_bfd
->my_archive
!= NULL
)))
219 if (sep
!= file_spec
)
221 const char *aname
= f
->the_bfd
->my_archive
->filename
;
223 match
= name_match (file_spec
, aname
) == 0;
224 *sep
= link_info
.path_separator
;
231 unique_section_p (const asection
*sec
,
232 const lang_output_section_statement_type
*os
)
234 struct unique_sections
*unam
;
237 if (!link_info
.resolve_section_groups
238 && sec
->owner
!= NULL
239 && bfd_is_group_section (sec
->owner
, sec
))
241 && strcmp (os
->name
, DISCARD_SECTION_NAME
) == 0);
244 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
245 if (name_match (unam
->name
, secnam
) == 0)
251 /* Generic traversal routines for finding matching sections. */
253 /* Return true if FILE matches a pattern in EXCLUDE_LIST, otherwise return
257 walk_wild_file_in_exclude_list (struct name_list
*exclude_list
,
258 lang_input_statement_type
*file
)
260 struct name_list
*list_tmp
;
262 for (list_tmp
= exclude_list
;
264 list_tmp
= list_tmp
->next
)
266 char *p
= archive_path (list_tmp
->name
);
270 if (input_statement_is_archive_path (list_tmp
->name
, p
, file
))
274 else if (name_match (list_tmp
->name
, file
->filename
) == 0)
277 /* FIXME: Perhaps remove the following at some stage? Matching
278 unadorned archives like this was never documented and has
279 been superceded by the archive:path syntax. */
280 else if (file
->the_bfd
!= NULL
281 && file
->the_bfd
->my_archive
!= NULL
282 && name_match (list_tmp
->name
,
283 file
->the_bfd
->my_archive
->filename
) == 0)
290 /* Try processing a section against a wildcard. This just calls
291 the callback unless the filename exclusion list is present
292 and excludes the file. It's hardly ever present so this
293 function is very fast. */
296 walk_wild_consider_section (lang_wild_statement_type
*ptr
,
297 lang_input_statement_type
*file
,
299 struct wildcard_list
*sec
,
303 /* Don't process sections from files which were excluded. */
304 if (walk_wild_file_in_exclude_list (sec
->spec
.exclude_name_list
, file
))
307 (*callback
) (ptr
, sec
, s
, ptr
->section_flag_list
, file
, data
);
310 /* Lowest common denominator routine that can handle everything correctly,
314 walk_wild_section_general (lang_wild_statement_type
*ptr
,
315 lang_input_statement_type
*file
,
320 struct wildcard_list
*sec
;
322 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
324 sec
= ptr
->section_list
;
326 (*callback
) (ptr
, sec
, s
, ptr
->section_flag_list
, file
, data
);
330 bfd_boolean skip
= FALSE
;
332 if (sec
->spec
.name
!= NULL
)
334 const char *sname
= bfd_section_name (s
);
336 skip
= name_match (sec
->spec
.name
, sname
) != 0;
340 walk_wild_consider_section (ptr
, file
, s
, sec
, callback
, data
);
347 /* Routines to find a single section given its name. If there's more
348 than one section with that name, we report that. */
352 asection
*found_section
;
353 bfd_boolean multiple_sections_found
;
354 } section_iterator_callback_data
;
357 section_iterator_callback (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*s
, void *data
)
359 section_iterator_callback_data
*d
= (section_iterator_callback_data
*) data
;
361 if (d
->found_section
!= NULL
)
363 d
->multiple_sections_found
= TRUE
;
367 d
->found_section
= s
;
372 find_section (lang_input_statement_type
*file
,
373 struct wildcard_list
*sec
,
374 bfd_boolean
*multiple_sections_found
)
376 section_iterator_callback_data cb_data
= { NULL
, FALSE
};
378 bfd_get_section_by_name_if (file
->the_bfd
, sec
->spec
.name
,
379 section_iterator_callback
, &cb_data
);
380 *multiple_sections_found
= cb_data
.multiple_sections_found
;
381 return cb_data
.found_section
;
384 /* Code for handling simple wildcards without going through fnmatch,
385 which can be expensive because of charset translations etc. */
387 /* A simple wild is a literal string followed by a single '*',
388 where the literal part is at least 4 characters long. */
391 is_simple_wild (const char *name
)
393 size_t len
= strcspn (name
, "*?[");
394 return len
>= 4 && name
[len
] == '*' && name
[len
+ 1] == '\0';
398 match_simple_wild (const char *pattern
, const char *name
)
400 /* The first four characters of the pattern are guaranteed valid
401 non-wildcard characters. So we can go faster. */
402 if (pattern
[0] != name
[0] || pattern
[1] != name
[1]
403 || pattern
[2] != name
[2] || pattern
[3] != name
[3])
408 while (*pattern
!= '*')
409 if (*name
++ != *pattern
++)
415 /* Return the numerical value of the init_priority attribute from
416 section name NAME. */
419 get_init_priority (const asection
*sec
)
421 const char *name
= bfd_section_name (sec
);
424 /* GCC uses the following section names for the init_priority
425 attribute with numerical values 101 to 65535 inclusive. A
426 lower value means a higher priority.
428 1: .init_array.NNNNN/.fini_array.NNNNN: Where NNNNN is the
429 decimal numerical value of the init_priority attribute.
430 The order of execution in .init_array is forward and
431 .fini_array is backward.
432 2: .ctors.NNNNN/.dtors.NNNNN: Where NNNNN is 65535 minus the
433 decimal numerical value of the init_priority attribute.
434 The order of execution in .ctors is backward and .dtors
437 .init_array.NNNNN sections would normally be placed in an output
438 .init_array section, .fini_array.NNNNN in .fini_array,
439 .ctors.NNNNN in .ctors, and .dtors.NNNNN in .dtors. This means
440 we should sort by increasing number (and could just use
441 SORT_BY_NAME in scripts). However if .ctors.NNNNN sections are
442 being placed in .init_array (which may also contain
443 .init_array.NNNNN sections) or .dtors.NNNNN sections are being
444 placed in .fini_array then we need to extract the init_priority
445 attribute and sort on that. */
446 dot
= strrchr (name
, '.');
447 if (dot
!= NULL
&& ISDIGIT (dot
[1]))
450 unsigned long init_priority
= strtoul (dot
+ 1, &end
, 10);
454 && (strncmp (name
, ".ctors", 6) == 0
455 || strncmp (name
, ".dtors", 6) == 0))
456 init_priority
= 65535 - init_priority
;
457 if (init_priority
<= INT_MAX
)
458 return init_priority
;
464 /* Compare sections ASEC and BSEC according to SORT. */
467 compare_section (sort_type sort
, asection
*asec
, asection
*bsec
)
470 int a_priority
, b_priority
;
477 case by_init_priority
:
478 a_priority
= get_init_priority (asec
);
479 b_priority
= get_init_priority (bsec
);
480 if (a_priority
< 0 || b_priority
< 0)
482 ret
= a_priority
- b_priority
;
488 case by_alignment_name
:
489 ret
= bfd_section_alignment (bsec
) - bfd_section_alignment (asec
);
496 ret
= strcmp (bfd_section_name (asec
), bfd_section_name (bsec
));
499 case by_name_alignment
:
500 ret
= strcmp (bfd_section_name (asec
), bfd_section_name (bsec
));
506 ret
= bfd_section_alignment (bsec
) - bfd_section_alignment (asec
);
513 /* Build a Binary Search Tree to sort sections, unlike insertion sort
514 used in wild_sort(). BST is considerably faster if the number of
515 of sections are large. */
517 static lang_section_bst_type
**
518 wild_sort_fast (lang_wild_statement_type
*wild
,
519 struct wildcard_list
*sec
,
520 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
523 lang_section_bst_type
**tree
;
526 if (!wild
->filenames_sorted
527 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
529 /* Append at the right end of tree. */
531 tree
= &((*tree
)->right
);
537 /* Find the correct node to append this section. */
538 if (compare_section (sec
->spec
.sorted
, section
, (*tree
)->section
) < 0)
539 tree
= &((*tree
)->left
);
541 tree
= &((*tree
)->right
);
547 /* Use wild_sort_fast to build a BST to sort sections. */
550 output_section_callback_fast (lang_wild_statement_type
*ptr
,
551 struct wildcard_list
*sec
,
553 struct flag_info
*sflag_list ATTRIBUTE_UNUSED
,
554 lang_input_statement_type
*file
,
557 lang_section_bst_type
*node
;
558 lang_section_bst_type
**tree
;
559 lang_output_section_statement_type
*os
;
561 os
= (lang_output_section_statement_type
*) output
;
563 if (unique_section_p (section
, os
))
566 node
= (lang_section_bst_type
*) xmalloc (sizeof (lang_section_bst_type
));
569 node
->section
= section
;
571 tree
= wild_sort_fast (ptr
, sec
, file
, section
);
576 /* Convert a sorted sections' BST back to list form. */
579 output_section_callback_tree_to_list (lang_wild_statement_type
*ptr
,
580 lang_section_bst_type
*tree
,
584 output_section_callback_tree_to_list (ptr
, tree
->left
, output
);
586 lang_add_section (&ptr
->children
, tree
->section
, NULL
,
587 (lang_output_section_statement_type
*) output
);
590 output_section_callback_tree_to_list (ptr
, tree
->right
, output
);
595 /* Specialized, optimized routines for handling different kinds of
599 walk_wild_section_specs1_wild0 (lang_wild_statement_type
*ptr
,
600 lang_input_statement_type
*file
,
604 /* We can just do a hash lookup for the section with the right name.
605 But if that lookup discovers more than one section with the name
606 (should be rare), we fall back to the general algorithm because
607 we would otherwise have to sort the sections to make sure they
608 get processed in the bfd's order. */
609 bfd_boolean multiple_sections_found
;
610 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
611 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
613 if (multiple_sections_found
)
614 walk_wild_section_general (ptr
, file
, callback
, data
);
616 walk_wild_consider_section (ptr
, file
, s0
, sec0
, callback
, data
);
620 walk_wild_section_specs1_wild1 (lang_wild_statement_type
*ptr
,
621 lang_input_statement_type
*file
,
626 struct wildcard_list
*wildsec0
= ptr
->handler_data
[0];
628 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
630 const char *sname
= bfd_section_name (s
);
631 bfd_boolean skip
= !match_simple_wild (wildsec0
->spec
.name
, sname
);
634 walk_wild_consider_section (ptr
, file
, s
, wildsec0
, callback
, data
);
639 walk_wild_section_specs2_wild1 (lang_wild_statement_type
*ptr
,
640 lang_input_statement_type
*file
,
645 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
646 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
647 bfd_boolean multiple_sections_found
;
648 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
650 if (multiple_sections_found
)
652 walk_wild_section_general (ptr
, file
, callback
, data
);
656 /* Note that if the section was not found, s0 is NULL and
657 we'll simply never succeed the s == s0 test below. */
658 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
660 /* Recall that in this code path, a section cannot satisfy more
661 than one spec, so if s == s0 then it cannot match
664 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
667 const char *sname
= bfd_section_name (s
);
668 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
671 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
,
678 walk_wild_section_specs3_wild2 (lang_wild_statement_type
*ptr
,
679 lang_input_statement_type
*file
,
684 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
685 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
686 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
687 bfd_boolean multiple_sections_found
;
688 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
690 if (multiple_sections_found
)
692 walk_wild_section_general (ptr
, file
, callback
, data
);
696 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
699 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
702 const char *sname
= bfd_section_name (s
);
703 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
706 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
, data
);
709 skip
= !match_simple_wild (wildsec2
->spec
.name
, sname
);
711 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
719 walk_wild_section_specs4_wild2 (lang_wild_statement_type
*ptr
,
720 lang_input_statement_type
*file
,
725 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
726 struct wildcard_list
*sec1
= ptr
->handler_data
[1];
727 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
728 struct wildcard_list
*wildsec3
= ptr
->handler_data
[3];
729 bfd_boolean multiple_sections_found
;
730 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
), *s1
;
732 if (multiple_sections_found
)
734 walk_wild_section_general (ptr
, file
, callback
, data
);
738 s1
= find_section (file
, sec1
, &multiple_sections_found
);
739 if (multiple_sections_found
)
741 walk_wild_section_general (ptr
, file
, callback
, data
);
745 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
748 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
751 walk_wild_consider_section (ptr
, file
, s
, sec1
, callback
, data
);
754 const char *sname
= bfd_section_name (s
);
755 bfd_boolean skip
= !match_simple_wild (wildsec2
->spec
.name
,
759 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
763 skip
= !match_simple_wild (wildsec3
->spec
.name
, sname
);
765 walk_wild_consider_section (ptr
, file
, s
, wildsec3
,
773 walk_wild_section (lang_wild_statement_type
*ptr
,
774 lang_input_statement_type
*file
,
778 if (file
->flags
.just_syms
)
781 (*ptr
->walk_wild_section_handler
) (ptr
, file
, callback
, data
);
784 /* Returns TRUE when name1 is a wildcard spec that might match
785 something name2 can match. We're conservative: we return FALSE
786 only if the prefixes of name1 and name2 are different up to the
787 first wildcard character. */
790 wild_spec_can_overlap (const char *name1
, const char *name2
)
792 size_t prefix1_len
= strcspn (name1
, "?*[");
793 size_t prefix2_len
= strcspn (name2
, "?*[");
794 size_t min_prefix_len
;
796 /* Note that if there is no wildcard character, then we treat the
797 terminating 0 as part of the prefix. Thus ".text" won't match
798 ".text." or ".text.*", for example. */
799 if (name1
[prefix1_len
] == '\0')
801 if (name2
[prefix2_len
] == '\0')
804 min_prefix_len
= prefix1_len
< prefix2_len
? prefix1_len
: prefix2_len
;
806 return memcmp (name1
, name2
, min_prefix_len
) == 0;
809 /* Select specialized code to handle various kinds of wildcard
813 analyze_walk_wild_section_handler (lang_wild_statement_type
*ptr
)
816 int wild_name_count
= 0;
817 struct wildcard_list
*sec
;
821 ptr
->walk_wild_section_handler
= walk_wild_section_general
;
822 ptr
->handler_data
[0] = NULL
;
823 ptr
->handler_data
[1] = NULL
;
824 ptr
->handler_data
[2] = NULL
;
825 ptr
->handler_data
[3] = NULL
;
828 /* Count how many wildcard_specs there are, and how many of those
829 actually use wildcards in the name. Also, bail out if any of the
830 wildcard names are NULL. (Can this actually happen?
831 walk_wild_section used to test for it.) And bail out if any
832 of the wildcards are more complex than a simple string
833 ending in a single '*'. */
834 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
837 if (sec
->spec
.name
== NULL
)
839 if (wildcardp (sec
->spec
.name
))
842 if (!is_simple_wild (sec
->spec
.name
))
847 /* The zero-spec case would be easy to optimize but it doesn't
848 happen in practice. Likewise, more than 4 specs doesn't
849 happen in practice. */
850 if (sec_count
== 0 || sec_count
> 4)
853 /* Check that no two specs can match the same section. */
854 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
856 struct wildcard_list
*sec2
;
857 for (sec2
= sec
->next
; sec2
!= NULL
; sec2
= sec2
->next
)
859 if (wild_spec_can_overlap (sec
->spec
.name
, sec2
->spec
.name
))
864 signature
= (sec_count
<< 8) + wild_name_count
;
868 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild0
;
871 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild1
;
874 ptr
->walk_wild_section_handler
= walk_wild_section_specs2_wild1
;
877 ptr
->walk_wild_section_handler
= walk_wild_section_specs3_wild2
;
880 ptr
->walk_wild_section_handler
= walk_wild_section_specs4_wild2
;
886 /* Now fill the data array with pointers to the specs, first the
887 specs with non-wildcard names, then the specs with wildcard
888 names. It's OK to process the specs in different order from the
889 given order, because we've already determined that no section
890 will match more than one spec. */
892 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
893 if (!wildcardp (sec
->spec
.name
))
894 ptr
->handler_data
[data_counter
++] = sec
;
895 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
896 if (wildcardp (sec
->spec
.name
))
897 ptr
->handler_data
[data_counter
++] = sec
;
900 /* Handle a wild statement for a single file F. */
903 walk_wild_file (lang_wild_statement_type
*s
,
904 lang_input_statement_type
*f
,
908 if (walk_wild_file_in_exclude_list (s
->exclude_name_list
, f
))
911 if (f
->the_bfd
== NULL
912 || !bfd_check_format (f
->the_bfd
, bfd_archive
))
913 walk_wild_section (s
, f
, callback
, data
);
918 /* This is an archive file. We must map each member of the
919 archive separately. */
920 member
= bfd_openr_next_archived_file (f
->the_bfd
, NULL
);
921 while (member
!= NULL
)
923 /* When lookup_name is called, it will call the add_symbols
924 entry point for the archive. For each element of the
925 archive which is included, BFD will call ldlang_add_file,
926 which will set the usrdata field of the member to the
927 lang_input_statement. */
928 if (bfd_usrdata (member
) != NULL
)
929 walk_wild_section (s
, bfd_usrdata (member
), callback
, data
);
931 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
937 walk_wild (lang_wild_statement_type
*s
, callback_t callback
, void *data
)
939 const char *file_spec
= s
->filename
;
942 if (file_spec
== NULL
)
944 /* Perform the iteration over all files in the list. */
945 LANG_FOR_EACH_INPUT_STATEMENT (f
)
947 walk_wild_file (s
, f
, callback
, data
);
950 else if ((p
= archive_path (file_spec
)) != NULL
)
952 LANG_FOR_EACH_INPUT_STATEMENT (f
)
954 if (input_statement_is_archive_path (file_spec
, p
, f
))
955 walk_wild_file (s
, f
, callback
, data
);
958 else if (wildcardp (file_spec
))
960 LANG_FOR_EACH_INPUT_STATEMENT (f
)
962 if (fnmatch (file_spec
, f
->filename
, 0) == 0)
963 walk_wild_file (s
, f
, callback
, data
);
968 lang_input_statement_type
*f
;
970 /* Perform the iteration over a single file. */
971 f
= lookup_name (file_spec
);
973 walk_wild_file (s
, f
, callback
, data
);
977 /* lang_for_each_statement walks the parse tree and calls the provided
978 function for each node, except those inside output section statements
979 with constraint set to -1. */
982 lang_for_each_statement_worker (void (*func
) (lang_statement_union_type
*),
983 lang_statement_union_type
*s
)
985 for (; s
!= NULL
; s
= s
->header
.next
)
989 switch (s
->header
.type
)
991 case lang_constructors_statement_enum
:
992 lang_for_each_statement_worker (func
, constructor_list
.head
);
994 case lang_output_section_statement_enum
:
995 if (s
->output_section_statement
.constraint
!= -1)
996 lang_for_each_statement_worker
997 (func
, s
->output_section_statement
.children
.head
);
999 case lang_wild_statement_enum
:
1000 lang_for_each_statement_worker (func
,
1001 s
->wild_statement
.children
.head
);
1003 case lang_group_statement_enum
:
1004 lang_for_each_statement_worker (func
,
1005 s
->group_statement
.children
.head
);
1007 case lang_data_statement_enum
:
1008 case lang_reloc_statement_enum
:
1009 case lang_object_symbols_statement_enum
:
1010 case lang_output_statement_enum
:
1011 case lang_target_statement_enum
:
1012 case lang_input_section_enum
:
1013 case lang_input_statement_enum
:
1014 case lang_assignment_statement_enum
:
1015 case lang_padding_statement_enum
:
1016 case lang_address_statement_enum
:
1017 case lang_fill_statement_enum
:
1018 case lang_insert_statement_enum
:
1028 lang_for_each_statement (void (*func
) (lang_statement_union_type
*))
1030 lang_for_each_statement_worker (func
, statement_list
.head
);
1033 /*----------------------------------------------------------------------*/
1036 lang_list_init (lang_statement_list_type
*list
)
1039 list
->tail
= &list
->head
;
1043 lang_statement_append (lang_statement_list_type
*list
,
1047 *(list
->tail
) = element
;
1052 push_stat_ptr (lang_statement_list_type
*new_ptr
)
1054 if (stat_save_ptr
>= stat_save
+ sizeof (stat_save
) / sizeof (stat_save
[0]))
1056 *stat_save_ptr
++ = stat_ptr
;
1063 if (stat_save_ptr
<= stat_save
)
1065 stat_ptr
= *--stat_save_ptr
;
1068 /* Build a new statement node for the parse tree. */
1070 static lang_statement_union_type
*
1071 new_statement (enum statement_enum type
,
1073 lang_statement_list_type
*list
)
1075 lang_statement_union_type
*new_stmt
;
1077 new_stmt
= stat_alloc (size
);
1078 new_stmt
->header
.type
= type
;
1079 new_stmt
->header
.next
= NULL
;
1080 lang_statement_append (list
, new_stmt
, &new_stmt
->header
.next
);
1084 /* Build a new input file node for the language. There are several
1085 ways in which we treat an input file, eg, we only look at symbols,
1086 or prefix it with a -l etc.
1088 We can be supplied with requests for input files more than once;
1089 they may, for example be split over several lines like foo.o(.text)
1090 foo.o(.data) etc, so when asked for a file we check that we haven't
1091 got it already so we don't duplicate the bfd. */
1093 static lang_input_statement_type
*
1094 new_afile (const char *name
,
1095 lang_input_file_enum_type file_type
,
1098 lang_input_statement_type
*p
;
1100 lang_has_input_file
= TRUE
;
1102 p
= new_stat (lang_input_statement
, stat_ptr
);
1103 memset (&p
->the_bfd
, 0,
1104 sizeof (*p
) - offsetof (lang_input_statement_type
, the_bfd
));
1106 p
->flags
.dynamic
= input_flags
.dynamic
;
1107 p
->flags
.add_DT_NEEDED_for_dynamic
= input_flags
.add_DT_NEEDED_for_dynamic
;
1108 p
->flags
.add_DT_NEEDED_for_regular
= input_flags
.add_DT_NEEDED_for_regular
;
1109 p
->flags
.whole_archive
= input_flags
.whole_archive
;
1110 p
->flags
.sysrooted
= input_flags
.sysrooted
;
1114 case lang_input_file_is_symbols_only_enum
:
1116 p
->local_sym_name
= name
;
1117 p
->flags
.real
= TRUE
;
1118 p
->flags
.just_syms
= TRUE
;
1120 case lang_input_file_is_fake_enum
:
1122 p
->local_sym_name
= name
;
1124 case lang_input_file_is_l_enum
:
1125 if (name
[0] == ':' && name
[1] != '\0')
1127 p
->filename
= name
+ 1;
1128 p
->flags
.full_name_provided
= TRUE
;
1132 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
1133 p
->flags
.maybe_archive
= TRUE
;
1134 p
->flags
.real
= TRUE
;
1135 p
->flags
.search_dirs
= TRUE
;
1137 case lang_input_file_is_marker_enum
:
1139 p
->local_sym_name
= name
;
1140 p
->flags
.search_dirs
= TRUE
;
1142 case lang_input_file_is_search_file_enum
:
1144 p
->local_sym_name
= name
;
1145 p
->flags
.real
= TRUE
;
1146 p
->flags
.search_dirs
= TRUE
;
1148 case lang_input_file_is_file_enum
:
1150 p
->local_sym_name
= name
;
1151 p
->flags
.real
= TRUE
;
1157 lang_statement_append (&input_file_chain
, p
, &p
->next_real_file
);
1161 lang_input_statement_type
*
1162 lang_add_input_file (const char *name
,
1163 lang_input_file_enum_type file_type
,
1167 && (*name
== '=' || CONST_STRNEQ (name
, "$SYSROOT")))
1169 lang_input_statement_type
*ret
;
1170 char *sysrooted_name
1171 = concat (ld_sysroot
,
1172 name
+ (*name
== '=' ? 1 : strlen ("$SYSROOT")),
1173 (const char *) NULL
);
1175 /* We've now forcibly prepended the sysroot, making the input
1176 file independent of the context. Therefore, temporarily
1177 force a non-sysrooted context for this statement, so it won't
1178 get the sysroot prepended again when opened. (N.B. if it's a
1179 script, any child nodes with input files starting with "/"
1180 will be handled as "sysrooted" as they'll be found to be
1181 within the sysroot subdirectory.) */
1182 unsigned int outer_sysrooted
= input_flags
.sysrooted
;
1183 input_flags
.sysrooted
= 0;
1184 ret
= new_afile (sysrooted_name
, file_type
, target
);
1185 input_flags
.sysrooted
= outer_sysrooted
;
1189 return new_afile (name
, file_type
, target
);
1192 struct out_section_hash_entry
1194 struct bfd_hash_entry root
;
1195 lang_statement_union_type s
;
1198 /* The hash table. */
1200 static struct bfd_hash_table output_section_statement_table
;
1202 /* Support routines for the hash table used by lang_output_section_find,
1203 initialize the table, fill in an entry and remove the table. */
1205 static struct bfd_hash_entry
*
1206 output_section_statement_newfunc (struct bfd_hash_entry
*entry
,
1207 struct bfd_hash_table
*table
,
1210 lang_output_section_statement_type
**nextp
;
1211 struct out_section_hash_entry
*ret
;
1215 entry
= (struct bfd_hash_entry
*) bfd_hash_allocate (table
,
1221 entry
= bfd_hash_newfunc (entry
, table
, string
);
1225 ret
= (struct out_section_hash_entry
*) entry
;
1226 memset (&ret
->s
, 0, sizeof (ret
->s
));
1227 ret
->s
.header
.type
= lang_output_section_statement_enum
;
1228 ret
->s
.output_section_statement
.subsection_alignment
= NULL
;
1229 ret
->s
.output_section_statement
.section_alignment
= NULL
;
1230 ret
->s
.output_section_statement
.block_value
= 1;
1231 lang_list_init (&ret
->s
.output_section_statement
.children
);
1232 lang_statement_append (stat_ptr
, &ret
->s
, &ret
->s
.header
.next
);
1234 /* For every output section statement added to the list, except the
1235 first one, lang_os_list.tail points to the "next"
1236 field of the last element of the list. */
1237 if (lang_os_list
.head
!= NULL
)
1238 ret
->s
.output_section_statement
.prev
1239 = ((lang_output_section_statement_type
*)
1240 ((char *) lang_os_list
.tail
1241 - offsetof (lang_output_section_statement_type
, next
)));
1243 /* GCC's strict aliasing rules prevent us from just casting the
1244 address, so we store the pointer in a variable and cast that
1246 nextp
= &ret
->s
.output_section_statement
.next
;
1247 lang_statement_append (&lang_os_list
, &ret
->s
, nextp
);
1252 output_section_statement_table_init (void)
1254 if (!bfd_hash_table_init_n (&output_section_statement_table
,
1255 output_section_statement_newfunc
,
1256 sizeof (struct out_section_hash_entry
),
1258 einfo (_("%F%P: can not create hash table: %E\n"));
1262 output_section_statement_table_free (void)
1264 bfd_hash_table_free (&output_section_statement_table
);
1267 /* Build enough state so that the parser can build its tree. */
1272 obstack_begin (&stat_obstack
, 1000);
1274 stat_ptr
= &statement_list
;
1276 output_section_statement_table_init ();
1278 lang_list_init (stat_ptr
);
1280 lang_list_init (&input_file_chain
);
1281 lang_list_init (&lang_os_list
);
1282 lang_list_init (&file_chain
);
1283 first_file
= lang_add_input_file (NULL
, lang_input_file_is_marker_enum
,
1285 abs_output_section
=
1286 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
, 0, TRUE
);
1288 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
1290 asneeded_list_head
= NULL
;
1291 asneeded_list_tail
= &asneeded_list_head
;
1297 output_section_statement_table_free ();
1300 /*----------------------------------------------------------------------
1301 A region is an area of memory declared with the
1302 MEMORY { name:org=exp, len=exp ... }
1305 We maintain a list of all the regions here.
1307 If no regions are specified in the script, then the default is used
1308 which is created when looked up to be the entire data space.
1310 If create is true we are creating a region inside a MEMORY block.
1311 In this case it is probably an error to create a region that has
1312 already been created. If we are not inside a MEMORY block it is
1313 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1314 and so we issue a warning.
1316 Each region has at least one name. The first name is either
1317 DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add
1318 alias names to an existing region within a script with
1319 REGION_ALIAS (alias, region_name). Each name corresponds to at most one
1322 static lang_memory_region_type
*lang_memory_region_list
;
1323 static lang_memory_region_type
**lang_memory_region_list_tail
1324 = &lang_memory_region_list
;
1326 lang_memory_region_type
*
1327 lang_memory_region_lookup (const char *const name
, bfd_boolean create
)
1329 lang_memory_region_name
*n
;
1330 lang_memory_region_type
*r
;
1331 lang_memory_region_type
*new_region
;
1333 /* NAME is NULL for LMA memspecs if no region was specified. */
1337 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1338 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1339 if (strcmp (n
->name
, name
) == 0)
1342 einfo (_("%P:%pS: warning: redeclaration of memory region `%s'\n"),
1347 if (!create
&& strcmp (name
, DEFAULT_MEMORY_REGION
))
1348 einfo (_("%P:%pS: warning: memory region `%s' not declared\n"),
1351 new_region
= stat_alloc (sizeof (lang_memory_region_type
));
1353 new_region
->name_list
.name
= xstrdup (name
);
1354 new_region
->name_list
.next
= NULL
;
1355 new_region
->next
= NULL
;
1356 new_region
->origin_exp
= NULL
;
1357 new_region
->origin
= 0;
1358 new_region
->length_exp
= NULL
;
1359 new_region
->length
= ~(bfd_size_type
) 0;
1360 new_region
->current
= 0;
1361 new_region
->last_os
= NULL
;
1362 new_region
->flags
= 0;
1363 new_region
->not_flags
= 0;
1364 new_region
->had_full_message
= FALSE
;
1366 *lang_memory_region_list_tail
= new_region
;
1367 lang_memory_region_list_tail
= &new_region
->next
;
1373 lang_memory_region_alias (const char *alias
, const char *region_name
)
1375 lang_memory_region_name
*n
;
1376 lang_memory_region_type
*r
;
1377 lang_memory_region_type
*region
;
1379 /* The default region must be unique. This ensures that it is not necessary
1380 to iterate through the name list if someone wants the check if a region is
1381 the default memory region. */
1382 if (strcmp (region_name
, DEFAULT_MEMORY_REGION
) == 0
1383 || strcmp (alias
, DEFAULT_MEMORY_REGION
) == 0)
1384 einfo (_("%F%P:%pS: error: alias for default memory region\n"), NULL
);
1386 /* Look for the target region and check if the alias is not already
1389 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1390 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1392 if (region
== NULL
&& strcmp (n
->name
, region_name
) == 0)
1394 if (strcmp (n
->name
, alias
) == 0)
1395 einfo (_("%F%P:%pS: error: redefinition of memory region "
1400 /* Check if the target region exists. */
1402 einfo (_("%F%P:%pS: error: memory region `%s' "
1403 "for alias `%s' does not exist\n"),
1404 NULL
, region_name
, alias
);
1406 /* Add alias to region name list. */
1407 n
= stat_alloc (sizeof (lang_memory_region_name
));
1408 n
->name
= xstrdup (alias
);
1409 n
->next
= region
->name_list
.next
;
1410 region
->name_list
.next
= n
;
1413 static lang_memory_region_type
*
1414 lang_memory_default (asection
*section
)
1416 lang_memory_region_type
*p
;
1418 flagword sec_flags
= section
->flags
;
1420 /* Override SEC_DATA to mean a writable section. */
1421 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
1422 sec_flags
|= SEC_DATA
;
1424 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
1426 if ((p
->flags
& sec_flags
) != 0
1427 && (p
->not_flags
& sec_flags
) == 0)
1432 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
1435 /* Get the output section statement directly from the userdata. */
1437 lang_output_section_statement_type
*
1438 lang_output_section_get (const asection
*output_section
)
1440 return bfd_section_userdata (output_section
);
1443 /* Find or create an output_section_statement with the given NAME.
1444 If CONSTRAINT is non-zero match one with that constraint, otherwise
1445 match any non-negative constraint. If CREATE, always make a
1446 new output_section_statement for SPECIAL CONSTRAINT. */
1448 lang_output_section_statement_type
*
1449 lang_output_section_statement_lookup (const char *name
,
1453 struct out_section_hash_entry
*entry
;
1455 entry
= ((struct out_section_hash_entry
*)
1456 bfd_hash_lookup (&output_section_statement_table
, name
,
1461 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1465 if (entry
->s
.output_section_statement
.name
!= NULL
)
1467 /* We have a section of this name, but it might not have the correct
1469 struct out_section_hash_entry
*last_ent
;
1471 name
= entry
->s
.output_section_statement
.name
;
1472 if (create
&& constraint
== SPECIAL
)
1473 /* Not traversing to the end reverses the order of the second
1474 and subsequent SPECIAL sections in the hash table chain,
1475 but that shouldn't matter. */
1480 if (constraint
== entry
->s
.output_section_statement
.constraint
1482 && entry
->s
.output_section_statement
.constraint
>= 0))
1483 return &entry
->s
.output_section_statement
;
1485 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1487 while (entry
!= NULL
1488 && name
== entry
->s
.output_section_statement
.name
);
1494 = ((struct out_section_hash_entry
*)
1495 output_section_statement_newfunc (NULL
,
1496 &output_section_statement_table
,
1500 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1503 entry
->root
= last_ent
->root
;
1504 last_ent
->root
.next
= &entry
->root
;
1507 entry
->s
.output_section_statement
.name
= name
;
1508 entry
->s
.output_section_statement
.constraint
= constraint
;
1509 return &entry
->s
.output_section_statement
;
1512 /* Find the next output_section_statement with the same name as OS.
1513 If CONSTRAINT is non-zero, find one with that constraint otherwise
1514 match any non-negative constraint. */
1516 lang_output_section_statement_type
*
1517 next_matching_output_section_statement (lang_output_section_statement_type
*os
,
1520 /* All output_section_statements are actually part of a
1521 struct out_section_hash_entry. */
1522 struct out_section_hash_entry
*entry
= (struct out_section_hash_entry
*)
1524 - offsetof (struct out_section_hash_entry
, s
.output_section_statement
));
1525 const char *name
= os
->name
;
1527 ASSERT (name
== entry
->root
.string
);
1530 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1532 || name
!= entry
->s
.output_section_statement
.name
)
1535 while (constraint
!= entry
->s
.output_section_statement
.constraint
1537 || entry
->s
.output_section_statement
.constraint
< 0));
1539 return &entry
->s
.output_section_statement
;
1542 /* A variant of lang_output_section_find used by place_orphan.
1543 Returns the output statement that should precede a new output
1544 statement for SEC. If an exact match is found on certain flags,
1547 lang_output_section_statement_type
*
1548 lang_output_section_find_by_flags (const asection
*sec
,
1550 lang_output_section_statement_type
**exact
,
1551 lang_match_sec_type_func match_type
)
1553 lang_output_section_statement_type
*first
, *look
, *found
;
1554 flagword look_flags
, differ
;
1556 /* We know the first statement on this list is *ABS*. May as well
1558 first
= (void *) lang_os_list
.head
;
1559 first
= first
->next
;
1561 /* First try for an exact match. */
1563 for (look
= first
; look
; look
= look
->next
)
1565 look_flags
= look
->flags
;
1566 if (look
->bfd_section
!= NULL
)
1568 look_flags
= look
->bfd_section
->flags
;
1569 if (match_type
&& !match_type (link_info
.output_bfd
,
1574 differ
= look_flags
^ sec_flags
;
1575 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1576 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1586 if ((sec_flags
& SEC_CODE
) != 0
1587 && (sec_flags
& SEC_ALLOC
) != 0)
1589 /* Try for a rw code section. */
1590 for (look
= first
; look
; look
= look
->next
)
1592 look_flags
= look
->flags
;
1593 if (look
->bfd_section
!= NULL
)
1595 look_flags
= look
->bfd_section
->flags
;
1596 if (match_type
&& !match_type (link_info
.output_bfd
,
1601 differ
= look_flags
^ sec_flags
;
1602 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1603 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1607 else if ((sec_flags
& SEC_READONLY
) != 0
1608 && (sec_flags
& SEC_ALLOC
) != 0)
1610 /* .rodata can go after .text, .sdata2 after .rodata. */
1611 for (look
= first
; look
; look
= look
->next
)
1613 look_flags
= look
->flags
;
1614 if (look
->bfd_section
!= NULL
)
1616 look_flags
= look
->bfd_section
->flags
;
1617 if (match_type
&& !match_type (link_info
.output_bfd
,
1622 differ
= look_flags
^ sec_flags
;
1623 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1624 | SEC_READONLY
| SEC_SMALL_DATA
))
1625 || (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1627 && !(look_flags
& SEC_SMALL_DATA
)))
1631 else if ((sec_flags
& SEC_THREAD_LOCAL
) != 0
1632 && (sec_flags
& SEC_ALLOC
) != 0)
1634 /* .tdata can go after .data, .tbss after .tdata. Treat .tbss
1635 as if it were a loaded section, and don't use match_type. */
1636 bfd_boolean seen_thread_local
= FALSE
;
1639 for (look
= first
; look
; look
= look
->next
)
1641 look_flags
= look
->flags
;
1642 if (look
->bfd_section
!= NULL
)
1643 look_flags
= look
->bfd_section
->flags
;
1645 differ
= look_flags
^ (sec_flags
| SEC_LOAD
| SEC_HAS_CONTENTS
);
1646 if (!(differ
& (SEC_THREAD_LOCAL
| SEC_ALLOC
)))
1648 /* .tdata and .tbss must be adjacent and in that order. */
1649 if (!(look_flags
& SEC_LOAD
)
1650 && (sec_flags
& SEC_LOAD
))
1651 /* ..so if we're at a .tbss section and we're placing
1652 a .tdata section stop looking and return the
1653 previous section. */
1656 seen_thread_local
= TRUE
;
1658 else if (seen_thread_local
)
1660 else if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
)))
1664 else if ((sec_flags
& SEC_SMALL_DATA
) != 0
1665 && (sec_flags
& SEC_ALLOC
) != 0)
1667 /* .sdata goes after .data, .sbss after .sdata. */
1668 for (look
= first
; look
; look
= look
->next
)
1670 look_flags
= look
->flags
;
1671 if (look
->bfd_section
!= NULL
)
1673 look_flags
= look
->bfd_section
->flags
;
1674 if (match_type
&& !match_type (link_info
.output_bfd
,
1679 differ
= look_flags
^ sec_flags
;
1680 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1681 | SEC_THREAD_LOCAL
))
1682 || ((look_flags
& SEC_SMALL_DATA
)
1683 && !(sec_flags
& SEC_HAS_CONTENTS
)))
1687 else if ((sec_flags
& SEC_HAS_CONTENTS
) != 0
1688 && (sec_flags
& SEC_ALLOC
) != 0)
1690 /* .data goes after .rodata. */
1691 for (look
= first
; look
; look
= look
->next
)
1693 look_flags
= look
->flags
;
1694 if (look
->bfd_section
!= NULL
)
1696 look_flags
= look
->bfd_section
->flags
;
1697 if (match_type
&& !match_type (link_info
.output_bfd
,
1702 differ
= look_flags
^ sec_flags
;
1703 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1704 | SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1708 else if ((sec_flags
& SEC_ALLOC
) != 0)
1710 /* .bss goes after any other alloc section. */
1711 for (look
= first
; look
; look
= look
->next
)
1713 look_flags
= look
->flags
;
1714 if (look
->bfd_section
!= NULL
)
1716 look_flags
= look
->bfd_section
->flags
;
1717 if (match_type
&& !match_type (link_info
.output_bfd
,
1722 differ
= look_flags
^ sec_flags
;
1723 if (!(differ
& SEC_ALLOC
))
1729 /* non-alloc go last. */
1730 for (look
= first
; look
; look
= look
->next
)
1732 look_flags
= look
->flags
;
1733 if (look
->bfd_section
!= NULL
)
1734 look_flags
= look
->bfd_section
->flags
;
1735 differ
= look_flags
^ sec_flags
;
1736 if (!(differ
& SEC_DEBUGGING
))
1742 if (found
|| !match_type
)
1745 return lang_output_section_find_by_flags (sec
, sec_flags
, NULL
, NULL
);
1748 /* Find the last output section before given output statement.
1749 Used by place_orphan. */
1752 output_prev_sec_find (lang_output_section_statement_type
*os
)
1754 lang_output_section_statement_type
*lookup
;
1756 for (lookup
= os
->prev
; lookup
!= NULL
; lookup
= lookup
->prev
)
1758 if (lookup
->constraint
< 0)
1761 if (lookup
->bfd_section
!= NULL
&& lookup
->bfd_section
->owner
!= NULL
)
1762 return lookup
->bfd_section
;
1768 /* Look for a suitable place for a new output section statement. The
1769 idea is to skip over anything that might be inside a SECTIONS {}
1770 statement in a script, before we find another output section
1771 statement. Assignments to "dot" before an output section statement
1772 are assumed to belong to it, except in two cases; The first
1773 assignment to dot, and assignments before non-alloc sections.
1774 Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
1775 similar assignments that set the initial address, or we might
1776 insert non-alloc note sections among assignments setting end of
1779 static lang_statement_union_type
**
1780 insert_os_after (lang_output_section_statement_type
*after
)
1782 lang_statement_union_type
**where
;
1783 lang_statement_union_type
**assign
= NULL
;
1784 bfd_boolean ignore_first
;
1786 ignore_first
= after
== (void *) lang_os_list
.head
;
1788 for (where
= &after
->header
.next
;
1790 where
= &(*where
)->header
.next
)
1792 switch ((*where
)->header
.type
)
1794 case lang_assignment_statement_enum
:
1797 lang_assignment_statement_type
*ass
;
1799 ass
= &(*where
)->assignment_statement
;
1800 if (ass
->exp
->type
.node_class
!= etree_assert
1801 && ass
->exp
->assign
.dst
[0] == '.'
1802 && ass
->exp
->assign
.dst
[1] == 0)
1806 ignore_first
= FALSE
;
1810 case lang_wild_statement_enum
:
1811 case lang_input_section_enum
:
1812 case lang_object_symbols_statement_enum
:
1813 case lang_fill_statement_enum
:
1814 case lang_data_statement_enum
:
1815 case lang_reloc_statement_enum
:
1816 case lang_padding_statement_enum
:
1817 case lang_constructors_statement_enum
:
1819 ignore_first
= FALSE
;
1821 case lang_output_section_statement_enum
:
1824 asection
*s
= (*where
)->output_section_statement
.bfd_section
;
1827 || s
->map_head
.s
== NULL
1828 || (s
->flags
& SEC_ALLOC
) != 0)
1832 case lang_input_statement_enum
:
1833 case lang_address_statement_enum
:
1834 case lang_target_statement_enum
:
1835 case lang_output_statement_enum
:
1836 case lang_group_statement_enum
:
1837 case lang_insert_statement_enum
:
1846 lang_output_section_statement_type
*
1847 lang_insert_orphan (asection
*s
,
1848 const char *secname
,
1850 lang_output_section_statement_type
*after
,
1851 struct orphan_save
*place
,
1852 etree_type
*address
,
1853 lang_statement_list_type
*add_child
)
1855 lang_statement_list_type add
;
1856 lang_output_section_statement_type
*os
;
1857 lang_output_section_statement_type
**os_tail
;
1859 /* If we have found an appropriate place for the output section
1860 statements for this orphan, add them to our own private list,
1861 inserting them later into the global statement list. */
1864 lang_list_init (&add
);
1865 push_stat_ptr (&add
);
1868 if (bfd_link_relocatable (&link_info
)
1869 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
1870 address
= exp_intop (0);
1872 os_tail
= (lang_output_section_statement_type
**) lang_os_list
.tail
;
1873 os
= lang_enter_output_section_statement (secname
, address
, normal_section
,
1874 NULL
, NULL
, NULL
, constraint
, 0);
1876 if (add_child
== NULL
)
1877 add_child
= &os
->children
;
1878 lang_add_section (add_child
, s
, NULL
, os
);
1880 if (after
&& (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) != 0)
1882 const char *region
= (after
->region
1883 ? after
->region
->name_list
.name
1884 : DEFAULT_MEMORY_REGION
);
1885 const char *lma_region
= (after
->lma_region
1886 ? after
->lma_region
->name_list
.name
1888 lang_leave_output_section_statement (NULL
, region
, after
->phdrs
,
1892 lang_leave_output_section_statement (NULL
, DEFAULT_MEMORY_REGION
, NULL
,
1895 /* Restore the global list pointer. */
1899 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
1901 asection
*snew
, *as
;
1902 bfd_boolean place_after
= place
->stmt
== NULL
;
1903 bfd_boolean insert_after
= TRUE
;
1905 snew
= os
->bfd_section
;
1907 /* Shuffle the bfd section list to make the output file look
1908 neater. This is really only cosmetic. */
1909 if (place
->section
== NULL
1910 && after
!= (void *) lang_os_list
.head
)
1912 asection
*bfd_section
= after
->bfd_section
;
1914 /* If the output statement hasn't been used to place any input
1915 sections (and thus doesn't have an output bfd_section),
1916 look for the closest prior output statement having an
1918 if (bfd_section
== NULL
)
1919 bfd_section
= output_prev_sec_find (after
);
1921 if (bfd_section
!= NULL
&& bfd_section
!= snew
)
1922 place
->section
= &bfd_section
->next
;
1925 if (place
->section
== NULL
)
1926 place
->section
= &link_info
.output_bfd
->sections
;
1928 as
= *place
->section
;
1932 /* Put the section at the end of the list. */
1934 /* Unlink the section. */
1935 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1937 /* Now tack it back on in the right place. */
1938 bfd_section_list_append (link_info
.output_bfd
, snew
);
1940 else if ((bfd_get_flavour (link_info
.output_bfd
)
1941 == bfd_target_elf_flavour
)
1942 && (bfd_get_flavour (s
->owner
)
1943 == bfd_target_elf_flavour
)
1944 && ((elf_section_type (s
) == SHT_NOTE
1945 && (s
->flags
& SEC_LOAD
) != 0)
1946 || (elf_section_type (as
) == SHT_NOTE
1947 && (as
->flags
& SEC_LOAD
) != 0)))
1949 /* Make sure that output note sections are grouped and sorted
1950 by alignments when inserting a note section or insert a
1951 section after a note section, */
1953 /* A specific section after which the output note section
1954 should be placed. */
1955 asection
*after_sec
;
1956 /* True if we need to insert the orphan section after a
1957 specific section to maintain output note section order. */
1958 bfd_boolean after_sec_note
= FALSE
;
1960 static asection
*first_orphan_note
= NULL
;
1962 /* Group and sort output note section by alignments in
1965 if (elf_section_type (s
) == SHT_NOTE
1966 && (s
->flags
& SEC_LOAD
) != 0)
1968 /* Search from the beginning for the last output note
1969 section with equal or larger alignments. NB: Don't
1970 place orphan note section after non-note sections. */
1972 first_orphan_note
= NULL
;
1973 for (sec
= link_info
.output_bfd
->sections
;
1975 && !bfd_is_abs_section (sec
));
1978 && elf_section_type (sec
) == SHT_NOTE
1979 && (sec
->flags
& SEC_LOAD
) != 0)
1981 if (!first_orphan_note
)
1982 first_orphan_note
= sec
;
1983 if (sec
->alignment_power
>= s
->alignment_power
)
1986 else if (first_orphan_note
)
1988 /* Stop if there is non-note section after the first
1989 orphan note section. */
1993 /* If this will be the first orphan note section, it can
1994 be placed at the default location. */
1995 after_sec_note
= first_orphan_note
!= NULL
;
1996 if (after_sec
== NULL
&& after_sec_note
)
1998 /* If all output note sections have smaller
1999 alignments, place the section before all
2000 output orphan note sections. */
2001 after_sec
= first_orphan_note
;
2002 insert_after
= FALSE
;
2005 else if (first_orphan_note
)
2007 /* Don't place non-note sections in the middle of orphan
2009 after_sec_note
= TRUE
;
2011 for (sec
= as
->next
;
2013 && !bfd_is_abs_section (sec
));
2015 if (elf_section_type (sec
) == SHT_NOTE
2016 && (sec
->flags
& SEC_LOAD
) != 0)
2024 /* Search forward to insert OS after AFTER_SEC output
2026 lang_output_section_statement_type
*stmt
, *next
;
2027 bfd_boolean found
= FALSE
;
2028 for (stmt
= after
; stmt
!= NULL
; stmt
= next
)
2033 if (stmt
->bfd_section
== after_sec
)
2043 /* If INSERT_AFTER is FALSE, place OS before
2044 AFTER_SEC output statement. */
2045 if (next
&& next
->bfd_section
== after_sec
)
2055 /* Search backward to insert OS after AFTER_SEC output
2058 for (stmt
= after
; stmt
!= NULL
; stmt
= stmt
->prev
)
2062 if (stmt
->bfd_section
== after_sec
)
2071 /* If INSERT_AFTER is FALSE, place OS before
2072 AFTER_SEC output statement. */
2073 if (stmt
->next
->bfd_section
== after_sec
)
2083 if (after_sec
== NULL
2084 || (insert_after
&& after_sec
->next
!= snew
)
2085 || (!insert_after
&& after_sec
->prev
!= snew
))
2087 /* Unlink the section. */
2088 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2090 /* Place SNEW after AFTER_SEC. If AFTER_SEC is NULL,
2095 bfd_section_list_insert_after (link_info
.output_bfd
,
2098 bfd_section_list_insert_before (link_info
.output_bfd
,
2102 bfd_section_list_prepend (link_info
.output_bfd
, snew
);
2105 else if (as
!= snew
&& as
->prev
!= snew
)
2107 /* Unlink the section. */
2108 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2110 /* Now tack it back on in the right place. */
2111 bfd_section_list_insert_before (link_info
.output_bfd
,
2115 else if (as
!= snew
&& as
->prev
!= snew
)
2117 /* Unlink the section. */
2118 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2120 /* Now tack it back on in the right place. */
2121 bfd_section_list_insert_before (link_info
.output_bfd
, as
, snew
);
2124 /* Save the end of this list. Further ophans of this type will
2125 follow the one we've just added. */
2126 place
->section
= &snew
->next
;
2128 /* The following is non-cosmetic. We try to put the output
2129 statements in some sort of reasonable order here, because they
2130 determine the final load addresses of the orphan sections.
2131 In addition, placing output statements in the wrong order may
2132 require extra segments. For instance, given a typical
2133 situation of all read-only sections placed in one segment and
2134 following that a segment containing all the read-write
2135 sections, we wouldn't want to place an orphan read/write
2136 section before or amongst the read-only ones. */
2137 if (add
.head
!= NULL
)
2139 lang_output_section_statement_type
*newly_added_os
;
2141 /* Place OS after AFTER if AFTER_NOTE is TRUE. */
2144 lang_statement_union_type
**where
= insert_os_after (after
);
2149 place
->os_tail
= &after
->next
;
2153 /* Put it after the last orphan statement we added. */
2154 *add
.tail
= *place
->stmt
;
2155 *place
->stmt
= add
.head
;
2158 /* Fix the global list pointer if we happened to tack our
2159 new list at the tail. */
2160 if (*stat_ptr
->tail
== add
.head
)
2161 stat_ptr
->tail
= add
.tail
;
2163 /* Save the end of this list. */
2164 place
->stmt
= add
.tail
;
2166 /* Do the same for the list of output section statements. */
2167 newly_added_os
= *os_tail
;
2169 newly_added_os
->prev
= (lang_output_section_statement_type
*)
2170 ((char *) place
->os_tail
2171 - offsetof (lang_output_section_statement_type
, next
));
2172 newly_added_os
->next
= *place
->os_tail
;
2173 if (newly_added_os
->next
!= NULL
)
2174 newly_added_os
->next
->prev
= newly_added_os
;
2175 *place
->os_tail
= newly_added_os
;
2176 place
->os_tail
= &newly_added_os
->next
;
2178 /* Fixing the global list pointer here is a little different.
2179 We added to the list in lang_enter_output_section_statement,
2180 trimmed off the new output_section_statment above when
2181 assigning *os_tail = NULL, but possibly added it back in
2182 the same place when assigning *place->os_tail. */
2183 if (*os_tail
== NULL
)
2184 lang_os_list
.tail
= (lang_statement_union_type
**) os_tail
;
2191 lang_print_asneeded (void)
2193 struct asneeded_minfo
*m
;
2195 if (asneeded_list_head
== NULL
)
2198 minfo (_("\nAs-needed library included to satisfy reference by file (symbol)\n\n"));
2200 for (m
= asneeded_list_head
; m
!= NULL
; m
= m
->next
)
2204 minfo ("%s", m
->soname
);
2205 len
= strlen (m
->soname
);
2219 minfo ("%pB ", m
->ref
);
2220 minfo ("(%pT)\n", m
->name
);
2225 lang_map_flags (flagword flag
)
2227 if (flag
& SEC_ALLOC
)
2230 if (flag
& SEC_CODE
)
2233 if (flag
& SEC_READONLY
)
2236 if (flag
& SEC_DATA
)
2239 if (flag
& SEC_LOAD
)
2246 lang_memory_region_type
*m
;
2247 bfd_boolean dis_header_printed
= FALSE
;
2249 LANG_FOR_EACH_INPUT_STATEMENT (file
)
2253 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
2254 || file
->flags
.just_syms
)
2257 if (config
.print_map_discarded
)
2258 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2259 if ((s
->output_section
== NULL
2260 || s
->output_section
->owner
!= link_info
.output_bfd
)
2261 && (s
->flags
& (SEC_LINKER_CREATED
| SEC_KEEP
)) == 0)
2263 if (! dis_header_printed
)
2265 fprintf (config
.map_file
, _("\nDiscarded input sections\n\n"));
2266 dis_header_printed
= TRUE
;
2269 print_input_section (s
, TRUE
);
2273 minfo (_("\nMemory Configuration\n\n"));
2274 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
2275 _("Name"), _("Origin"), _("Length"), _("Attributes"));
2277 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
2282 fprintf (config
.map_file
, "%-16s ", m
->name_list
.name
);
2284 sprintf_vma (buf
, m
->origin
);
2285 minfo ("0x%s ", buf
);
2293 minfo ("0x%V", m
->length
);
2294 if (m
->flags
|| m
->not_flags
)
2302 lang_map_flags (m
->flags
);
2308 lang_map_flags (m
->not_flags
);
2315 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
2317 if (!link_info
.reduce_memory_overheads
)
2319 obstack_begin (&map_obstack
, 1000);
2320 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
2322 expld
.phase
= lang_fixed_phase_enum
;
2323 lang_statement_iteration
++;
2324 print_statements ();
2326 ldemul_extra_map_file_text (link_info
.output_bfd
, &link_info
,
2331 sort_def_symbol (struct bfd_link_hash_entry
*hash_entry
,
2332 void *info ATTRIBUTE_UNUSED
)
2334 if ((hash_entry
->type
== bfd_link_hash_defined
2335 || hash_entry
->type
== bfd_link_hash_defweak
)
2336 && hash_entry
->u
.def
.section
->owner
!= link_info
.output_bfd
2337 && hash_entry
->u
.def
.section
->owner
!= NULL
)
2339 input_section_userdata_type
*ud
;
2340 struct map_symbol_def
*def
;
2342 ud
= bfd_section_userdata (hash_entry
->u
.def
.section
);
2345 ud
= stat_alloc (sizeof (*ud
));
2346 bfd_set_section_userdata (hash_entry
->u
.def
.section
, ud
);
2347 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2348 ud
->map_symbol_def_count
= 0;
2350 else if (!ud
->map_symbol_def_tail
)
2351 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2353 def
= (struct map_symbol_def
*) obstack_alloc (&map_obstack
, sizeof *def
);
2354 def
->entry
= hash_entry
;
2355 *(ud
->map_symbol_def_tail
) = def
;
2356 ud
->map_symbol_def_tail
= &def
->next
;
2357 ud
->map_symbol_def_count
++;
2362 /* Initialize an output section. */
2365 init_os (lang_output_section_statement_type
*s
, flagword flags
)
2367 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
2368 einfo (_("%F%P: illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
2370 if (s
->constraint
!= SPECIAL
)
2371 s
->bfd_section
= bfd_get_section_by_name (link_info
.output_bfd
, s
->name
);
2372 if (s
->bfd_section
== NULL
)
2373 s
->bfd_section
= bfd_make_section_anyway_with_flags (link_info
.output_bfd
,
2375 if (s
->bfd_section
== NULL
)
2377 einfo (_("%F%P: output format %s cannot represent section"
2378 " called %s: %E\n"),
2379 link_info
.output_bfd
->xvec
->name
, s
->name
);
2381 s
->bfd_section
->output_section
= s
->bfd_section
;
2382 s
->bfd_section
->output_offset
= 0;
2384 /* Set the userdata of the output section to the output section
2385 statement to avoid lookup. */
2386 bfd_set_section_userdata (s
->bfd_section
, s
);
2388 /* If there is a base address, make sure that any sections it might
2389 mention are initialized. */
2390 if (s
->addr_tree
!= NULL
)
2391 exp_init_os (s
->addr_tree
);
2393 if (s
->load_base
!= NULL
)
2394 exp_init_os (s
->load_base
);
2396 /* If supplied an alignment, set it. */
2397 if (s
->section_alignment
!= NULL
)
2398 s
->bfd_section
->alignment_power
= exp_get_power (s
->section_alignment
,
2399 "section alignment");
2402 /* Make sure that all output sections mentioned in an expression are
2406 exp_init_os (etree_type
*exp
)
2408 switch (exp
->type
.node_class
)
2412 case etree_provided
:
2413 exp_init_os (exp
->assign
.src
);
2417 exp_init_os (exp
->binary
.lhs
);
2418 exp_init_os (exp
->binary
.rhs
);
2422 exp_init_os (exp
->trinary
.cond
);
2423 exp_init_os (exp
->trinary
.lhs
);
2424 exp_init_os (exp
->trinary
.rhs
);
2428 exp_init_os (exp
->assert_s
.child
);
2432 exp_init_os (exp
->unary
.child
);
2436 switch (exp
->type
.node_code
)
2442 lang_output_section_statement_type
*os
;
2444 os
= lang_output_section_find (exp
->name
.name
);
2445 if (os
!= NULL
&& os
->bfd_section
== NULL
)
2457 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
2459 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
2461 /* If we are only reading symbols from this object, then we want to
2462 discard all sections. */
2463 if (entry
->flags
.just_syms
)
2465 bfd_link_just_syms (abfd
, sec
, &link_info
);
2469 /* Deal with SHF_EXCLUDE ELF sections. */
2470 if (!bfd_link_relocatable (&link_info
)
2471 && (abfd
->flags
& BFD_PLUGIN
) == 0
2472 && (sec
->flags
& (SEC_GROUP
| SEC_KEEP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
2473 sec
->output_section
= bfd_abs_section_ptr
;
2475 if (!(abfd
->flags
& DYNAMIC
))
2476 bfd_section_already_linked (abfd
, sec
, &link_info
);
2480 /* Returns true if SECTION is one we know will be discarded based on its
2481 section flags, otherwise returns false. */
2484 lang_discard_section_p (asection
*section
)
2486 bfd_boolean discard
;
2487 flagword flags
= section
->flags
;
2489 /* Discard sections marked with SEC_EXCLUDE. */
2490 discard
= (flags
& SEC_EXCLUDE
) != 0;
2492 /* Discard the group descriptor sections when we're finally placing the
2493 sections from within the group. */
2494 if ((flags
& SEC_GROUP
) != 0
2495 && link_info
.resolve_section_groups
)
2498 /* Discard debugging sections if we are stripping debugging
2500 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
2501 && (flags
& SEC_DEBUGGING
) != 0)
2507 /* The wild routines.
2509 These expand statements like *(.text) and foo.o to a list of
2510 explicit actions, like foo.o(.text), bar.o(.text) and
2511 foo.o(.text, .data). */
2513 /* Add SECTION to the output section OUTPUT. Do this by creating a
2514 lang_input_section statement which is placed at PTR. */
2517 lang_add_section (lang_statement_list_type
*ptr
,
2519 struct flag_info
*sflag_info
,
2520 lang_output_section_statement_type
*output
)
2522 flagword flags
= section
->flags
;
2524 bfd_boolean discard
;
2525 lang_input_section_type
*new_section
;
2526 bfd
*abfd
= link_info
.output_bfd
;
2528 /* Is this section one we know should be discarded? */
2529 discard
= lang_discard_section_p (section
);
2531 /* Discard input sections which are assigned to a section named
2532 DISCARD_SECTION_NAME. */
2533 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
2538 if (section
->output_section
== NULL
)
2540 /* This prevents future calls from assigning this section. */
2541 section
->output_section
= bfd_abs_section_ptr
;
2550 keep
= bfd_lookup_section_flags (&link_info
, sflag_info
, section
);
2555 if (section
->output_section
!= NULL
)
2558 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2559 to an output section, because we want to be able to include a
2560 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2561 section (I don't know why we want to do this, but we do).
2562 build_link_order in ldwrite.c handles this case by turning
2563 the embedded SEC_NEVER_LOAD section into a fill. */
2564 flags
&= ~ SEC_NEVER_LOAD
;
2566 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2567 already been processed. One reason to do this is that on pe
2568 format targets, .text$foo sections go into .text and it's odd
2569 to see .text with SEC_LINK_ONCE set. */
2570 if ((flags
& (SEC_LINK_ONCE
| SEC_GROUP
)) == (SEC_LINK_ONCE
| SEC_GROUP
))
2572 if (link_info
.resolve_section_groups
)
2573 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2575 flags
&= ~(SEC_LINK_DUPLICATES
| SEC_RELOC
);
2577 else if (!bfd_link_relocatable (&link_info
))
2578 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2580 switch (output
->sectype
)
2582 case normal_section
:
2583 case overlay_section
:
2584 case first_overlay_section
:
2586 case noalloc_section
:
2587 flags
&= ~SEC_ALLOC
;
2589 case noload_section
:
2591 flags
|= SEC_NEVER_LOAD
;
2592 /* Unfortunately GNU ld has managed to evolve two different
2593 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2594 alloc, no contents section. All others get a noload, noalloc
2596 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
2597 flags
&= ~SEC_HAS_CONTENTS
;
2599 flags
&= ~SEC_ALLOC
;
2603 if (output
->bfd_section
== NULL
)
2604 init_os (output
, flags
);
2606 /* If SEC_READONLY is not set in the input section, then clear
2607 it from the output section. */
2608 output
->bfd_section
->flags
&= flags
| ~SEC_READONLY
;
2610 if (output
->bfd_section
->linker_has_input
)
2612 /* Only set SEC_READONLY flag on the first input section. */
2613 flags
&= ~ SEC_READONLY
;
2615 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2616 if ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2617 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2618 || ((flags
& SEC_MERGE
) != 0
2619 && output
->bfd_section
->entsize
!= section
->entsize
))
2621 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2622 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2625 output
->bfd_section
->flags
|= flags
;
2627 if (!output
->bfd_section
->linker_has_input
)
2629 output
->bfd_section
->linker_has_input
= 1;
2630 /* This must happen after flags have been updated. The output
2631 section may have been created before we saw its first input
2632 section, eg. for a data statement. */
2633 bfd_init_private_section_data (section
->owner
, section
,
2634 link_info
.output_bfd
,
2635 output
->bfd_section
,
2637 if ((flags
& SEC_MERGE
) != 0)
2638 output
->bfd_section
->entsize
= section
->entsize
;
2641 if ((flags
& SEC_TIC54X_BLOCK
) != 0
2642 && bfd_get_arch (section
->owner
) == bfd_arch_tic54x
)
2644 /* FIXME: This value should really be obtained from the bfd... */
2645 output
->block_value
= 128;
2648 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2649 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2651 section
->output_section
= output
->bfd_section
;
2653 if (!map_head_is_link_order
)
2655 asection
*s
= output
->bfd_section
->map_tail
.s
;
2656 output
->bfd_section
->map_tail
.s
= section
;
2657 section
->map_head
.s
= NULL
;
2658 section
->map_tail
.s
= s
;
2660 s
->map_head
.s
= section
;
2662 output
->bfd_section
->map_head
.s
= section
;
2665 /* Add a section reference to the list. */
2666 new_section
= new_stat (lang_input_section
, ptr
);
2667 new_section
->section
= section
;
2670 /* Handle wildcard sorting. This returns the lang_input_section which
2671 should follow the one we are going to create for SECTION and FILE,
2672 based on the sorting requirements of WILD. It returns NULL if the
2673 new section should just go at the end of the current list. */
2675 static lang_statement_union_type
*
2676 wild_sort (lang_wild_statement_type
*wild
,
2677 struct wildcard_list
*sec
,
2678 lang_input_statement_type
*file
,
2681 lang_statement_union_type
*l
;
2683 if (!wild
->filenames_sorted
2684 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
2687 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
2689 lang_input_section_type
*ls
;
2691 if (l
->header
.type
!= lang_input_section_enum
)
2693 ls
= &l
->input_section
;
2695 /* Sorting by filename takes precedence over sorting by section
2698 if (wild
->filenames_sorted
)
2700 const char *fn
, *ln
;
2704 /* The PE support for the .idata section as generated by
2705 dlltool assumes that files will be sorted by the name of
2706 the archive and then the name of the file within the
2709 if (file
->the_bfd
!= NULL
2710 && file
->the_bfd
->my_archive
!= NULL
)
2712 fn
= bfd_get_filename (file
->the_bfd
->my_archive
);
2717 fn
= file
->filename
;
2721 if (ls
->section
->owner
->my_archive
!= NULL
)
2723 ln
= bfd_get_filename (ls
->section
->owner
->my_archive
);
2728 ln
= ls
->section
->owner
->filename
;
2732 i
= filename_cmp (fn
, ln
);
2741 fn
= file
->filename
;
2743 ln
= ls
->section
->owner
->filename
;
2745 i
= filename_cmp (fn
, ln
);
2753 /* Here either the files are not sorted by name, or we are
2754 looking at the sections for this file. */
2757 && sec
->spec
.sorted
!= none
2758 && sec
->spec
.sorted
!= by_none
)
2759 if (compare_section (sec
->spec
.sorted
, section
, ls
->section
) < 0)
2766 /* Expand a wild statement for a particular FILE. SECTION may be
2767 NULL, in which case it is a wild card. */
2770 output_section_callback (lang_wild_statement_type
*ptr
,
2771 struct wildcard_list
*sec
,
2773 struct flag_info
*sflag_info
,
2774 lang_input_statement_type
*file
,
2777 lang_statement_union_type
*before
;
2778 lang_output_section_statement_type
*os
;
2780 os
= (lang_output_section_statement_type
*) output
;
2782 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2783 if (unique_section_p (section
, os
))
2786 before
= wild_sort (ptr
, sec
, file
, section
);
2788 /* Here BEFORE points to the lang_input_section which
2789 should follow the one we are about to add. If BEFORE
2790 is NULL, then the section should just go at the end
2791 of the current list. */
2794 lang_add_section (&ptr
->children
, section
, sflag_info
, os
);
2797 lang_statement_list_type list
;
2798 lang_statement_union_type
**pp
;
2800 lang_list_init (&list
);
2801 lang_add_section (&list
, section
, sflag_info
, os
);
2803 /* If we are discarding the section, LIST.HEAD will
2805 if (list
.head
!= NULL
)
2807 ASSERT (list
.head
->header
.next
== NULL
);
2809 for (pp
= &ptr
->children
.head
;
2811 pp
= &(*pp
)->header
.next
)
2812 ASSERT (*pp
!= NULL
);
2814 list
.head
->header
.next
= *pp
;
2820 /* Check if all sections in a wild statement for a particular FILE
2824 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2825 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2827 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
2828 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2831 lang_output_section_statement_type
*os
;
2833 os
= (lang_output_section_statement_type
*) output
;
2835 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2836 if (unique_section_p (section
, os
))
2839 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2840 os
->all_input_readonly
= FALSE
;
2843 /* This is passed a file name which must have been seen already and
2844 added to the statement tree. We will see if it has been opened
2845 already and had its symbols read. If not then we'll read it. */
2847 static lang_input_statement_type
*
2848 lookup_name (const char *name
)
2850 lang_input_statement_type
*search
;
2852 for (search
= (void *) input_file_chain
.head
;
2854 search
= search
->next_real_file
)
2856 /* Use the local_sym_name as the name of the file that has
2857 already been loaded as filename might have been transformed
2858 via the search directory lookup mechanism. */
2859 const char *filename
= search
->local_sym_name
;
2861 if (filename
!= NULL
2862 && filename_cmp (filename
, name
) == 0)
2868 /* Arrange to splice the input statement added by new_afile into
2869 statement_list after the current input_file_chain tail.
2870 We know input_file_chain is not an empty list, and that
2871 lookup_name was called via open_input_bfds. Later calls to
2872 lookup_name should always match an existing input_statement. */
2873 lang_statement_union_type
**tail
= stat_ptr
->tail
;
2874 lang_statement_union_type
**after
2875 = (void *) ((char *) input_file_chain
.tail
2876 - offsetof (lang_input_statement_type
, next_real_file
)
2877 + offsetof (lang_input_statement_type
, header
.next
));
2878 lang_statement_union_type
*rest
= *after
;
2879 stat_ptr
->tail
= after
;
2880 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2882 *stat_ptr
->tail
= rest
;
2884 stat_ptr
->tail
= tail
;
2887 /* If we have already added this file, or this file is not real
2888 don't add this file. */
2889 if (search
->flags
.loaded
|| !search
->flags
.real
)
2892 if (!load_symbols (search
, NULL
))
2898 /* Save LIST as a list of libraries whose symbols should not be exported. */
2903 struct excluded_lib
*next
;
2905 static struct excluded_lib
*excluded_libs
;
2908 add_excluded_libs (const char *list
)
2910 const char *p
= list
, *end
;
2914 struct excluded_lib
*entry
;
2915 end
= strpbrk (p
, ",:");
2917 end
= p
+ strlen (p
);
2918 entry
= (struct excluded_lib
*) xmalloc (sizeof (*entry
));
2919 entry
->next
= excluded_libs
;
2920 entry
->name
= (char *) xmalloc (end
- p
+ 1);
2921 memcpy (entry
->name
, p
, end
- p
);
2922 entry
->name
[end
- p
] = '\0';
2923 excluded_libs
= entry
;
2931 check_excluded_libs (bfd
*abfd
)
2933 struct excluded_lib
*lib
= excluded_libs
;
2937 int len
= strlen (lib
->name
);
2938 const char *filename
= lbasename (abfd
->filename
);
2940 if (strcmp (lib
->name
, "ALL") == 0)
2942 abfd
->no_export
= TRUE
;
2946 if (filename_ncmp (lib
->name
, filename
, len
) == 0
2947 && (filename
[len
] == '\0'
2948 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
2949 && filename
[len
+ 2] == '\0')))
2951 abfd
->no_export
= TRUE
;
2959 /* Get the symbols for an input file. */
2962 load_symbols (lang_input_statement_type
*entry
,
2963 lang_statement_list_type
*place
)
2967 if (entry
->flags
.loaded
)
2970 ldfile_open_file (entry
);
2972 /* Do not process further if the file was missing. */
2973 if (entry
->flags
.missing_file
)
2976 if (trace_files
|| verbose
)
2977 info_msg ("%pI\n", entry
);
2979 if (!bfd_check_format (entry
->the_bfd
, bfd_archive
)
2980 && !bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
2983 struct lang_input_statement_flags save_flags
;
2986 err
= bfd_get_error ();
2988 /* See if the emulation has some special knowledge. */
2989 if (ldemul_unrecognized_file (entry
))
2992 if (err
== bfd_error_file_ambiguously_recognized
)
2996 einfo (_("%P: %pB: file not recognized: %E;"
2997 " matching formats:"), entry
->the_bfd
);
2998 for (p
= matching
; *p
!= NULL
; p
++)
3002 else if (err
!= bfd_error_file_not_recognized
3004 einfo (_("%F%P: %pB: file not recognized: %E\n"), entry
->the_bfd
);
3006 bfd_close (entry
->the_bfd
);
3007 entry
->the_bfd
= NULL
;
3009 /* Try to interpret the file as a linker script. */
3010 save_flags
= input_flags
;
3011 ldfile_open_command_file (entry
->filename
);
3013 push_stat_ptr (place
);
3014 input_flags
.add_DT_NEEDED_for_regular
3015 = entry
->flags
.add_DT_NEEDED_for_regular
;
3016 input_flags
.add_DT_NEEDED_for_dynamic
3017 = entry
->flags
.add_DT_NEEDED_for_dynamic
;
3018 input_flags
.whole_archive
= entry
->flags
.whole_archive
;
3019 input_flags
.dynamic
= entry
->flags
.dynamic
;
3021 ldfile_assumed_script
= TRUE
;
3022 parser_input
= input_script
;
3024 ldfile_assumed_script
= FALSE
;
3026 /* missing_file is sticky. sysrooted will already have been
3027 restored when seeing EOF in yyparse, but no harm to restore
3029 save_flags
.missing_file
|= input_flags
.missing_file
;
3030 input_flags
= save_flags
;
3034 entry
->flags
.loaded
= TRUE
;
3039 if (ldemul_recognized_file (entry
))
3042 /* We don't call ldlang_add_file for an archive. Instead, the
3043 add_symbols entry point will call ldlang_add_file, via the
3044 add_archive_element callback, for each element of the archive
3046 switch (bfd_get_format (entry
->the_bfd
))
3052 if (!entry
->flags
.reload
)
3053 ldlang_add_file (entry
);
3057 check_excluded_libs (entry
->the_bfd
);
3059 bfd_set_usrdata (entry
->the_bfd
, entry
);
3060 if (entry
->flags
.whole_archive
)
3063 bfd_boolean loaded
= TRUE
;
3068 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
3073 if (!bfd_check_format (member
, bfd_object
))
3075 einfo (_("%F%P: %pB: member %pB in archive is not an object\n"),
3076 entry
->the_bfd
, member
);
3081 if (!(*link_info
.callbacks
3082 ->add_archive_element
) (&link_info
, member
,
3083 "--whole-archive", &subsbfd
))
3086 /* Potentially, the add_archive_element hook may have set a
3087 substitute BFD for us. */
3088 if (!bfd_link_add_symbols (subsbfd
, &link_info
))
3090 einfo (_("%F%P: %pB: error adding symbols: %E\n"), member
);
3095 entry
->flags
.loaded
= loaded
;
3101 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
3102 entry
->flags
.loaded
= TRUE
;
3104 einfo (_("%F%P: %pB: error adding symbols: %E\n"), entry
->the_bfd
);
3106 return entry
->flags
.loaded
;
3109 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
3110 may be NULL, indicating that it is a wildcard. Separate
3111 lang_input_section statements are created for each part of the
3112 expansion; they are added after the wild statement S. OUTPUT is
3113 the output section. */
3116 wild (lang_wild_statement_type
*s
,
3117 const char *target ATTRIBUTE_UNUSED
,
3118 lang_output_section_statement_type
*output
)
3120 struct wildcard_list
*sec
;
3122 if (s
->handler_data
[0]
3123 && s
->handler_data
[0]->spec
.sorted
== by_name
3124 && !s
->filenames_sorted
)
3126 lang_section_bst_type
*tree
;
3128 walk_wild (s
, output_section_callback_fast
, output
);
3133 output_section_callback_tree_to_list (s
, tree
, output
);
3138 walk_wild (s
, output_section_callback
, output
);
3140 if (default_common_section
== NULL
)
3141 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
3142 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
3144 /* Remember the section that common is going to in case we
3145 later get something which doesn't know where to put it. */
3146 default_common_section
= output
;
3151 /* Return TRUE iff target is the sought target. */
3154 get_target (const bfd_target
*target
, void *data
)
3156 const char *sought
= (const char *) data
;
3158 return strcmp (target
->name
, sought
) == 0;
3161 /* Like strcpy() but convert to lower case as well. */
3164 stricpy (char *dest
, const char *src
)
3168 while ((c
= *src
++) != 0)
3169 *dest
++ = TOLOWER (c
);
3174 /* Remove the first occurrence of needle (if any) in haystack
3178 strcut (char *haystack
, const char *needle
)
3180 haystack
= strstr (haystack
, needle
);
3186 for (src
= haystack
+ strlen (needle
); *src
;)
3187 *haystack
++ = *src
++;
3193 /* Compare two target format name strings.
3194 Return a value indicating how "similar" they are. */
3197 name_compare (const char *first
, const char *second
)
3203 copy1
= (char *) xmalloc (strlen (first
) + 1);
3204 copy2
= (char *) xmalloc (strlen (second
) + 1);
3206 /* Convert the names to lower case. */
3207 stricpy (copy1
, first
);
3208 stricpy (copy2
, second
);
3210 /* Remove size and endian strings from the name. */
3211 strcut (copy1
, "big");
3212 strcut (copy1
, "little");
3213 strcut (copy2
, "big");
3214 strcut (copy2
, "little");
3216 /* Return a value based on how many characters match,
3217 starting from the beginning. If both strings are
3218 the same then return 10 * their length. */
3219 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
3220 if (copy1
[result
] == 0)
3232 /* Set by closest_target_match() below. */
3233 static const bfd_target
*winner
;
3235 /* Scan all the valid bfd targets looking for one that has the endianness
3236 requirement that was specified on the command line, and is the nearest
3237 match to the original output target. */
3240 closest_target_match (const bfd_target
*target
, void *data
)
3242 const bfd_target
*original
= (const bfd_target
*) data
;
3244 if (command_line
.endian
== ENDIAN_BIG
3245 && target
->byteorder
!= BFD_ENDIAN_BIG
)
3248 if (command_line
.endian
== ENDIAN_LITTLE
3249 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
3252 /* Must be the same flavour. */
3253 if (target
->flavour
!= original
->flavour
)
3256 /* Ignore generic big and little endian elf vectors. */
3257 if (strcmp (target
->name
, "elf32-big") == 0
3258 || strcmp (target
->name
, "elf64-big") == 0
3259 || strcmp (target
->name
, "elf32-little") == 0
3260 || strcmp (target
->name
, "elf64-little") == 0)
3263 /* If we have not found a potential winner yet, then record this one. */
3270 /* Oh dear, we now have two potential candidates for a successful match.
3271 Compare their names and choose the better one. */
3272 if (name_compare (target
->name
, original
->name
)
3273 > name_compare (winner
->name
, original
->name
))
3276 /* Keep on searching until wqe have checked them all. */
3280 /* Return the BFD target format of the first input file. */
3283 get_first_input_target (void)
3285 const char *target
= NULL
;
3287 LANG_FOR_EACH_INPUT_STATEMENT (s
)
3289 if (s
->header
.type
== lang_input_statement_enum
3292 ldfile_open_file (s
);
3294 if (s
->the_bfd
!= NULL
3295 && bfd_check_format (s
->the_bfd
, bfd_object
))
3297 target
= bfd_get_target (s
->the_bfd
);
3309 lang_get_output_target (void)
3313 /* Has the user told us which output format to use? */
3314 if (output_target
!= NULL
)
3315 return output_target
;
3317 /* No - has the current target been set to something other than
3319 if (current_target
!= default_target
&& current_target
!= NULL
)
3320 return current_target
;
3322 /* No - can we determine the format of the first input file? */
3323 target
= get_first_input_target ();
3327 /* Failed - use the default output target. */
3328 return default_target
;
3331 /* Open the output file. */
3334 open_output (const char *name
)
3336 output_target
= lang_get_output_target ();
3338 /* Has the user requested a particular endianness on the command
3340 if (command_line
.endian
!= ENDIAN_UNSET
)
3342 /* Get the chosen target. */
3343 const bfd_target
*target
3344 = bfd_iterate_over_targets (get_target
, (void *) output_target
);
3346 /* If the target is not supported, we cannot do anything. */
3349 enum bfd_endian desired_endian
;
3351 if (command_line
.endian
== ENDIAN_BIG
)
3352 desired_endian
= BFD_ENDIAN_BIG
;
3354 desired_endian
= BFD_ENDIAN_LITTLE
;
3356 /* See if the target has the wrong endianness. This should
3357 not happen if the linker script has provided big and
3358 little endian alternatives, but some scrips don't do
3360 if (target
->byteorder
!= desired_endian
)
3362 /* If it does, then see if the target provides
3363 an alternative with the correct endianness. */
3364 if (target
->alternative_target
!= NULL
3365 && (target
->alternative_target
->byteorder
== desired_endian
))
3366 output_target
= target
->alternative_target
->name
;
3369 /* Try to find a target as similar as possible to
3370 the default target, but which has the desired
3371 endian characteristic. */
3372 bfd_iterate_over_targets (closest_target_match
,
3375 /* Oh dear - we could not find any targets that
3376 satisfy our requirements. */
3378 einfo (_("%P: warning: could not find any targets"
3379 " that match endianness requirement\n"));
3381 output_target
= winner
->name
;
3387 link_info
.output_bfd
= bfd_openw (name
, output_target
);
3389 if (link_info
.output_bfd
== NULL
)
3391 if (bfd_get_error () == bfd_error_invalid_target
)
3392 einfo (_("%F%P: target %s not found\n"), output_target
);
3394 einfo (_("%F%P: cannot open output file %s: %E\n"), name
);
3397 delete_output_file_on_failure
= TRUE
;
3399 if (!bfd_set_format (link_info
.output_bfd
, bfd_object
))
3400 einfo (_("%F%P: %s: can not make object file: %E\n"), name
);
3401 if (!bfd_set_arch_mach (link_info
.output_bfd
,
3402 ldfile_output_architecture
,
3403 ldfile_output_machine
))
3404 einfo (_("%F%P: %s: can not set architecture: %E\n"), name
);
3406 link_info
.hash
= bfd_link_hash_table_create (link_info
.output_bfd
);
3407 if (link_info
.hash
== NULL
)
3408 einfo (_("%F%P: can not create hash table: %E\n"));
3410 bfd_set_gp_size (link_info
.output_bfd
, g_switch_value
);
3414 ldlang_open_output (lang_statement_union_type
*statement
)
3416 switch (statement
->header
.type
)
3418 case lang_output_statement_enum
:
3419 ASSERT (link_info
.output_bfd
== NULL
);
3420 open_output (statement
->output_statement
.name
);
3421 ldemul_set_output_arch ();
3422 if (config
.magic_demand_paged
3423 && !bfd_link_relocatable (&link_info
))
3424 link_info
.output_bfd
->flags
|= D_PAGED
;
3426 link_info
.output_bfd
->flags
&= ~D_PAGED
;
3427 if (config
.text_read_only
)
3428 link_info
.output_bfd
->flags
|= WP_TEXT
;
3430 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
3431 if (link_info
.traditional_format
)
3432 link_info
.output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
3434 link_info
.output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
3437 case lang_target_statement_enum
:
3438 current_target
= statement
->target_statement
.target
;
3446 init_opb (asection
*s
)
3451 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
3453 && (s
->flags
& SEC_ELF_OCTETS
) != 0)
3456 x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3457 ldfile_output_machine
);
3459 while ((x
& 1) == 0)
3467 /* Open all the input files. */
3471 OPEN_BFD_NORMAL
= 0,
3475 #ifdef ENABLE_PLUGINS
3476 static lang_input_statement_type
*plugin_insert
= NULL
;
3477 static struct bfd_link_hash_entry
*plugin_undefs
= NULL
;
3481 open_input_bfds (lang_statement_union_type
*s
, enum open_bfd_mode mode
)
3483 for (; s
!= NULL
; s
= s
->header
.next
)
3485 switch (s
->header
.type
)
3487 case lang_constructors_statement_enum
:
3488 open_input_bfds (constructor_list
.head
, mode
);
3490 case lang_output_section_statement_enum
:
3491 open_input_bfds (s
->output_section_statement
.children
.head
, mode
);
3493 case lang_wild_statement_enum
:
3494 /* Maybe we should load the file's symbols. */
3495 if ((mode
& OPEN_BFD_RESCAN
) == 0
3496 && s
->wild_statement
.filename
3497 && !wildcardp (s
->wild_statement
.filename
)
3498 && !archive_path (s
->wild_statement
.filename
))
3499 lookup_name (s
->wild_statement
.filename
);
3500 open_input_bfds (s
->wild_statement
.children
.head
, mode
);
3502 case lang_group_statement_enum
:
3504 struct bfd_link_hash_entry
*undefs
;
3505 #ifdef ENABLE_PLUGINS
3506 lang_input_statement_type
*plugin_insert_save
;
3509 /* We must continually search the entries in the group
3510 until no new symbols are added to the list of undefined
3515 #ifdef ENABLE_PLUGINS
3516 plugin_insert_save
= plugin_insert
;
3518 undefs
= link_info
.hash
->undefs_tail
;
3519 open_input_bfds (s
->group_statement
.children
.head
,
3520 mode
| OPEN_BFD_FORCE
);
3522 while (undefs
!= link_info
.hash
->undefs_tail
3523 #ifdef ENABLE_PLUGINS
3524 /* Objects inserted by a plugin, which are loaded
3525 before we hit this loop, may have added new
3527 || (plugin_insert
!= plugin_insert_save
&& plugin_undefs
)
3532 case lang_target_statement_enum
:
3533 current_target
= s
->target_statement
.target
;
3535 case lang_input_statement_enum
:
3536 if (s
->input_statement
.flags
.real
)
3538 lang_statement_union_type
**os_tail
;
3539 lang_statement_list_type add
;
3542 s
->input_statement
.target
= current_target
;
3544 /* If we are being called from within a group, and this
3545 is an archive which has already been searched, then
3546 force it to be researched unless the whole archive
3547 has been loaded already. Do the same for a rescan.
3548 Likewise reload --as-needed shared libs. */
3549 if (mode
!= OPEN_BFD_NORMAL
3550 #ifdef ENABLE_PLUGINS
3551 && ((mode
& OPEN_BFD_RESCAN
) == 0
3552 || plugin_insert
== NULL
)
3554 && s
->input_statement
.flags
.loaded
3555 && (abfd
= s
->input_statement
.the_bfd
) != NULL
3556 && ((bfd_get_format (abfd
) == bfd_archive
3557 && !s
->input_statement
.flags
.whole_archive
)
3558 || (bfd_get_format (abfd
) == bfd_object
3559 && ((abfd
->flags
) & DYNAMIC
) != 0
3560 && s
->input_statement
.flags
.add_DT_NEEDED_for_regular
3561 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3562 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)))
3564 s
->input_statement
.flags
.loaded
= FALSE
;
3565 s
->input_statement
.flags
.reload
= TRUE
;
3568 os_tail
= lang_os_list
.tail
;
3569 lang_list_init (&add
);
3571 if (!load_symbols (&s
->input_statement
, &add
))
3572 config
.make_executable
= FALSE
;
3574 if (add
.head
!= NULL
)
3576 /* If this was a script with output sections then
3577 tack any added statements on to the end of the
3578 list. This avoids having to reorder the output
3579 section statement list. Very likely the user
3580 forgot -T, and whatever we do here will not meet
3581 naive user expectations. */
3582 if (os_tail
!= lang_os_list
.tail
)
3584 einfo (_("%P: warning: %s contains output sections;"
3585 " did you forget -T?\n"),
3586 s
->input_statement
.filename
);
3587 *stat_ptr
->tail
= add
.head
;
3588 stat_ptr
->tail
= add
.tail
;
3592 *add
.tail
= s
->header
.next
;
3593 s
->header
.next
= add
.head
;
3597 #ifdef ENABLE_PLUGINS
3598 /* If we have found the point at which a plugin added new
3599 files, clear plugin_insert to enable archive rescan. */
3600 if (&s
->input_statement
== plugin_insert
)
3601 plugin_insert
= NULL
;
3604 case lang_assignment_statement_enum
:
3605 if (s
->assignment_statement
.exp
->type
.node_class
!= etree_assert
)
3606 exp_fold_tree_no_dot (s
->assignment_statement
.exp
);
3613 /* Exit if any of the files were missing. */
3614 if (input_flags
.missing_file
)
3618 /* Open the CTF sections in the input files with libctf: if any were opened,
3619 create a fake input file that we'll write the merged CTF data to later
3623 ldlang_open_ctf (void)
3628 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3632 /* Incoming files from the compiler have a single ctf_file_t in them
3633 (which is presented to us by the libctf API in a ctf_archive_t
3634 wrapper): files derived from a previous relocatable link have a CTF
3635 archive containing possibly many CTF files. */
3637 if ((file
->the_ctf
= ctf_bfdopen (file
->the_bfd
, &err
)) == NULL
)
3639 if (err
!= ECTF_NOCTFDATA
)
3640 einfo (_("%P: warning: CTF section in `%pI' not loaded: "
3641 "its types will be discarded: `%s'\n"), file
,
3646 /* Prevent the contents of this section from being written, while
3647 requiring the section itself to be duplicated in the output. */
3648 /* This section must exist if ctf_bfdopen() succeeded. */
3649 sect
= bfd_get_section_by_name (file
->the_bfd
, ".ctf");
3651 sect
->flags
|= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
| SEC_LINKER_CREATED
;
3662 if ((ctf_output
= ctf_create (&err
)) != NULL
)
3665 einfo (_("%P: warning: CTF output not created: `%s'\n"),
3668 LANG_FOR_EACH_INPUT_STATEMENT (errfile
)
3669 ctf_close (errfile
->the_ctf
);
3672 /* Merge together CTF sections. After this, only the symtab-dependent
3673 function and data object sections need adjustment. */
3676 lang_merge_ctf (void)
3678 asection
*output_sect
;
3683 output_sect
= bfd_get_section_by_name (link_info
.output_bfd
, ".ctf");
3685 /* If the section was discarded, don't waste time merging. */
3686 if (output_sect
== NULL
)
3688 ctf_file_close (ctf_output
);
3691 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3693 ctf_close (file
->the_ctf
);
3694 file
->the_ctf
= NULL
;
3699 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3704 /* Takes ownership of file->u.the_ctfa. */
3705 if (ctf_link_add_ctf (ctf_output
, file
->the_ctf
, file
->filename
) < 0)
3707 einfo (_("%F%P: cannot link with CTF in %pB: %s\n"), file
->the_bfd
,
3708 ctf_errmsg (ctf_errno (ctf_output
)));
3709 ctf_close (file
->the_ctf
);
3710 file
->the_ctf
= NULL
;
3715 if (ctf_link (ctf_output
, CTF_LINK_SHARE_UNCONFLICTED
) < 0)
3717 einfo (_("%F%P: CTF linking failed; output will have no CTF section: %s\n"),
3718 ctf_errmsg (ctf_errno (ctf_output
)));
3721 output_sect
->size
= 0;
3722 output_sect
->flags
|= SEC_EXCLUDE
;
3727 /* Let the emulation examine the symbol table and strtab to help it optimize the
3728 CTF, if supported. */
3731 ldlang_ctf_apply_strsym (struct elf_sym_strtab
*syms
, bfd_size_type symcount
,
3732 struct elf_strtab_hash
*symstrtab
)
3734 ldemul_examine_strtab_for_ctf (ctf_output
, syms
, symcount
, symstrtab
);
3737 /* Write out the CTF section. Called early, if the emulation isn't going to
3738 need to dedup against the strtab and symtab, then possibly called from the
3739 target linker code if the dedup has happened. */
3741 lang_write_ctf (int late
)
3744 asection
*output_sect
;
3751 /* Emit CTF late if this emulation says it can do so. */
3752 if (ldemul_emit_ctf_early ())
3757 if (!ldemul_emit_ctf_early ())
3763 output_sect
= bfd_get_section_by_name (link_info
.output_bfd
, ".ctf");
3766 output_sect
->contents
= ctf_link_write (ctf_output
, &output_size
,
3767 CTF_COMPRESSION_THRESHOLD
);
3768 output_sect
->size
= output_size
;
3769 output_sect
->flags
|= SEC_IN_MEMORY
| SEC_KEEP
;
3771 if (!output_sect
->contents
)
3773 einfo (_("%F%P: CTF section emission failed; output will have no "
3774 "CTF section: %s\n"), ctf_errmsg (ctf_errno (ctf_output
)));
3775 output_sect
->size
= 0;
3776 output_sect
->flags
|= SEC_EXCLUDE
;
3780 /* This also closes every CTF input file used in the link. */
3781 ctf_file_close (ctf_output
);
3784 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3785 file
->the_ctf
= NULL
;
3788 /* Write out the CTF section late, if the emulation needs that. */
3791 ldlang_write_ctf_late (void)
3793 /* Trigger a "late call", if the emulation needs one. */
3798 /* Add the supplied name to the symbol table as an undefined reference.
3799 This is a two step process as the symbol table doesn't even exist at
3800 the time the ld command line is processed. First we put the name
3801 on a list, then, once the output file has been opened, transfer the
3802 name to the symbol table. */
3804 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3806 #define ldlang_undef_chain_list_head entry_symbol.next
3809 ldlang_add_undef (const char *const name
, bfd_boolean cmdline
)
3811 ldlang_undef_chain_list_type
*new_undef
;
3813 undef_from_cmdline
= undef_from_cmdline
|| cmdline
;
3814 new_undef
= stat_alloc (sizeof (*new_undef
));
3815 new_undef
->next
= ldlang_undef_chain_list_head
;
3816 ldlang_undef_chain_list_head
= new_undef
;
3818 new_undef
->name
= xstrdup (name
);
3820 if (link_info
.output_bfd
!= NULL
)
3821 insert_undefined (new_undef
->name
);
3824 /* Insert NAME as undefined in the symbol table. */
3827 insert_undefined (const char *name
)
3829 struct bfd_link_hash_entry
*h
;
3831 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
3833 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
3834 if (h
->type
== bfd_link_hash_new
)
3836 h
->type
= bfd_link_hash_undefined
;
3837 h
->u
.undef
.abfd
= NULL
;
3838 h
->non_ir_ref_regular
= TRUE
;
3839 if (is_elf_hash_table (link_info
.hash
))
3840 ((struct elf_link_hash_entry
*) h
)->mark
= 1;
3841 bfd_link_add_undef (link_info
.hash
, h
);
3845 /* Run through the list of undefineds created above and place them
3846 into the linker hash table as undefined symbols belonging to the
3850 lang_place_undefineds (void)
3852 ldlang_undef_chain_list_type
*ptr
;
3854 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3855 insert_undefined (ptr
->name
);
3858 /* Structure used to build the list of symbols that the user has required
3861 struct require_defined_symbol
3864 struct require_defined_symbol
*next
;
3867 /* The list of symbols that the user has required be defined. */
3869 static struct require_defined_symbol
*require_defined_symbol_list
;
3871 /* Add a new symbol NAME to the list of symbols that are required to be
3875 ldlang_add_require_defined (const char *const name
)
3877 struct require_defined_symbol
*ptr
;
3879 ldlang_add_undef (name
, TRUE
);
3880 ptr
= stat_alloc (sizeof (*ptr
));
3881 ptr
->next
= require_defined_symbol_list
;
3882 ptr
->name
= strdup (name
);
3883 require_defined_symbol_list
= ptr
;
3886 /* Check that all symbols the user required to be defined, are defined,
3887 raise an error if we find a symbol that is not defined. */
3890 ldlang_check_require_defined_symbols (void)
3892 struct require_defined_symbol
*ptr
;
3894 for (ptr
= require_defined_symbol_list
; ptr
!= NULL
; ptr
= ptr
->next
)
3896 struct bfd_link_hash_entry
*h
;
3898 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
,
3899 FALSE
, FALSE
, TRUE
);
3901 || (h
->type
!= bfd_link_hash_defined
3902 && h
->type
!= bfd_link_hash_defweak
))
3903 einfo(_("%X%P: required symbol `%s' not defined\n"), ptr
->name
);
3907 /* Check for all readonly or some readwrite sections. */
3910 check_input_sections
3911 (lang_statement_union_type
*s
,
3912 lang_output_section_statement_type
*output_section_statement
)
3914 for (; s
!= NULL
; s
= s
->header
.next
)
3916 switch (s
->header
.type
)
3918 case lang_wild_statement_enum
:
3919 walk_wild (&s
->wild_statement
, check_section_callback
,
3920 output_section_statement
);
3921 if (!output_section_statement
->all_input_readonly
)
3924 case lang_constructors_statement_enum
:
3925 check_input_sections (constructor_list
.head
,
3926 output_section_statement
);
3927 if (!output_section_statement
->all_input_readonly
)
3930 case lang_group_statement_enum
:
3931 check_input_sections (s
->group_statement
.children
.head
,
3932 output_section_statement
);
3933 if (!output_section_statement
->all_input_readonly
)
3942 /* Update wildcard statements if needed. */
3945 update_wild_statements (lang_statement_union_type
*s
)
3947 struct wildcard_list
*sec
;
3949 switch (sort_section
)
3959 for (; s
!= NULL
; s
= s
->header
.next
)
3961 switch (s
->header
.type
)
3966 case lang_wild_statement_enum
:
3967 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
3969 /* Don't sort .init/.fini sections. */
3970 if (strcmp (sec
->spec
.name
, ".init") != 0
3971 && strcmp (sec
->spec
.name
, ".fini") != 0)
3972 switch (sec
->spec
.sorted
)
3975 sec
->spec
.sorted
= sort_section
;
3978 if (sort_section
== by_alignment
)
3979 sec
->spec
.sorted
= by_name_alignment
;
3982 if (sort_section
== by_name
)
3983 sec
->spec
.sorted
= by_alignment_name
;
3990 case lang_constructors_statement_enum
:
3991 update_wild_statements (constructor_list
.head
);
3994 case lang_output_section_statement_enum
:
3995 update_wild_statements
3996 (s
->output_section_statement
.children
.head
);
3999 case lang_group_statement_enum
:
4000 update_wild_statements (s
->group_statement
.children
.head
);
4008 /* Open input files and attach to output sections. */
4011 map_input_to_output_sections
4012 (lang_statement_union_type
*s
, const char *target
,
4013 lang_output_section_statement_type
*os
)
4015 for (; s
!= NULL
; s
= s
->header
.next
)
4017 lang_output_section_statement_type
*tos
;
4020 switch (s
->header
.type
)
4022 case lang_wild_statement_enum
:
4023 wild (&s
->wild_statement
, target
, os
);
4025 case lang_constructors_statement_enum
:
4026 map_input_to_output_sections (constructor_list
.head
,
4030 case lang_output_section_statement_enum
:
4031 tos
= &s
->output_section_statement
;
4032 if (tos
->constraint
!= 0)
4034 if (tos
->constraint
!= ONLY_IF_RW
4035 && tos
->constraint
!= ONLY_IF_RO
)
4037 tos
->all_input_readonly
= TRUE
;
4038 check_input_sections (tos
->children
.head
, tos
);
4039 if (tos
->all_input_readonly
!= (tos
->constraint
== ONLY_IF_RO
))
4041 tos
->constraint
= -1;
4045 map_input_to_output_sections (tos
->children
.head
,
4049 case lang_output_statement_enum
:
4051 case lang_target_statement_enum
:
4052 target
= s
->target_statement
.target
;
4054 case lang_group_statement_enum
:
4055 map_input_to_output_sections (s
->group_statement
.children
.head
,
4059 case lang_data_statement_enum
:
4060 /* Make sure that any sections mentioned in the expression
4062 exp_init_os (s
->data_statement
.exp
);
4063 /* The output section gets CONTENTS, ALLOC and LOAD, but
4064 these may be overridden by the script. */
4065 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
;
4066 switch (os
->sectype
)
4068 case normal_section
:
4069 case overlay_section
:
4070 case first_overlay_section
:
4072 case noalloc_section
:
4073 flags
= SEC_HAS_CONTENTS
;
4075 case noload_section
:
4076 if (bfd_get_flavour (link_info
.output_bfd
)
4077 == bfd_target_elf_flavour
)
4078 flags
= SEC_NEVER_LOAD
| SEC_ALLOC
;
4080 flags
= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
;
4083 if (os
->bfd_section
== NULL
)
4084 init_os (os
, flags
);
4086 os
->bfd_section
->flags
|= flags
;
4088 case lang_input_section_enum
:
4090 case lang_fill_statement_enum
:
4091 case lang_object_symbols_statement_enum
:
4092 case lang_reloc_statement_enum
:
4093 case lang_padding_statement_enum
:
4094 case lang_input_statement_enum
:
4095 if (os
!= NULL
&& os
->bfd_section
== NULL
)
4098 case lang_assignment_statement_enum
:
4099 if (os
!= NULL
&& os
->bfd_section
== NULL
)
4102 /* Make sure that any sections mentioned in the assignment
4104 exp_init_os (s
->assignment_statement
.exp
);
4106 case lang_address_statement_enum
:
4107 /* Mark the specified section with the supplied address.
4108 If this section was actually a segment marker, then the
4109 directive is ignored if the linker script explicitly
4110 processed the segment marker. Originally, the linker
4111 treated segment directives (like -Ttext on the
4112 command-line) as section directives. We honor the
4113 section directive semantics for backwards compatibility;
4114 linker scripts that do not specifically check for
4115 SEGMENT_START automatically get the old semantics. */
4116 if (!s
->address_statement
.segment
4117 || !s
->address_statement
.segment
->used
)
4119 const char *name
= s
->address_statement
.section_name
;
4121 /* Create the output section statement here so that
4122 orphans with a set address will be placed after other
4123 script sections. If we let the orphan placement code
4124 place them in amongst other sections then the address
4125 will affect following script sections, which is
4126 likely to surprise naive users. */
4127 tos
= lang_output_section_statement_lookup (name
, 0, TRUE
);
4128 tos
->addr_tree
= s
->address_statement
.address
;
4129 if (tos
->bfd_section
== NULL
)
4133 case lang_insert_statement_enum
:
4139 /* An insert statement snips out all the linker statements from the
4140 start of the list and places them after the output section
4141 statement specified by the insert. This operation is complicated
4142 by the fact that we keep a doubly linked list of output section
4143 statements as well as the singly linked list of all statements.
4144 FIXME someday: Twiddling with the list not only moves statements
4145 from the user's script but also input and group statements that are
4146 built from command line object files and --start-group. We only
4147 get away with this because the list pointers used by file_chain
4148 and input_file_chain are not reordered, and processing via
4149 statement_list after this point mostly ignores input statements.
4150 One exception is the map file, where LOAD and START GROUP/END GROUP
4151 can end up looking odd. */
4154 process_insert_statements (lang_statement_union_type
**start
)
4156 lang_statement_union_type
**s
;
4157 lang_output_section_statement_type
*first_os
= NULL
;
4158 lang_output_section_statement_type
*last_os
= NULL
;
4159 lang_output_section_statement_type
*os
;
4164 if ((*s
)->header
.type
== lang_output_section_statement_enum
)
4166 /* Keep pointers to the first and last output section
4167 statement in the sequence we may be about to move. */
4168 os
= &(*s
)->output_section_statement
;
4170 ASSERT (last_os
== NULL
|| last_os
->next
== os
);
4173 /* Set constraint negative so that lang_output_section_find
4174 won't match this output section statement. At this
4175 stage in linking constraint has values in the range
4176 [-1, ONLY_IN_RW]. */
4177 last_os
->constraint
= -2 - last_os
->constraint
;
4178 if (first_os
== NULL
)
4181 else if ((*s
)->header
.type
== lang_group_statement_enum
)
4183 /* A user might put -T between --start-group and
4184 --end-group. One way this odd construct might arise is
4185 from a wrapper around ld to change library search
4186 behaviour. For example:
4188 exec real_ld --start-group "$@" --end-group
4189 This isn't completely unreasonable so go looking inside a
4190 group statement for insert statements. */
4191 process_insert_statements (&(*s
)->group_statement
.children
.head
);
4193 else if ((*s
)->header
.type
== lang_insert_statement_enum
)
4195 lang_insert_statement_type
*i
= &(*s
)->insert_statement
;
4196 lang_output_section_statement_type
*where
;
4197 lang_statement_union_type
**ptr
;
4198 lang_statement_union_type
*first
;
4200 where
= lang_output_section_find (i
->where
);
4201 if (where
!= NULL
&& i
->is_before
)
4204 where
= where
->prev
;
4205 while (where
!= NULL
&& where
->constraint
< 0);
4209 einfo (_("%F%P: %s not found for insert\n"), i
->where
);
4213 /* Deal with reordering the output section statement list. */
4214 if (last_os
!= NULL
)
4216 asection
*first_sec
, *last_sec
;
4217 struct lang_output_section_statement_struct
**next
;
4219 /* Snip out the output sections we are moving. */
4220 first_os
->prev
->next
= last_os
->next
;
4221 if (last_os
->next
== NULL
)
4223 next
= &first_os
->prev
->next
;
4224 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4227 last_os
->next
->prev
= first_os
->prev
;
4228 /* Add them in at the new position. */
4229 last_os
->next
= where
->next
;
4230 if (where
->next
== NULL
)
4232 next
= &last_os
->next
;
4233 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4236 where
->next
->prev
= last_os
;
4237 first_os
->prev
= where
;
4238 where
->next
= first_os
;
4240 /* Move the bfd sections in the same way. */
4243 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4245 os
->constraint
= -2 - os
->constraint
;
4246 if (os
->bfd_section
!= NULL
4247 && os
->bfd_section
->owner
!= NULL
)
4249 last_sec
= os
->bfd_section
;
4250 if (first_sec
== NULL
)
4251 first_sec
= last_sec
;
4256 if (last_sec
!= NULL
)
4258 asection
*sec
= where
->bfd_section
;
4260 sec
= output_prev_sec_find (where
);
4262 /* The place we want to insert must come after the
4263 sections we are moving. So if we find no
4264 section or if the section is the same as our
4265 last section, then no move is needed. */
4266 if (sec
!= NULL
&& sec
!= last_sec
)
4268 /* Trim them off. */
4269 if (first_sec
->prev
!= NULL
)
4270 first_sec
->prev
->next
= last_sec
->next
;
4272 link_info
.output_bfd
->sections
= last_sec
->next
;
4273 if (last_sec
->next
!= NULL
)
4274 last_sec
->next
->prev
= first_sec
->prev
;
4276 link_info
.output_bfd
->section_last
= first_sec
->prev
;
4278 last_sec
->next
= sec
->next
;
4279 if (sec
->next
!= NULL
)
4280 sec
->next
->prev
= last_sec
;
4282 link_info
.output_bfd
->section_last
= last_sec
;
4283 first_sec
->prev
= sec
;
4284 sec
->next
= first_sec
;
4292 ptr
= insert_os_after (where
);
4293 /* Snip everything from the start of the list, up to and
4294 including the insert statement we are currently processing. */
4296 *start
= (*s
)->header
.next
;
4297 /* Add them back where they belong, minus the insert. */
4300 statement_list
.tail
= s
;
4305 s
= &(*s
)->header
.next
;
4308 /* Undo constraint twiddling. */
4309 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4311 os
->constraint
= -2 - os
->constraint
;
4317 /* An output section might have been removed after its statement was
4318 added. For example, ldemul_before_allocation can remove dynamic
4319 sections if they turn out to be not needed. Clean them up here. */
4322 strip_excluded_output_sections (void)
4324 lang_output_section_statement_type
*os
;
4326 /* Run lang_size_sections (if not already done). */
4327 if (expld
.phase
!= lang_mark_phase_enum
)
4329 expld
.phase
= lang_mark_phase_enum
;
4330 expld
.dataseg
.phase
= exp_seg_none
;
4331 one_lang_size_sections_pass (NULL
, FALSE
);
4332 lang_reset_memory_regions ();
4335 for (os
= (void *) lang_os_list
.head
;
4339 asection
*output_section
;
4340 bfd_boolean exclude
;
4342 if (os
->constraint
< 0)
4345 output_section
= os
->bfd_section
;
4346 if (output_section
== NULL
)
4349 exclude
= (output_section
->rawsize
== 0
4350 && (output_section
->flags
& SEC_KEEP
) == 0
4351 && !bfd_section_removed_from_list (link_info
.output_bfd
,
4354 /* Some sections have not yet been sized, notably .gnu.version,
4355 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
4356 input sections, so don't drop output sections that have such
4357 input sections unless they are also marked SEC_EXCLUDE. */
4358 if (exclude
&& output_section
->map_head
.s
!= NULL
)
4362 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
4363 if ((s
->flags
& SEC_EXCLUDE
) == 0
4364 && ((s
->flags
& SEC_LINKER_CREATED
) != 0
4365 || link_info
.emitrelocations
))
4374 /* We don't set bfd_section to NULL since bfd_section of the
4375 removed output section statement may still be used. */
4376 if (!os
->update_dot
)
4378 output_section
->flags
|= SEC_EXCLUDE
;
4379 bfd_section_list_remove (link_info
.output_bfd
, output_section
);
4380 link_info
.output_bfd
->section_count
--;
4385 /* Called from ldwrite to clear out asection.map_head and
4386 asection.map_tail for use as link_orders in ldwrite. */
4389 lang_clear_os_map (void)
4391 lang_output_section_statement_type
*os
;
4393 if (map_head_is_link_order
)
4396 for (os
= (void *) lang_os_list
.head
;
4400 asection
*output_section
;
4402 if (os
->constraint
< 0)
4405 output_section
= os
->bfd_section
;
4406 if (output_section
== NULL
)
4409 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
4410 output_section
->map_head
.link_order
= NULL
;
4411 output_section
->map_tail
.link_order
= NULL
;
4414 /* Stop future calls to lang_add_section from messing with map_head
4415 and map_tail link_order fields. */
4416 map_head_is_link_order
= TRUE
;
4420 print_output_section_statement
4421 (lang_output_section_statement_type
*output_section_statement
)
4423 asection
*section
= output_section_statement
->bfd_section
;
4426 if (output_section_statement
!= abs_output_section
)
4428 minfo ("\n%s", output_section_statement
->name
);
4430 if (section
!= NULL
)
4432 print_dot
= section
->vma
;
4434 len
= strlen (output_section_statement
->name
);
4435 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4440 while (len
< SECTION_NAME_MAP_LENGTH
)
4446 minfo ("0x%V %W", section
->vma
, TO_ADDR (section
->size
));
4448 if (section
->vma
!= section
->lma
)
4449 minfo (_(" load address 0x%V"), section
->lma
);
4451 if (output_section_statement
->update_dot_tree
!= NULL
)
4452 exp_fold_tree (output_section_statement
->update_dot_tree
,
4453 bfd_abs_section_ptr
, &print_dot
);
4459 print_statement_list (output_section_statement
->children
.head
,
4460 output_section_statement
);
4464 print_assignment (lang_assignment_statement_type
*assignment
,
4465 lang_output_section_statement_type
*output_section
)
4472 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4475 if (assignment
->exp
->type
.node_class
== etree_assert
)
4478 tree
= assignment
->exp
->assert_s
.child
;
4482 const char *dst
= assignment
->exp
->assign
.dst
;
4484 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
4485 tree
= assignment
->exp
;
4488 osec
= output_section
->bfd_section
;
4490 osec
= bfd_abs_section_ptr
;
4492 if (assignment
->exp
->type
.node_class
!= etree_provide
)
4493 exp_fold_tree (tree
, osec
, &print_dot
);
4495 expld
.result
.valid_p
= FALSE
;
4497 if (expld
.result
.valid_p
)
4501 if (assignment
->exp
->type
.node_class
== etree_assert
4503 || expld
.assign_name
!= NULL
)
4505 value
= expld
.result
.value
;
4507 if (expld
.result
.section
!= NULL
)
4508 value
+= expld
.result
.section
->vma
;
4510 minfo ("0x%V", value
);
4516 struct bfd_link_hash_entry
*h
;
4518 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
4519 FALSE
, FALSE
, TRUE
);
4521 && (h
->type
== bfd_link_hash_defined
4522 || h
->type
== bfd_link_hash_defweak
))
4524 value
= h
->u
.def
.value
;
4525 value
+= h
->u
.def
.section
->output_section
->vma
;
4526 value
+= h
->u
.def
.section
->output_offset
;
4528 minfo ("[0x%V]", value
);
4531 minfo ("[unresolved]");
4536 if (assignment
->exp
->type
.node_class
== etree_provide
)
4537 minfo ("[!provide]");
4544 expld
.assign_name
= NULL
;
4547 exp_print_tree (assignment
->exp
);
4552 print_input_statement (lang_input_statement_type
*statm
)
4554 if (statm
->filename
!= NULL
)
4555 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
4558 /* Print all symbols defined in a particular section. This is called
4559 via bfd_link_hash_traverse, or by print_all_symbols. */
4562 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
4564 asection
*sec
= (asection
*) ptr
;
4566 if ((hash_entry
->type
== bfd_link_hash_defined
4567 || hash_entry
->type
== bfd_link_hash_defweak
)
4568 && sec
== hash_entry
->u
.def
.section
)
4572 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4575 (hash_entry
->u
.def
.value
4576 + hash_entry
->u
.def
.section
->output_offset
4577 + hash_entry
->u
.def
.section
->output_section
->vma
));
4579 minfo (" %pT\n", hash_entry
->root
.string
);
4586 hash_entry_addr_cmp (const void *a
, const void *b
)
4588 const struct bfd_link_hash_entry
*l
= *(const struct bfd_link_hash_entry
**)a
;
4589 const struct bfd_link_hash_entry
*r
= *(const struct bfd_link_hash_entry
**)b
;
4591 if (l
->u
.def
.value
< r
->u
.def
.value
)
4593 else if (l
->u
.def
.value
> r
->u
.def
.value
)
4600 print_all_symbols (asection
*sec
)
4602 input_section_userdata_type
*ud
= bfd_section_userdata (sec
);
4603 struct map_symbol_def
*def
;
4604 struct bfd_link_hash_entry
**entries
;
4610 *ud
->map_symbol_def_tail
= 0;
4612 /* Sort the symbols by address. */
4613 entries
= (struct bfd_link_hash_entry
**)
4614 obstack_alloc (&map_obstack
,
4615 ud
->map_symbol_def_count
* sizeof (*entries
));
4617 for (i
= 0, def
= ud
->map_symbol_def_head
; def
; def
= def
->next
, i
++)
4618 entries
[i
] = def
->entry
;
4620 qsort (entries
, ud
->map_symbol_def_count
, sizeof (*entries
),
4621 hash_entry_addr_cmp
);
4623 /* Print the symbols. */
4624 for (i
= 0; i
< ud
->map_symbol_def_count
; i
++)
4625 print_one_symbol (entries
[i
], sec
);
4627 obstack_free (&map_obstack
, entries
);
4630 /* Print information about an input section to the map file. */
4633 print_input_section (asection
*i
, bfd_boolean is_discarded
)
4635 bfd_size_type size
= i
->size
;
4642 minfo ("%s", i
->name
);
4644 len
= 1 + strlen (i
->name
);
4645 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4650 while (len
< SECTION_NAME_MAP_LENGTH
)
4656 if (i
->output_section
!= NULL
4657 && i
->output_section
->owner
== link_info
.output_bfd
)
4658 addr
= i
->output_section
->vma
+ i
->output_offset
;
4666 minfo ("0x%V %W %pB\n", addr
, TO_ADDR (size
), i
->owner
);
4668 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
4670 len
= SECTION_NAME_MAP_LENGTH
+ 3;
4682 minfo (_("%W (size before relaxing)\n"), TO_ADDR (i
->rawsize
));
4685 if (i
->output_section
!= NULL
4686 && i
->output_section
->owner
== link_info
.output_bfd
)
4688 if (link_info
.reduce_memory_overheads
)
4689 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, i
);
4691 print_all_symbols (i
);
4693 /* Update print_dot, but make sure that we do not move it
4694 backwards - this could happen if we have overlays and a
4695 later overlay is shorter than an earier one. */
4696 if (addr
+ TO_ADDR (size
) > print_dot
)
4697 print_dot
= addr
+ TO_ADDR (size
);
4702 print_fill_statement (lang_fill_statement_type
*fill
)
4706 fputs (" FILL mask 0x", config
.map_file
);
4707 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
4708 fprintf (config
.map_file
, "%02x", *p
);
4709 fputs ("\n", config
.map_file
);
4713 print_data_statement (lang_data_statement_type
*data
)
4720 init_opb (data
->output_section
);
4721 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4724 addr
= data
->output_offset
;
4725 if (data
->output_section
!= NULL
)
4726 addr
+= data
->output_section
->vma
;
4754 if (size
< TO_SIZE ((unsigned) 1))
4755 size
= TO_SIZE ((unsigned) 1);
4756 minfo ("0x%V %W %s 0x%v", addr
, TO_ADDR (size
), name
, data
->value
);
4758 if (data
->exp
->type
.node_class
!= etree_value
)
4761 exp_print_tree (data
->exp
);
4766 print_dot
= addr
+ TO_ADDR (size
);
4769 /* Print an address statement. These are generated by options like
4773 print_address_statement (lang_address_statement_type
*address
)
4775 minfo (_("Address of section %s set to "), address
->section_name
);
4776 exp_print_tree (address
->address
);
4780 /* Print a reloc statement. */
4783 print_reloc_statement (lang_reloc_statement_type
*reloc
)
4789 init_opb (reloc
->output_section
);
4790 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4793 addr
= reloc
->output_offset
;
4794 if (reloc
->output_section
!= NULL
)
4795 addr
+= reloc
->output_section
->vma
;
4797 size
= bfd_get_reloc_size (reloc
->howto
);
4799 minfo ("0x%V %W RELOC %s ", addr
, TO_ADDR (size
), reloc
->howto
->name
);
4801 if (reloc
->name
!= NULL
)
4802 minfo ("%s+", reloc
->name
);
4804 minfo ("%s+", reloc
->section
->name
);
4806 exp_print_tree (reloc
->addend_exp
);
4810 print_dot
= addr
+ TO_ADDR (size
);
4814 print_padding_statement (lang_padding_statement_type
*s
)
4819 init_opb (s
->output_section
);
4822 len
= sizeof " *fill*" - 1;
4823 while (len
< SECTION_NAME_MAP_LENGTH
)
4829 addr
= s
->output_offset
;
4830 if (s
->output_section
!= NULL
)
4831 addr
+= s
->output_section
->vma
;
4832 minfo ("0x%V %W ", addr
, TO_ADDR (s
->size
));
4834 if (s
->fill
->size
!= 0)
4838 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
4839 fprintf (config
.map_file
, "%02x", *p
);
4844 print_dot
= addr
+ TO_ADDR (s
->size
);
4848 print_wild_statement (lang_wild_statement_type
*w
,
4849 lang_output_section_statement_type
*os
)
4851 struct wildcard_list
*sec
;
4855 if (w
->exclude_name_list
)
4858 minfo ("EXCLUDE_FILE(%s", w
->exclude_name_list
->name
);
4859 for (tmp
= w
->exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4860 minfo (" %s", tmp
->name
);
4864 if (w
->filenames_sorted
)
4865 minfo ("SORT_BY_NAME(");
4866 if (w
->filename
!= NULL
)
4867 minfo ("%s", w
->filename
);
4870 if (w
->filenames_sorted
)
4874 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
4876 int closing_paren
= 0;
4878 switch (sec
->spec
.sorted
)
4884 minfo ("SORT_BY_NAME(");
4889 minfo ("SORT_BY_ALIGNMENT(");
4893 case by_name_alignment
:
4894 minfo ("SORT_BY_NAME(SORT_BY_ALIGNMENT(");
4898 case by_alignment_name
:
4899 minfo ("SORT_BY_ALIGNMENT(SORT_BY_NAME(");
4904 minfo ("SORT_NONE(");
4908 case by_init_priority
:
4909 minfo ("SORT_BY_INIT_PRIORITY(");
4914 if (sec
->spec
.exclude_name_list
!= NULL
)
4917 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
4918 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4919 minfo (" %s", tmp
->name
);
4922 if (sec
->spec
.name
!= NULL
)
4923 minfo ("%s", sec
->spec
.name
);
4926 for (;closing_paren
> 0; closing_paren
--)
4935 print_statement_list (w
->children
.head
, os
);
4938 /* Print a group statement. */
4941 print_group (lang_group_statement_type
*s
,
4942 lang_output_section_statement_type
*os
)
4944 fprintf (config
.map_file
, "START GROUP\n");
4945 print_statement_list (s
->children
.head
, os
);
4946 fprintf (config
.map_file
, "END GROUP\n");
4949 /* Print the list of statements in S.
4950 This can be called for any statement type. */
4953 print_statement_list (lang_statement_union_type
*s
,
4954 lang_output_section_statement_type
*os
)
4958 print_statement (s
, os
);
4963 /* Print the first statement in statement list S.
4964 This can be called for any statement type. */
4967 print_statement (lang_statement_union_type
*s
,
4968 lang_output_section_statement_type
*os
)
4970 switch (s
->header
.type
)
4973 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
4976 case lang_constructors_statement_enum
:
4977 if (constructor_list
.head
!= NULL
)
4979 if (constructors_sorted
)
4980 minfo (" SORT (CONSTRUCTORS)\n");
4982 minfo (" CONSTRUCTORS\n");
4983 print_statement_list (constructor_list
.head
, os
);
4986 case lang_wild_statement_enum
:
4987 print_wild_statement (&s
->wild_statement
, os
);
4989 case lang_address_statement_enum
:
4990 print_address_statement (&s
->address_statement
);
4992 case lang_object_symbols_statement_enum
:
4993 minfo (" CREATE_OBJECT_SYMBOLS\n");
4995 case lang_fill_statement_enum
:
4996 print_fill_statement (&s
->fill_statement
);
4998 case lang_data_statement_enum
:
4999 print_data_statement (&s
->data_statement
);
5001 case lang_reloc_statement_enum
:
5002 print_reloc_statement (&s
->reloc_statement
);
5004 case lang_input_section_enum
:
5005 print_input_section (s
->input_section
.section
, FALSE
);
5007 case lang_padding_statement_enum
:
5008 print_padding_statement (&s
->padding_statement
);
5010 case lang_output_section_statement_enum
:
5011 print_output_section_statement (&s
->output_section_statement
);
5013 case lang_assignment_statement_enum
:
5014 print_assignment (&s
->assignment_statement
, os
);
5016 case lang_target_statement_enum
:
5017 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
5019 case lang_output_statement_enum
:
5020 minfo ("OUTPUT(%s", s
->output_statement
.name
);
5021 if (output_target
!= NULL
)
5022 minfo (" %s", output_target
);
5025 case lang_input_statement_enum
:
5026 print_input_statement (&s
->input_statement
);
5028 case lang_group_statement_enum
:
5029 print_group (&s
->group_statement
, os
);
5031 case lang_insert_statement_enum
:
5032 minfo ("INSERT %s %s\n",
5033 s
->insert_statement
.is_before
? "BEFORE" : "AFTER",
5034 s
->insert_statement
.where
);
5040 print_statements (void)
5042 print_statement_list (statement_list
.head
, abs_output_section
);
5045 /* Print the first N statements in statement list S to STDERR.
5046 If N == 0, nothing is printed.
5047 If N < 0, the entire list is printed.
5048 Intended to be called from GDB. */
5051 dprint_statement (lang_statement_union_type
*s
, int n
)
5053 FILE *map_save
= config
.map_file
;
5055 config
.map_file
= stderr
;
5058 print_statement_list (s
, abs_output_section
);
5061 while (s
&& --n
>= 0)
5063 print_statement (s
, abs_output_section
);
5068 config
.map_file
= map_save
;
5072 insert_pad (lang_statement_union_type
**ptr
,
5074 bfd_size_type alignment_needed
,
5075 asection
*output_section
,
5078 static fill_type zero_fill
;
5079 lang_statement_union_type
*pad
= NULL
;
5081 if (ptr
!= &statement_list
.head
)
5082 pad
= ((lang_statement_union_type
*)
5083 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
5085 && pad
->header
.type
== lang_padding_statement_enum
5086 && pad
->padding_statement
.output_section
== output_section
)
5088 /* Use the existing pad statement. */
5090 else if ((pad
= *ptr
) != NULL
5091 && pad
->header
.type
== lang_padding_statement_enum
5092 && pad
->padding_statement
.output_section
== output_section
)
5094 /* Use the existing pad statement. */
5098 /* Make a new padding statement, linked into existing chain. */
5099 pad
= stat_alloc (sizeof (lang_padding_statement_type
));
5100 pad
->header
.next
= *ptr
;
5102 pad
->header
.type
= lang_padding_statement_enum
;
5103 pad
->padding_statement
.output_section
= output_section
;
5106 pad
->padding_statement
.fill
= fill
;
5108 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
5109 pad
->padding_statement
.size
= alignment_needed
;
5110 if (!(output_section
->flags
& SEC_FIXED_SIZE
))
5111 output_section
->size
= TO_SIZE (dot
+ TO_ADDR (alignment_needed
)
5112 - output_section
->vma
);
5115 /* Work out how much this section will move the dot point. */
5119 (lang_statement_union_type
**this_ptr
,
5120 lang_output_section_statement_type
*output_section_statement
,
5124 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
5125 asection
*i
= is
->section
;
5126 asection
*o
= output_section_statement
->bfd_section
;
5128 if (i
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
5129 i
->output_offset
= i
->vma
- o
->vma
;
5130 else if (((i
->flags
& SEC_EXCLUDE
) != 0)
5131 || output_section_statement
->ignored
)
5132 i
->output_offset
= dot
- o
->vma
;
5135 bfd_size_type alignment_needed
;
5137 /* Align this section first to the input sections requirement,
5138 then to the output section's requirement. If this alignment
5139 is greater than any seen before, then record it too. Perform
5140 the alignment by inserting a magic 'padding' statement. */
5142 if (output_section_statement
->subsection_alignment
!= NULL
)
5144 = exp_get_power (output_section_statement
->subsection_alignment
,
5145 "subsection alignment");
5147 if (o
->alignment_power
< i
->alignment_power
)
5148 o
->alignment_power
= i
->alignment_power
;
5150 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
5152 if (alignment_needed
!= 0)
5154 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
5155 dot
+= alignment_needed
;
5158 /* Remember where in the output section this input section goes. */
5159 i
->output_offset
= dot
- o
->vma
;
5161 /* Mark how big the output section must be to contain this now. */
5162 dot
+= TO_ADDR (i
->size
);
5163 if (!(o
->flags
& SEC_FIXED_SIZE
))
5164 o
->size
= TO_SIZE (dot
- o
->vma
);
5177 sort_sections_by_lma (const void *arg1
, const void *arg2
)
5179 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
5180 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
5182 if (sec1
->lma
< sec2
->lma
)
5184 else if (sec1
->lma
> sec2
->lma
)
5186 else if (sec1
->id
< sec2
->id
)
5188 else if (sec1
->id
> sec2
->id
)
5195 sort_sections_by_vma (const void *arg1
, const void *arg2
)
5197 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
5198 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
5200 if (sec1
->vma
< sec2
->vma
)
5202 else if (sec1
->vma
> sec2
->vma
)
5204 else if (sec1
->id
< sec2
->id
)
5206 else if (sec1
->id
> sec2
->id
)
5212 #define IS_TBSS(s) \
5213 ((s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == SEC_THREAD_LOCAL)
5215 #define IGNORE_SECTION(s) \
5216 ((s->flags & SEC_ALLOC) == 0 || IS_TBSS (s))
5218 /* Check to see if any allocated sections overlap with other allocated
5219 sections. This can happen if a linker script specifies the output
5220 section addresses of the two sections. Also check whether any memory
5221 region has overflowed. */
5224 lang_check_section_addresses (void)
5227 struct check_sec
*sections
;
5232 bfd_vma p_start
= 0;
5234 lang_memory_region_type
*m
;
5235 bfd_boolean overlays
;
5237 /* Detect address space overflow on allocated sections. */
5238 addr_mask
= ((bfd_vma
) 1 <<
5239 (bfd_arch_bits_per_address (link_info
.output_bfd
) - 1)) - 1;
5240 addr_mask
= (addr_mask
<< 1) + 1;
5241 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5242 if ((s
->flags
& SEC_ALLOC
) != 0)
5244 s_end
= (s
->vma
+ s
->size
) & addr_mask
;
5245 if (s_end
!= 0 && s_end
< (s
->vma
& addr_mask
))
5246 einfo (_("%X%P: section %s VMA wraps around address space\n"),
5250 s_end
= (s
->lma
+ s
->size
) & addr_mask
;
5251 if (s_end
!= 0 && s_end
< (s
->lma
& addr_mask
))
5252 einfo (_("%X%P: section %s LMA wraps around address space\n"),
5257 if (bfd_count_sections (link_info
.output_bfd
) <= 1)
5260 count
= bfd_count_sections (link_info
.output_bfd
);
5261 sections
= XNEWVEC (struct check_sec
, count
);
5263 /* Scan all sections in the output list. */
5265 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5267 if (IGNORE_SECTION (s
)
5271 sections
[count
].sec
= s
;
5272 sections
[count
].warned
= FALSE
;
5282 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_lma
);
5284 /* First check section LMAs. There should be no overlap of LMAs on
5285 loadable sections, even with overlays. */
5286 for (p
= NULL
, i
= 0; i
< count
; i
++)
5288 s
= sections
[i
].sec
;
5290 if ((s
->flags
& SEC_LOAD
) != 0)
5293 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5295 /* Look for an overlap. We have sorted sections by lma, so
5296 we know that s_start >= p_start. Besides the obvious
5297 case of overlap when the current section starts before
5298 the previous one ends, we also must have overlap if the
5299 previous section wraps around the address space. */
5301 && (s_start
<= p_end
5302 || p_end
< p_start
))
5304 einfo (_("%X%P: section %s LMA [%V,%V]"
5305 " overlaps section %s LMA [%V,%V]\n"),
5306 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5307 sections
[i
].warned
= TRUE
;
5315 /* If any non-zero size allocated section (excluding tbss) starts at
5316 exactly the same VMA as another such section, then we have
5317 overlays. Overlays generated by the OVERLAY keyword will have
5318 this property. It is possible to intentionally generate overlays
5319 that fail this test, but it would be unusual. */
5320 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_vma
);
5322 p_start
= sections
[0].sec
->vma
;
5323 for (i
= 1; i
< count
; i
++)
5325 s_start
= sections
[i
].sec
->vma
;
5326 if (p_start
== s_start
)
5334 /* Now check section VMAs if no overlays were detected. */
5337 for (p
= NULL
, i
= 0; i
< count
; i
++)
5339 s
= sections
[i
].sec
;
5342 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5345 && !sections
[i
].warned
5346 && (s_start
<= p_end
5347 || p_end
< p_start
))
5348 einfo (_("%X%P: section %s VMA [%V,%V]"
5349 " overlaps section %s VMA [%V,%V]\n"),
5350 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5359 /* If any memory region has overflowed, report by how much.
5360 We do not issue this diagnostic for regions that had sections
5361 explicitly placed outside their bounds; os_region_check's
5362 diagnostics are adequate for that case.
5364 FIXME: It is conceivable that m->current - (m->origin + m->length)
5365 might overflow a 32-bit integer. There is, alas, no way to print
5366 a bfd_vma quantity in decimal. */
5367 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
5368 if (m
->had_full_message
)
5370 unsigned long over
= m
->current
- (m
->origin
+ m
->length
);
5371 einfo (ngettext ("%X%P: region `%s' overflowed by %lu byte\n",
5372 "%X%P: region `%s' overflowed by %lu bytes\n",
5374 m
->name_list
.name
, over
);
5378 /* Make sure the new address is within the region. We explicitly permit the
5379 current address to be at the exact end of the region when the address is
5380 non-zero, in case the region is at the end of addressable memory and the
5381 calculation wraps around. */
5384 os_region_check (lang_output_section_statement_type
*os
,
5385 lang_memory_region_type
*region
,
5389 if ((region
->current
< region
->origin
5390 || (region
->current
- region
->origin
> region
->length
))
5391 && ((region
->current
!= region
->origin
+ region
->length
)
5396 einfo (_("%X%P: address 0x%v of %pB section `%s'"
5397 " is not within region `%s'\n"),
5399 os
->bfd_section
->owner
,
5400 os
->bfd_section
->name
,
5401 region
->name_list
.name
);
5403 else if (!region
->had_full_message
)
5405 region
->had_full_message
= TRUE
;
5407 einfo (_("%X%P: %pB section `%s' will not fit in region `%s'\n"),
5408 os
->bfd_section
->owner
,
5409 os
->bfd_section
->name
,
5410 region
->name_list
.name
);
5416 ldlang_check_relro_region (lang_statement_union_type
*s
,
5417 seg_align_type
*seg
)
5419 if (seg
->relro
== exp_seg_relro_start
)
5421 if (!seg
->relro_start_stat
)
5422 seg
->relro_start_stat
= s
;
5425 ASSERT (seg
->relro_start_stat
== s
);
5428 else if (seg
->relro
== exp_seg_relro_end
)
5430 if (!seg
->relro_end_stat
)
5431 seg
->relro_end_stat
= s
;
5434 ASSERT (seg
->relro_end_stat
== s
);
5439 /* Set the sizes for all the output sections. */
5442 lang_size_sections_1
5443 (lang_statement_union_type
**prev
,
5444 lang_output_section_statement_type
*output_section_statement
,
5448 bfd_boolean check_regions
)
5450 lang_statement_union_type
*s
;
5452 /* Size up the sections from their constituent parts. */
5453 for (s
= *prev
; s
!= NULL
; s
= s
->header
.next
)
5455 switch (s
->header
.type
)
5457 case lang_output_section_statement_enum
:
5459 bfd_vma newdot
, after
, dotdelta
;
5460 lang_output_section_statement_type
*os
;
5461 lang_memory_region_type
*r
;
5462 int section_alignment
= 0;
5464 os
= &s
->output_section_statement
;
5465 init_opb (os
->bfd_section
);
5466 if (os
->constraint
== -1)
5469 /* FIXME: We shouldn't need to zero section vmas for ld -r
5470 here, in lang_insert_orphan, or in the default linker scripts.
5471 This is covering for coff backend linker bugs. See PR6945. */
5472 if (os
->addr_tree
== NULL
5473 && bfd_link_relocatable (&link_info
)
5474 && (bfd_get_flavour (link_info
.output_bfd
)
5475 == bfd_target_coff_flavour
))
5476 os
->addr_tree
= exp_intop (0);
5477 if (os
->addr_tree
!= NULL
)
5479 os
->processed_vma
= FALSE
;
5480 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
5482 if (expld
.result
.valid_p
)
5484 dot
= expld
.result
.value
;
5485 if (expld
.result
.section
!= NULL
)
5486 dot
+= expld
.result
.section
->vma
;
5488 else if (expld
.phase
!= lang_mark_phase_enum
)
5489 einfo (_("%F%P:%pS: non constant or forward reference"
5490 " address expression for section %s\n"),
5491 os
->addr_tree
, os
->name
);
5494 if (os
->bfd_section
== NULL
)
5495 /* This section was removed or never actually created. */
5498 /* If this is a COFF shared library section, use the size and
5499 address from the input section. FIXME: This is COFF
5500 specific; it would be cleaner if there were some other way
5501 to do this, but nothing simple comes to mind. */
5502 if (((bfd_get_flavour (link_info
.output_bfd
)
5503 == bfd_target_ecoff_flavour
)
5504 || (bfd_get_flavour (link_info
.output_bfd
)
5505 == bfd_target_coff_flavour
))
5506 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
5510 if (os
->children
.head
== NULL
5511 || os
->children
.head
->header
.next
!= NULL
5512 || (os
->children
.head
->header
.type
5513 != lang_input_section_enum
))
5514 einfo (_("%X%P: internal error on COFF shared library"
5515 " section %s\n"), os
->name
);
5517 input
= os
->children
.head
->input_section
.section
;
5518 bfd_set_section_vma (os
->bfd_section
,
5519 bfd_section_vma (input
));
5520 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5521 os
->bfd_section
->size
= input
->size
;
5527 if (bfd_is_abs_section (os
->bfd_section
))
5529 /* No matter what happens, an abs section starts at zero. */
5530 ASSERT (os
->bfd_section
->vma
== 0);
5534 if (os
->addr_tree
== NULL
)
5536 /* No address specified for this section, get one
5537 from the region specification. */
5538 if (os
->region
== NULL
5539 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
5540 && os
->region
->name_list
.name
[0] == '*'
5541 && strcmp (os
->region
->name_list
.name
,
5542 DEFAULT_MEMORY_REGION
) == 0))
5544 os
->region
= lang_memory_default (os
->bfd_section
);
5547 /* If a loadable section is using the default memory
5548 region, and some non default memory regions were
5549 defined, issue an error message. */
5551 && !IGNORE_SECTION (os
->bfd_section
)
5552 && !bfd_link_relocatable (&link_info
)
5554 && strcmp (os
->region
->name_list
.name
,
5555 DEFAULT_MEMORY_REGION
) == 0
5556 && lang_memory_region_list
!= NULL
5557 && (strcmp (lang_memory_region_list
->name_list
.name
,
5558 DEFAULT_MEMORY_REGION
) != 0
5559 || lang_memory_region_list
->next
!= NULL
)
5560 && lang_sizing_iteration
== 1)
5562 /* By default this is an error rather than just a
5563 warning because if we allocate the section to the
5564 default memory region we can end up creating an
5565 excessively large binary, or even seg faulting when
5566 attempting to perform a negative seek. See
5567 sources.redhat.com/ml/binutils/2003-04/msg00423.html
5568 for an example of this. This behaviour can be
5569 overridden by the using the --no-check-sections
5571 if (command_line
.check_section_addresses
)
5572 einfo (_("%F%P: error: no memory region specified"
5573 " for loadable section `%s'\n"),
5574 bfd_section_name (os
->bfd_section
));
5576 einfo (_("%P: warning: no memory region specified"
5577 " for loadable section `%s'\n"),
5578 bfd_section_name (os
->bfd_section
));
5581 newdot
= os
->region
->current
;
5582 section_alignment
= os
->bfd_section
->alignment_power
;
5585 section_alignment
= exp_get_power (os
->section_alignment
,
5586 "section alignment");
5588 /* Align to what the section needs. */
5589 if (section_alignment
> 0)
5591 bfd_vma savedot
= newdot
;
5594 newdot
= align_power (newdot
, section_alignment
);
5595 dotdelta
= newdot
- savedot
;
5597 if (lang_sizing_iteration
== 1)
5599 else if (lang_sizing_iteration
> 1)
5600 diff
= newdot
- os
->bfd_section
->vma
;
5602 && (config
.warn_section_align
5603 || os
->addr_tree
!= NULL
))
5604 einfo (_("%P: warning: "
5605 "start of section %s changed by %ld\n"),
5606 os
->name
, (long) diff
);
5609 bfd_set_section_vma (os
->bfd_section
, newdot
);
5611 os
->bfd_section
->output_offset
= 0;
5614 lang_size_sections_1 (&os
->children
.head
, os
,
5615 os
->fill
, newdot
, relax
, check_regions
);
5617 os
->processed_vma
= TRUE
;
5619 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5620 /* Except for some special linker created sections,
5621 no output section should change from zero size
5622 after strip_excluded_output_sections. A non-zero
5623 size on an ignored section indicates that some
5624 input section was not sized early enough. */
5625 ASSERT (os
->bfd_section
->size
== 0);
5628 dot
= os
->bfd_section
->vma
;
5630 /* Put the section within the requested block size, or
5631 align at the block boundary. */
5633 + TO_ADDR (os
->bfd_section
->size
)
5634 + os
->block_value
- 1)
5635 & - (bfd_vma
) os
->block_value
);
5637 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5638 os
->bfd_section
->size
= TO_SIZE (after
5639 - os
->bfd_section
->vma
);
5642 /* Set section lma. */
5645 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
5649 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
5650 os
->bfd_section
->lma
= lma
;
5652 else if (os
->lma_region
!= NULL
)
5654 bfd_vma lma
= os
->lma_region
->current
;
5656 if (os
->align_lma_with_input
)
5660 /* When LMA_REGION is the same as REGION, align the LMA
5661 as we did for the VMA, possibly including alignment
5662 from the bfd section. If a different region, then
5663 only align according to the value in the output
5665 if (os
->lma_region
!= os
->region
)
5666 section_alignment
= exp_get_power (os
->section_alignment
,
5667 "section alignment");
5668 if (section_alignment
> 0)
5669 lma
= align_power (lma
, section_alignment
);
5671 os
->bfd_section
->lma
= lma
;
5673 else if (r
->last_os
!= NULL
5674 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5679 last
= r
->last_os
->output_section_statement
.bfd_section
;
5681 /* A backwards move of dot should be accompanied by
5682 an explicit assignment to the section LMA (ie.
5683 os->load_base set) because backwards moves can
5684 create overlapping LMAs. */
5686 && os
->bfd_section
->size
!= 0
5687 && dot
+ TO_ADDR (os
->bfd_section
->size
) <= last
->vma
)
5689 /* If dot moved backwards then leave lma equal to
5690 vma. This is the old default lma, which might
5691 just happen to work when the backwards move is
5692 sufficiently large. Nag if this changes anything,
5693 so people can fix their linker scripts. */
5695 if (last
->vma
!= last
->lma
)
5696 einfo (_("%P: warning: dot moved backwards "
5697 "before `%s'\n"), os
->name
);
5701 /* If this is an overlay, set the current lma to that
5702 at the end of the previous section. */
5703 if (os
->sectype
== overlay_section
)
5704 lma
= last
->lma
+ TO_ADDR (last
->size
);
5706 /* Otherwise, keep the same lma to vma relationship
5707 as the previous section. */
5709 lma
= os
->bfd_section
->vma
+ last
->lma
- last
->vma
;
5711 if (section_alignment
> 0)
5712 lma
= align_power (lma
, section_alignment
);
5713 os
->bfd_section
->lma
= lma
;
5716 os
->processed_lma
= TRUE
;
5718 /* Keep track of normal sections using the default
5719 lma region. We use this to set the lma for
5720 following sections. Overlays or other linker
5721 script assignment to lma might mean that the
5722 default lma == vma is incorrect.
5723 To avoid warnings about dot moving backwards when using
5724 -Ttext, don't start tracking sections until we find one
5725 of non-zero size or with lma set differently to vma.
5726 Do this tracking before we short-cut the loop so that we
5727 track changes for the case where the section size is zero,
5728 but the lma is set differently to the vma. This is
5729 important, if an orphan section is placed after an
5730 otherwise empty output section that has an explicit lma
5731 set, we want that lma reflected in the orphans lma. */
5732 if (((!IGNORE_SECTION (os
->bfd_section
)
5733 && (os
->bfd_section
->size
!= 0
5734 || (r
->last_os
== NULL
5735 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
5736 || (r
->last_os
!= NULL
5737 && dot
>= (r
->last_os
->output_section_statement
5738 .bfd_section
->vma
))))
5739 || os
->sectype
== first_overlay_section
)
5740 && os
->lma_region
== NULL
5741 && !bfd_link_relocatable (&link_info
))
5744 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5747 /* .tbss sections effectively have zero size. */
5748 if (!IS_TBSS (os
->bfd_section
)
5749 || bfd_link_relocatable (&link_info
))
5750 dotdelta
= TO_ADDR (os
->bfd_section
->size
);
5755 if (os
->update_dot_tree
!= 0)
5756 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5758 /* Update dot in the region ?
5759 We only do this if the section is going to be allocated,
5760 since unallocated sections do not contribute to the region's
5761 overall size in memory. */
5762 if (os
->region
!= NULL
5763 && (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)))
5765 os
->region
->current
= dot
;
5768 /* Make sure the new address is within the region. */
5769 os_region_check (os
, os
->region
, os
->addr_tree
,
5770 os
->bfd_section
->vma
);
5772 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
5773 && ((os
->bfd_section
->flags
& SEC_LOAD
)
5774 || os
->align_lma_with_input
))
5776 os
->lma_region
->current
= os
->bfd_section
->lma
+ dotdelta
;
5779 os_region_check (os
, os
->lma_region
, NULL
,
5780 os
->bfd_section
->lma
);
5786 case lang_constructors_statement_enum
:
5787 dot
= lang_size_sections_1 (&constructor_list
.head
,
5788 output_section_statement
,
5789 fill
, dot
, relax
, check_regions
);
5792 case lang_data_statement_enum
:
5794 unsigned int size
= 0;
5796 s
->data_statement
.output_offset
=
5797 dot
- output_section_statement
->bfd_section
->vma
;
5798 s
->data_statement
.output_section
=
5799 output_section_statement
->bfd_section
;
5801 /* We might refer to provided symbols in the expression, and
5802 need to mark them as needed. */
5803 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5805 switch (s
->data_statement
.type
)
5823 if (size
< TO_SIZE ((unsigned) 1))
5824 size
= TO_SIZE ((unsigned) 1);
5825 dot
+= TO_ADDR (size
);
5826 if (!(output_section_statement
->bfd_section
->flags
5828 output_section_statement
->bfd_section
->size
5829 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5834 case lang_reloc_statement_enum
:
5838 s
->reloc_statement
.output_offset
=
5839 dot
- output_section_statement
->bfd_section
->vma
;
5840 s
->reloc_statement
.output_section
=
5841 output_section_statement
->bfd_section
;
5842 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
5843 dot
+= TO_ADDR (size
);
5844 if (!(output_section_statement
->bfd_section
->flags
5846 output_section_statement
->bfd_section
->size
5847 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5851 case lang_wild_statement_enum
:
5852 dot
= lang_size_sections_1 (&s
->wild_statement
.children
.head
,
5853 output_section_statement
,
5854 fill
, dot
, relax
, check_regions
);
5857 case lang_object_symbols_statement_enum
:
5858 link_info
.create_object_symbols_section
5859 = output_section_statement
->bfd_section
;
5860 output_section_statement
->bfd_section
->flags
|= SEC_KEEP
;
5863 case lang_output_statement_enum
:
5864 case lang_target_statement_enum
:
5867 case lang_input_section_enum
:
5871 i
= s
->input_section
.section
;
5876 if (!bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
5877 einfo (_("%F%P: can't relax section: %E\n"));
5881 dot
= size_input_section (prev
, output_section_statement
,
5886 case lang_input_statement_enum
:
5889 case lang_fill_statement_enum
:
5890 s
->fill_statement
.output_section
=
5891 output_section_statement
->bfd_section
;
5893 fill
= s
->fill_statement
.fill
;
5896 case lang_assignment_statement_enum
:
5898 bfd_vma newdot
= dot
;
5899 etree_type
*tree
= s
->assignment_statement
.exp
;
5901 expld
.dataseg
.relro
= exp_seg_relro_none
;
5903 exp_fold_tree (tree
,
5904 output_section_statement
->bfd_section
,
5907 ldlang_check_relro_region (s
, &expld
.dataseg
);
5909 expld
.dataseg
.relro
= exp_seg_relro_none
;
5911 /* This symbol may be relative to this section. */
5912 if ((tree
->type
.node_class
== etree_provided
5913 || tree
->type
.node_class
== etree_assign
)
5914 && (tree
->assign
.dst
[0] != '.'
5915 || tree
->assign
.dst
[1] != '\0'))
5916 output_section_statement
->update_dot
= 1;
5918 if (!output_section_statement
->ignored
)
5920 if (output_section_statement
== abs_output_section
)
5922 /* If we don't have an output section, then just adjust
5923 the default memory address. */
5924 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
5925 FALSE
)->current
= newdot
;
5927 else if (newdot
!= dot
)
5929 /* Insert a pad after this statement. We can't
5930 put the pad before when relaxing, in case the
5931 assignment references dot. */
5932 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
5933 output_section_statement
->bfd_section
, dot
);
5935 /* Don't neuter the pad below when relaxing. */
5938 /* If dot is advanced, this implies that the section
5939 should have space allocated to it, unless the
5940 user has explicitly stated that the section
5941 should not be allocated. */
5942 if (output_section_statement
->sectype
!= noalloc_section
5943 && (output_section_statement
->sectype
!= noload_section
5944 || (bfd_get_flavour (link_info
.output_bfd
)
5945 == bfd_target_elf_flavour
)))
5946 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
5953 case lang_padding_statement_enum
:
5954 /* If this is the first time lang_size_sections is called,
5955 we won't have any padding statements. If this is the
5956 second or later passes when relaxing, we should allow
5957 padding to shrink. If padding is needed on this pass, it
5958 will be added back in. */
5959 s
->padding_statement
.size
= 0;
5961 /* Make sure output_offset is valid. If relaxation shrinks
5962 the section and this pad isn't needed, it's possible to
5963 have output_offset larger than the final size of the
5964 section. bfd_set_section_contents will complain even for
5965 a pad size of zero. */
5966 s
->padding_statement
.output_offset
5967 = dot
- output_section_statement
->bfd_section
->vma
;
5970 case lang_group_statement_enum
:
5971 dot
= lang_size_sections_1 (&s
->group_statement
.children
.head
,
5972 output_section_statement
,
5973 fill
, dot
, relax
, check_regions
);
5976 case lang_insert_statement_enum
:
5979 /* We can only get here when relaxing is turned on. */
5980 case lang_address_statement_enum
:
5987 prev
= &s
->header
.next
;
5992 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
5993 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
5994 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
5995 segments. We are allowed an opportunity to override this decision. */
5998 ldlang_override_segment_assignment (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5999 bfd
*abfd ATTRIBUTE_UNUSED
,
6000 asection
*current_section
,
6001 asection
*previous_section
,
6002 bfd_boolean new_segment
)
6004 lang_output_section_statement_type
*cur
;
6005 lang_output_section_statement_type
*prev
;
6007 /* The checks below are only necessary when the BFD library has decided
6008 that the two sections ought to be placed into the same segment. */
6012 /* Paranoia checks. */
6013 if (current_section
== NULL
|| previous_section
== NULL
)
6016 /* If this flag is set, the target never wants code and non-code
6017 sections comingled in the same segment. */
6018 if (config
.separate_code
6019 && ((current_section
->flags
^ previous_section
->flags
) & SEC_CODE
))
6022 /* Find the memory regions associated with the two sections.
6023 We call lang_output_section_find() here rather than scanning the list
6024 of output sections looking for a matching section pointer because if
6025 we have a large number of sections then a hash lookup is faster. */
6026 cur
= lang_output_section_find (current_section
->name
);
6027 prev
= lang_output_section_find (previous_section
->name
);
6029 /* More paranoia. */
6030 if (cur
== NULL
|| prev
== NULL
)
6033 /* If the regions are different then force the sections to live in
6034 different segments. See the email thread starting at the following
6035 URL for the reasons why this is necessary:
6036 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
6037 return cur
->region
!= prev
->region
;
6041 one_lang_size_sections_pass (bfd_boolean
*relax
, bfd_boolean check_regions
)
6043 lang_statement_iteration
++;
6044 if (expld
.phase
!= lang_mark_phase_enum
)
6045 lang_sizing_iteration
++;
6046 lang_size_sections_1 (&statement_list
.head
, abs_output_section
,
6047 0, 0, relax
, check_regions
);
6051 lang_size_segment (seg_align_type
*seg
)
6053 /* If XXX_SEGMENT_ALIGN XXX_SEGMENT_END pair was seen, check whether
6054 a page could be saved in the data segment. */
6055 bfd_vma first
, last
;
6057 first
= -seg
->base
& (seg
->pagesize
- 1);
6058 last
= seg
->end
& (seg
->pagesize
- 1);
6060 && ((seg
->base
& ~(seg
->pagesize
- 1))
6061 != (seg
->end
& ~(seg
->pagesize
- 1)))
6062 && first
+ last
<= seg
->pagesize
)
6064 seg
->phase
= exp_seg_adjust
;
6068 seg
->phase
= exp_seg_done
;
6073 lang_size_relro_segment_1 (seg_align_type
*seg
)
6075 bfd_vma relro_end
, desired_end
;
6078 /* Compute the expected PT_GNU_RELRO/PT_LOAD segment end. */
6079 relro_end
= ((seg
->relro_end
+ seg
->pagesize
- 1)
6080 & ~(seg
->pagesize
- 1));
6082 /* Adjust by the offset arg of XXX_SEGMENT_RELRO_END. */
6083 desired_end
= relro_end
- seg
->relro_offset
;
6085 /* For sections in the relro segment.. */
6086 for (sec
= link_info
.output_bfd
->section_last
; sec
; sec
= sec
->prev
)
6087 if ((sec
->flags
& SEC_ALLOC
) != 0
6088 && sec
->vma
>= seg
->base
6089 && sec
->vma
< seg
->relro_end
- seg
->relro_offset
)
6091 /* Where do we want to put this section so that it ends as
6093 bfd_vma start
, end
, bump
;
6095 end
= start
= sec
->vma
;
6097 end
+= TO_ADDR (sec
->size
);
6098 bump
= desired_end
- end
;
6099 /* We'd like to increase START by BUMP, but we must heed
6100 alignment so the increase might be less than optimum. */
6102 start
&= ~(((bfd_vma
) 1 << sec
->alignment_power
) - 1);
6103 /* This is now the desired end for the previous section. */
6104 desired_end
= start
;
6107 seg
->phase
= exp_seg_relro_adjust
;
6108 ASSERT (desired_end
>= seg
->base
);
6109 seg
->base
= desired_end
;
6114 lang_size_relro_segment (bfd_boolean
*relax
, bfd_boolean check_regions
)
6116 bfd_boolean do_reset
= FALSE
;
6117 bfd_boolean do_data_relro
;
6118 bfd_vma data_initial_base
, data_relro_end
;
6120 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
6122 do_data_relro
= TRUE
;
6123 data_initial_base
= expld
.dataseg
.base
;
6124 data_relro_end
= lang_size_relro_segment_1 (&expld
.dataseg
);
6128 do_data_relro
= FALSE
;
6129 data_initial_base
= data_relro_end
= 0;
6134 lang_reset_memory_regions ();
6135 one_lang_size_sections_pass (relax
, check_regions
);
6137 /* Assignments to dot, or to output section address in a user
6138 script have increased padding over the original. Revert. */
6139 if (do_data_relro
&& expld
.dataseg
.relro_end
> data_relro_end
)
6141 expld
.dataseg
.base
= data_initial_base
;;
6146 if (!do_data_relro
&& lang_size_segment (&expld
.dataseg
))
6153 lang_size_sections (bfd_boolean
*relax
, bfd_boolean check_regions
)
6155 expld
.phase
= lang_allocating_phase_enum
;
6156 expld
.dataseg
.phase
= exp_seg_none
;
6158 one_lang_size_sections_pass (relax
, check_regions
);
6160 if (expld
.dataseg
.phase
!= exp_seg_end_seen
)
6161 expld
.dataseg
.phase
= exp_seg_done
;
6163 if (expld
.dataseg
.phase
== exp_seg_end_seen
)
6165 bfd_boolean do_reset
6166 = lang_size_relro_segment (relax
, check_regions
);
6170 lang_reset_memory_regions ();
6171 one_lang_size_sections_pass (relax
, check_regions
);
6174 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
6176 link_info
.relro_start
= expld
.dataseg
.base
;
6177 link_info
.relro_end
= expld
.dataseg
.relro_end
;
6182 static lang_output_section_statement_type
*current_section
;
6183 static lang_assignment_statement_type
*current_assign
;
6184 static bfd_boolean prefer_next_section
;
6186 /* Worker function for lang_do_assignments. Recursiveness goes here. */
6189 lang_do_assignments_1 (lang_statement_union_type
*s
,
6190 lang_output_section_statement_type
*current_os
,
6193 bfd_boolean
*found_end
)
6195 for (; s
!= NULL
; s
= s
->header
.next
)
6197 switch (s
->header
.type
)
6199 case lang_constructors_statement_enum
:
6200 dot
= lang_do_assignments_1 (constructor_list
.head
,
6201 current_os
, fill
, dot
, found_end
);
6204 case lang_output_section_statement_enum
:
6206 lang_output_section_statement_type
*os
;
6209 os
= &(s
->output_section_statement
);
6210 os
->after_end
= *found_end
;
6211 init_opb (os
->bfd_section
);
6212 if (os
->bfd_section
!= NULL
&& !os
->ignored
)
6214 if ((os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
6216 current_section
= os
;
6217 prefer_next_section
= FALSE
;
6219 dot
= os
->bfd_section
->vma
;
6221 newdot
= lang_do_assignments_1 (os
->children
.head
,
6222 os
, os
->fill
, dot
, found_end
);
6225 if (os
->bfd_section
!= NULL
)
6227 /* .tbss sections effectively have zero size. */
6228 if (!IS_TBSS (os
->bfd_section
)
6229 || bfd_link_relocatable (&link_info
))
6230 dot
+= TO_ADDR (os
->bfd_section
->size
);
6232 if (os
->update_dot_tree
!= NULL
)
6233 exp_fold_tree (os
->update_dot_tree
,
6234 bfd_abs_section_ptr
, &dot
);
6242 case lang_wild_statement_enum
:
6244 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
6245 current_os
, fill
, dot
, found_end
);
6248 case lang_object_symbols_statement_enum
:
6249 case lang_output_statement_enum
:
6250 case lang_target_statement_enum
:
6253 case lang_data_statement_enum
:
6254 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
6255 if (expld
.result
.valid_p
)
6257 s
->data_statement
.value
= expld
.result
.value
;
6258 if (expld
.result
.section
!= NULL
)
6259 s
->data_statement
.value
+= expld
.result
.section
->vma
;
6261 else if (expld
.phase
== lang_final_phase_enum
)
6262 einfo (_("%F%P: invalid data statement\n"));
6265 switch (s
->data_statement
.type
)
6283 if (size
< TO_SIZE ((unsigned) 1))
6284 size
= TO_SIZE ((unsigned) 1);
6285 dot
+= TO_ADDR (size
);
6289 case lang_reloc_statement_enum
:
6290 exp_fold_tree (s
->reloc_statement
.addend_exp
,
6291 bfd_abs_section_ptr
, &dot
);
6292 if (expld
.result
.valid_p
)
6293 s
->reloc_statement
.addend_value
= expld
.result
.value
;
6294 else if (expld
.phase
== lang_final_phase_enum
)
6295 einfo (_("%F%P: invalid reloc statement\n"));
6296 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
6299 case lang_input_section_enum
:
6301 asection
*in
= s
->input_section
.section
;
6303 if ((in
->flags
& SEC_EXCLUDE
) == 0)
6304 dot
+= TO_ADDR (in
->size
);
6308 case lang_input_statement_enum
:
6311 case lang_fill_statement_enum
:
6312 fill
= s
->fill_statement
.fill
;
6315 case lang_assignment_statement_enum
:
6316 current_assign
= &s
->assignment_statement
;
6317 if (current_assign
->exp
->type
.node_class
!= etree_assert
)
6319 const char *p
= current_assign
->exp
->assign
.dst
;
6321 if (current_os
== abs_output_section
&& p
[0] == '.' && p
[1] == 0)
6322 prefer_next_section
= TRUE
;
6326 if (strcmp (p
, "end") == 0)
6329 exp_fold_tree (s
->assignment_statement
.exp
,
6330 (current_os
->bfd_section
!= NULL
6331 ? current_os
->bfd_section
: bfd_und_section_ptr
),
6335 case lang_padding_statement_enum
:
6336 dot
+= TO_ADDR (s
->padding_statement
.size
);
6339 case lang_group_statement_enum
:
6340 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
6341 current_os
, fill
, dot
, found_end
);
6344 case lang_insert_statement_enum
:
6347 case lang_address_statement_enum
:
6359 lang_do_assignments (lang_phase_type phase
)
6361 bfd_boolean found_end
= FALSE
;
6363 current_section
= NULL
;
6364 prefer_next_section
= FALSE
;
6365 expld
.phase
= phase
;
6366 lang_statement_iteration
++;
6367 lang_do_assignments_1 (statement_list
.head
,
6368 abs_output_section
, NULL
, 0, &found_end
);
6371 /* For an assignment statement outside of an output section statement,
6372 choose the best of neighbouring output sections to use for values
6376 section_for_dot (void)
6380 /* Assignments belong to the previous output section, unless there
6381 has been an assignment to "dot", in which case following
6382 assignments belong to the next output section. (The assumption
6383 is that an assignment to "dot" is setting up the address for the
6384 next output section.) Except that past the assignment to "_end"
6385 we always associate with the previous section. This exception is
6386 for targets like SH that define an alloc .stack or other
6387 weirdness after non-alloc sections. */
6388 if (current_section
== NULL
|| prefer_next_section
)
6390 lang_statement_union_type
*stmt
;
6391 lang_output_section_statement_type
*os
;
6393 for (stmt
= (lang_statement_union_type
*) current_assign
;
6395 stmt
= stmt
->header
.next
)
6396 if (stmt
->header
.type
== lang_output_section_statement_enum
)
6399 os
= &stmt
->output_section_statement
;
6402 && (os
->bfd_section
== NULL
6403 || (os
->bfd_section
->flags
& SEC_EXCLUDE
) != 0
6404 || bfd_section_removed_from_list (link_info
.output_bfd
,
6408 if (current_section
== NULL
|| os
== NULL
|| !os
->after_end
)
6411 s
= os
->bfd_section
;
6413 s
= link_info
.output_bfd
->section_last
;
6415 && ((s
->flags
& SEC_ALLOC
) == 0
6416 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6421 return bfd_abs_section_ptr
;
6425 s
= current_section
->bfd_section
;
6427 /* The section may have been stripped. */
6429 && ((s
->flags
& SEC_EXCLUDE
) != 0
6430 || (s
->flags
& SEC_ALLOC
) == 0
6431 || (s
->flags
& SEC_THREAD_LOCAL
) != 0
6432 || bfd_section_removed_from_list (link_info
.output_bfd
, s
)))
6435 s
= link_info
.output_bfd
->sections
;
6437 && ((s
->flags
& SEC_ALLOC
) == 0
6438 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6443 return bfd_abs_section_ptr
;
6446 /* Array of __start/__stop/.startof./.sizeof/ symbols. */
6448 static struct bfd_link_hash_entry
**start_stop_syms
;
6449 static size_t start_stop_count
= 0;
6450 static size_t start_stop_alloc
= 0;
6452 /* Give start/stop SYMBOL for SEC a preliminary definition, and add it
6453 to start_stop_syms. */
6456 lang_define_start_stop (const char *symbol
, asection
*sec
)
6458 struct bfd_link_hash_entry
*h
;
6460 h
= bfd_define_start_stop (link_info
.output_bfd
, &link_info
, symbol
, sec
);
6463 if (start_stop_count
== start_stop_alloc
)
6465 start_stop_alloc
= 2 * start_stop_alloc
+ 10;
6467 = xrealloc (start_stop_syms
,
6468 start_stop_alloc
* sizeof (*start_stop_syms
));
6470 start_stop_syms
[start_stop_count
++] = h
;
6474 /* Check for input sections whose names match references to
6475 __start_SECNAME or __stop_SECNAME symbols. Give the symbols
6476 preliminary definitions. */
6479 lang_init_start_stop (void)
6483 char leading_char
= bfd_get_symbol_leading_char (link_info
.output_bfd
);
6485 for (abfd
= link_info
.input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6486 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6489 const char *secname
= s
->name
;
6491 for (ps
= secname
; *ps
!= '\0'; ps
++)
6492 if (!ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
6496 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6498 symbol
[0] = leading_char
;
6499 sprintf (symbol
+ (leading_char
!= 0), "__start_%s", secname
);
6500 lang_define_start_stop (symbol
, s
);
6502 symbol
[1] = leading_char
;
6503 memcpy (symbol
+ 1 + (leading_char
!= 0), "__stop", 6);
6504 lang_define_start_stop (symbol
+ 1, s
);
6511 /* Iterate over start_stop_syms. */
6514 foreach_start_stop (void (*func
) (struct bfd_link_hash_entry
*))
6518 for (i
= 0; i
< start_stop_count
; ++i
)
6519 func (start_stop_syms
[i
]);
6522 /* __start and __stop symbols are only supposed to be defined by the
6523 linker for orphan sections, but we now extend that to sections that
6524 map to an output section of the same name. The symbols were
6525 defined early for --gc-sections, before we mapped input to output
6526 sections, so undo those that don't satisfy this rule. */
6529 undef_start_stop (struct bfd_link_hash_entry
*h
)
6531 if (h
->ldscript_def
)
6534 if (h
->u
.def
.section
->output_section
== NULL
6535 || h
->u
.def
.section
->output_section
->owner
!= link_info
.output_bfd
6536 || strcmp (h
->u
.def
.section
->name
,
6537 h
->u
.def
.section
->output_section
->name
) != 0)
6539 asection
*sec
= bfd_get_section_by_name (link_info
.output_bfd
,
6540 h
->u
.def
.section
->name
);
6543 /* When there are more than one input sections with the same
6544 section name, SECNAME, linker picks the first one to define
6545 __start_SECNAME and __stop_SECNAME symbols. When the first
6546 input section is removed by comdat group, we need to check
6547 if there is still an output section with section name
6550 for (i
= sec
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
6551 if (strcmp (h
->u
.def
.section
->name
, i
->name
) == 0)
6553 h
->u
.def
.section
= i
;
6557 h
->type
= bfd_link_hash_undefined
;
6558 h
->u
.undef
.abfd
= NULL
;
6563 lang_undef_start_stop (void)
6565 foreach_start_stop (undef_start_stop
);
6568 /* Check for output sections whose names match references to
6569 .startof.SECNAME or .sizeof.SECNAME symbols. Give the symbols
6570 preliminary definitions. */
6573 lang_init_startof_sizeof (void)
6577 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6579 const char *secname
= s
->name
;
6580 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6582 sprintf (symbol
, ".startof.%s", secname
);
6583 lang_define_start_stop (symbol
, s
);
6585 memcpy (symbol
+ 1, ".size", 5);
6586 lang_define_start_stop (symbol
+ 1, s
);
6591 /* Set .startof., .sizeof., __start and __stop symbols final values. */
6594 set_start_stop (struct bfd_link_hash_entry
*h
)
6597 || h
->type
!= bfd_link_hash_defined
)
6600 if (h
->root
.string
[0] == '.')
6602 /* .startof. or .sizeof. symbol.
6603 .startof. already has final value. */
6604 if (h
->root
.string
[2] == 'i')
6607 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6608 h
->u
.def
.section
= bfd_abs_section_ptr
;
6613 /* __start or __stop symbol. */
6614 int has_lead
= bfd_get_symbol_leading_char (link_info
.output_bfd
) != 0;
6616 h
->u
.def
.section
= h
->u
.def
.section
->output_section
;
6617 if (h
->root
.string
[4 + has_lead
] == 'o')
6620 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6626 lang_finalize_start_stop (void)
6628 foreach_start_stop (set_start_stop
);
6634 struct bfd_link_hash_entry
*h
;
6637 if ((bfd_link_relocatable (&link_info
) && !link_info
.gc_sections
)
6638 || bfd_link_dll (&link_info
))
6639 warn
= entry_from_cmdline
;
6643 /* Force the user to specify a root when generating a relocatable with
6644 --gc-sections, unless --gc-keep-exported was also given. */
6645 if (bfd_link_relocatable (&link_info
)
6646 && link_info
.gc_sections
6647 && !link_info
.gc_keep_exported
6648 && !(entry_from_cmdline
|| undef_from_cmdline
))
6649 einfo (_("%F%P: gc-sections requires either an entry or "
6650 "an undefined symbol\n"));
6652 if (entry_symbol
.name
== NULL
)
6654 /* No entry has been specified. Look for the default entry, but
6655 don't warn if we don't find it. */
6656 entry_symbol
.name
= entry_symbol_default
;
6660 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
6661 FALSE
, FALSE
, TRUE
);
6663 && (h
->type
== bfd_link_hash_defined
6664 || h
->type
== bfd_link_hash_defweak
)
6665 && h
->u
.def
.section
->output_section
!= NULL
)
6669 val
= (h
->u
.def
.value
6670 + bfd_section_vma (h
->u
.def
.section
->output_section
)
6671 + h
->u
.def
.section
->output_offset
);
6672 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6673 einfo (_("%F%P: %s: can't set start address\n"), entry_symbol
.name
);
6680 /* We couldn't find the entry symbol. Try parsing it as a
6682 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
6685 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6686 einfo (_("%F%P: can't set start address\n"));
6692 /* Can't find the entry symbol, and it's not a number. Use
6693 the first address in the text section. */
6694 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
6698 einfo (_("%P: warning: cannot find entry symbol %s;"
6699 " defaulting to %V\n"),
6701 bfd_section_vma (ts
));
6702 if (!bfd_set_start_address (link_info
.output_bfd
,
6703 bfd_section_vma (ts
)))
6704 einfo (_("%F%P: can't set start address\n"));
6709 einfo (_("%P: warning: cannot find entry symbol %s;"
6710 " not setting start address\n"),
6717 /* This is a small function used when we want to ignore errors from
6721 ignore_bfd_errors (const char *fmt ATTRIBUTE_UNUSED
,
6722 va_list ap ATTRIBUTE_UNUSED
)
6724 /* Don't do anything. */
6727 /* Check that the architecture of all the input files is compatible
6728 with the output file. Also call the backend to let it do any
6729 other checking that is needed. */
6734 lang_input_statement_type
*file
;
6736 const bfd_arch_info_type
*compatible
;
6738 for (file
= (void *) file_chain
.head
;
6742 #ifdef ENABLE_PLUGINS
6743 /* Don't check format of files claimed by plugin. */
6744 if (file
->flags
.claimed
)
6746 #endif /* ENABLE_PLUGINS */
6747 input_bfd
= file
->the_bfd
;
6749 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
6750 command_line
.accept_unknown_input_arch
);
6752 /* In general it is not possible to perform a relocatable
6753 link between differing object formats when the input
6754 file has relocations, because the relocations in the
6755 input format may not have equivalent representations in
6756 the output format (and besides BFD does not translate
6757 relocs for other link purposes than a final link). */
6758 if ((bfd_link_relocatable (&link_info
)
6759 || link_info
.emitrelocations
)
6760 && (compatible
== NULL
6761 || (bfd_get_flavour (input_bfd
)
6762 != bfd_get_flavour (link_info
.output_bfd
)))
6763 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
6765 einfo (_("%F%P: relocatable linking with relocations from"
6766 " format %s (%pB) to format %s (%pB) is not supported\n"),
6767 bfd_get_target (input_bfd
), input_bfd
,
6768 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
6769 /* einfo with %F exits. */
6772 if (compatible
== NULL
)
6774 if (command_line
.warn_mismatch
)
6775 einfo (_("%X%P: %s architecture of input file `%pB'"
6776 " is incompatible with %s output\n"),
6777 bfd_printable_name (input_bfd
), input_bfd
,
6778 bfd_printable_name (link_info
.output_bfd
));
6780 else if (bfd_count_sections (input_bfd
))
6782 /* If the input bfd has no contents, it shouldn't set the
6783 private data of the output bfd. */
6785 bfd_error_handler_type pfn
= NULL
;
6787 /* If we aren't supposed to warn about mismatched input
6788 files, temporarily set the BFD error handler to a
6789 function which will do nothing. We still want to call
6790 bfd_merge_private_bfd_data, since it may set up
6791 information which is needed in the output file. */
6792 if (!command_line
.warn_mismatch
)
6793 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
6794 if (!bfd_merge_private_bfd_data (input_bfd
, &link_info
))
6796 if (command_line
.warn_mismatch
)
6797 einfo (_("%X%P: failed to merge target specific data"
6798 " of file %pB\n"), input_bfd
);
6800 if (!command_line
.warn_mismatch
)
6801 bfd_set_error_handler (pfn
);
6806 /* Look through all the global common symbols and attach them to the
6807 correct section. The -sort-common command line switch may be used
6808 to roughly sort the entries by alignment. */
6813 if (link_info
.inhibit_common_definition
)
6815 if (bfd_link_relocatable (&link_info
)
6816 && !command_line
.force_common_definition
)
6819 if (!config
.sort_common
)
6820 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
6825 if (config
.sort_common
== sort_descending
)
6827 for (power
= 4; power
> 0; power
--)
6828 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6831 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6835 for (power
= 0; power
<= 4; power
++)
6836 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6838 power
= (unsigned int) -1;
6839 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6844 /* Place one common symbol in the correct section. */
6847 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
6849 unsigned int power_of_two
;
6853 if (h
->type
!= bfd_link_hash_common
)
6857 power_of_two
= h
->u
.c
.p
->alignment_power
;
6859 if (config
.sort_common
== sort_descending
6860 && power_of_two
< *(unsigned int *) info
)
6862 else if (config
.sort_common
== sort_ascending
6863 && power_of_two
> *(unsigned int *) info
)
6866 section
= h
->u
.c
.p
->section
;
6867 if (!bfd_define_common_symbol (link_info
.output_bfd
, &link_info
, h
))
6868 einfo (_("%F%P: could not define common symbol `%pT': %E\n"),
6871 if (config
.map_file
!= NULL
)
6873 static bfd_boolean header_printed
;
6878 if (!header_printed
)
6880 minfo (_("\nAllocating common symbols\n"));
6881 minfo (_("Common symbol size file\n\n"));
6882 header_printed
= TRUE
;
6885 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
6886 DMGL_ANSI
| DMGL_PARAMS
);
6889 minfo ("%s", h
->root
.string
);
6890 len
= strlen (h
->root
.string
);
6895 len
= strlen (name
);
6911 if (size
<= 0xffffffff)
6912 sprintf (buf
, "%lx", (unsigned long) size
);
6914 sprintf_vma (buf
, size
);
6924 minfo ("%pB\n", section
->owner
);
6930 /* Handle a single orphan section S, placing the orphan into an appropriate
6931 output section. The effects of the --orphan-handling command line
6932 option are handled here. */
6935 ldlang_place_orphan (asection
*s
)
6937 if (config
.orphan_handling
== orphan_handling_discard
)
6939 lang_output_section_statement_type
*os
;
6940 os
= lang_output_section_statement_lookup (DISCARD_SECTION_NAME
, 0,
6942 if (os
->addr_tree
== NULL
6943 && (bfd_link_relocatable (&link_info
)
6944 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6945 os
->addr_tree
= exp_intop (0);
6946 lang_add_section (&os
->children
, s
, NULL
, os
);
6950 lang_output_section_statement_type
*os
;
6951 const char *name
= s
->name
;
6954 if (config
.orphan_handling
== orphan_handling_error
)
6955 einfo (_("%X%P: error: unplaced orphan section `%pA' from `%pB'\n"),
6958 if (config
.unique_orphan_sections
|| unique_section_p (s
, NULL
))
6959 constraint
= SPECIAL
;
6961 os
= ldemul_place_orphan (s
, name
, constraint
);
6964 os
= lang_output_section_statement_lookup (name
, constraint
, TRUE
);
6965 if (os
->addr_tree
== NULL
6966 && (bfd_link_relocatable (&link_info
)
6967 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6968 os
->addr_tree
= exp_intop (0);
6969 lang_add_section (&os
->children
, s
, NULL
, os
);
6972 if (config
.orphan_handling
== orphan_handling_warn
)
6973 einfo (_("%P: warning: orphan section `%pA' from `%pB' being "
6974 "placed in section `%s'\n"),
6975 s
, s
->owner
, os
->name
);
6979 /* Run through the input files and ensure that every input section has
6980 somewhere to go. If one is found without a destination then create
6981 an input request and place it into the statement tree. */
6984 lang_place_orphans (void)
6986 LANG_FOR_EACH_INPUT_STATEMENT (file
)
6990 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6992 if (s
->output_section
== NULL
)
6994 /* This section of the file is not attached, root
6995 around for a sensible place for it to go. */
6997 if (file
->flags
.just_syms
)
6998 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
6999 else if (lang_discard_section_p (s
))
7000 s
->output_section
= bfd_abs_section_ptr
;
7001 else if (strcmp (s
->name
, "COMMON") == 0)
7003 /* This is a lonely common section which must have
7004 come from an archive. We attach to the section
7005 with the wildcard. */
7006 if (!bfd_link_relocatable (&link_info
)
7007 || command_line
.force_common_definition
)
7009 if (default_common_section
== NULL
)
7010 default_common_section
7011 = lang_output_section_statement_lookup (".bss", 0,
7013 lang_add_section (&default_common_section
->children
, s
,
7014 NULL
, default_common_section
);
7018 ldlang_place_orphan (s
);
7025 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
7027 flagword
*ptr_flags
;
7029 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
7035 /* PR 17900: An exclamation mark in the attributes reverses
7036 the sense of any of the attributes that follow. */
7039 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
7043 *ptr_flags
|= SEC_ALLOC
;
7047 *ptr_flags
|= SEC_READONLY
;
7051 *ptr_flags
|= SEC_DATA
;
7055 *ptr_flags
|= SEC_CODE
;
7060 *ptr_flags
|= SEC_LOAD
;
7064 einfo (_("%F%P: invalid character %c (%d) in flags\n"),
7072 /* Call a function on each real input file. This function will be
7073 called on an archive, but not on the elements. */
7076 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
7078 lang_input_statement_type
*f
;
7080 for (f
= (void *) input_file_chain
.head
;
7082 f
= f
->next_real_file
)
7087 /* Call a function on each real file. The function will be called on
7088 all the elements of an archive which are included in the link, but
7089 will not be called on the archive file itself. */
7092 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
7094 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7102 ldlang_add_file (lang_input_statement_type
*entry
)
7104 lang_statement_append (&file_chain
, entry
, &entry
->next
);
7106 /* The BFD linker needs to have a list of all input BFDs involved in
7108 ASSERT (entry
->the_bfd
->link
.next
== NULL
);
7109 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
7111 *link_info
.input_bfds_tail
= entry
->the_bfd
;
7112 link_info
.input_bfds_tail
= &entry
->the_bfd
->link
.next
;
7113 bfd_set_usrdata (entry
->the_bfd
, entry
);
7114 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
7116 /* Look through the sections and check for any which should not be
7117 included in the link. We need to do this now, so that we can
7118 notice when the backend linker tries to report multiple
7119 definition errors for symbols which are in sections we aren't
7120 going to link. FIXME: It might be better to entirely ignore
7121 symbols which are defined in sections which are going to be
7122 discarded. This would require modifying the backend linker for
7123 each backend which might set the SEC_LINK_ONCE flag. If we do
7124 this, we should probably handle SEC_EXCLUDE in the same way. */
7126 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
7130 lang_add_output (const char *name
, int from_script
)
7132 /* Make -o on command line override OUTPUT in script. */
7133 if (!had_output_filename
|| !from_script
)
7135 output_filename
= name
;
7136 had_output_filename
= TRUE
;
7140 lang_output_section_statement_type
*
7141 lang_enter_output_section_statement (const char *output_section_statement_name
,
7142 etree_type
*address_exp
,
7143 enum section_type sectype
,
7145 etree_type
*subalign
,
7148 int align_with_input
)
7150 lang_output_section_statement_type
*os
;
7152 os
= lang_output_section_statement_lookup (output_section_statement_name
,
7154 current_section
= os
;
7156 if (os
->addr_tree
== NULL
)
7158 os
->addr_tree
= address_exp
;
7160 os
->sectype
= sectype
;
7161 if (sectype
!= noload_section
)
7162 os
->flags
= SEC_NO_FLAGS
;
7164 os
->flags
= SEC_NEVER_LOAD
;
7165 os
->block_value
= 1;
7167 /* Make next things chain into subchain of this. */
7168 push_stat_ptr (&os
->children
);
7170 os
->align_lma_with_input
= align_with_input
== ALIGN_WITH_INPUT
;
7171 if (os
->align_lma_with_input
&& align
!= NULL
)
7172 einfo (_("%F%P:%pS: error: align with input and explicit align specified\n"),
7175 os
->subsection_alignment
= subalign
;
7176 os
->section_alignment
= align
;
7178 os
->load_base
= ebase
;
7185 lang_output_statement_type
*new_stmt
;
7187 new_stmt
= new_stat (lang_output_statement
, stat_ptr
);
7188 new_stmt
->name
= output_filename
;
7191 /* Reset the current counters in the regions. */
7194 lang_reset_memory_regions (void)
7196 lang_memory_region_type
*p
= lang_memory_region_list
;
7198 lang_output_section_statement_type
*os
;
7200 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
7202 p
->current
= p
->origin
;
7206 for (os
= (void *) lang_os_list
.head
;
7210 os
->processed_vma
= FALSE
;
7211 os
->processed_lma
= FALSE
;
7214 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
7216 /* Save the last size for possible use by bfd_relax_section. */
7217 o
->rawsize
= o
->size
;
7218 if (!(o
->flags
& SEC_FIXED_SIZE
))
7223 /* Worker for lang_gc_sections_1. */
7226 gc_section_callback (lang_wild_statement_type
*ptr
,
7227 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7229 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
7230 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7231 void *data ATTRIBUTE_UNUSED
)
7233 /* If the wild pattern was marked KEEP, the member sections
7234 should be as well. */
7235 if (ptr
->keep_sections
)
7236 section
->flags
|= SEC_KEEP
;
7239 /* Iterate over sections marking them against GC. */
7242 lang_gc_sections_1 (lang_statement_union_type
*s
)
7244 for (; s
!= NULL
; s
= s
->header
.next
)
7246 switch (s
->header
.type
)
7248 case lang_wild_statement_enum
:
7249 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
7251 case lang_constructors_statement_enum
:
7252 lang_gc_sections_1 (constructor_list
.head
);
7254 case lang_output_section_statement_enum
:
7255 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
7257 case lang_group_statement_enum
:
7258 lang_gc_sections_1 (s
->group_statement
.children
.head
);
7267 lang_gc_sections (void)
7269 /* Keep all sections so marked in the link script. */
7270 lang_gc_sections_1 (statement_list
.head
);
7272 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
7273 the special case of debug info. (See bfd/stabs.c)
7274 Twiddle the flag here, to simplify later linker code. */
7275 if (bfd_link_relocatable (&link_info
))
7277 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7280 #ifdef ENABLE_PLUGINS
7281 if (f
->flags
.claimed
)
7284 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7285 if ((sec
->flags
& SEC_DEBUGGING
) == 0)
7286 sec
->flags
&= ~SEC_EXCLUDE
;
7290 if (link_info
.gc_sections
)
7291 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
7294 /* Worker for lang_find_relro_sections_1. */
7297 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
7298 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7300 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
7301 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7304 /* Discarded, excluded and ignored sections effectively have zero
7306 if (section
->output_section
!= NULL
7307 && section
->output_section
->owner
== link_info
.output_bfd
7308 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
7309 && !IGNORE_SECTION (section
)
7310 && section
->size
!= 0)
7312 bfd_boolean
*has_relro_section
= (bfd_boolean
*) data
;
7313 *has_relro_section
= TRUE
;
7317 /* Iterate over sections for relro sections. */
7320 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
7321 seg_align_type
*seg
,
7322 bfd_boolean
*has_relro_section
)
7324 if (*has_relro_section
)
7327 for (; s
!= NULL
; s
= s
->header
.next
)
7329 if (s
== seg
->relro_end_stat
)
7332 switch (s
->header
.type
)
7334 case lang_wild_statement_enum
:
7335 walk_wild (&s
->wild_statement
,
7336 find_relro_section_callback
,
7339 case lang_constructors_statement_enum
:
7340 lang_find_relro_sections_1 (constructor_list
.head
,
7341 seg
, has_relro_section
);
7343 case lang_output_section_statement_enum
:
7344 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
7345 seg
, has_relro_section
);
7347 case lang_group_statement_enum
:
7348 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
7349 seg
, has_relro_section
);
7358 lang_find_relro_sections (void)
7360 bfd_boolean has_relro_section
= FALSE
;
7362 /* Check all sections in the link script. */
7364 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
7365 &expld
.dataseg
, &has_relro_section
);
7367 if (!has_relro_section
)
7368 link_info
.relro
= FALSE
;
7371 /* Relax all sections until bfd_relax_section gives up. */
7374 lang_relax_sections (bfd_boolean need_layout
)
7376 if (RELAXATION_ENABLED
)
7378 /* We may need more than one relaxation pass. */
7379 int i
= link_info
.relax_pass
;
7381 /* The backend can use it to determine the current pass. */
7382 link_info
.relax_pass
= 0;
7386 /* Keep relaxing until bfd_relax_section gives up. */
7387 bfd_boolean relax_again
;
7389 link_info
.relax_trip
= -1;
7392 link_info
.relax_trip
++;
7394 /* Note: pe-dll.c does something like this also. If you find
7395 you need to change this code, you probably need to change
7396 pe-dll.c also. DJ */
7398 /* Do all the assignments with our current guesses as to
7400 lang_do_assignments (lang_assigning_phase_enum
);
7402 /* We must do this after lang_do_assignments, because it uses
7404 lang_reset_memory_regions ();
7406 /* Perform another relax pass - this time we know where the
7407 globals are, so can make a better guess. */
7408 relax_again
= FALSE
;
7409 lang_size_sections (&relax_again
, FALSE
);
7411 while (relax_again
);
7413 link_info
.relax_pass
++;
7420 /* Final extra sizing to report errors. */
7421 lang_do_assignments (lang_assigning_phase_enum
);
7422 lang_reset_memory_regions ();
7423 lang_size_sections (NULL
, TRUE
);
7427 #ifdef ENABLE_PLUGINS
7428 /* Find the insert point for the plugin's replacement files. We
7429 place them after the first claimed real object file, or if the
7430 first claimed object is an archive member, after the last real
7431 object file immediately preceding the archive. In the event
7432 no objects have been claimed at all, we return the first dummy
7433 object file on the list as the insert point; that works, but
7434 the callee must be careful when relinking the file_chain as it
7435 is not actually on that chain, only the statement_list and the
7436 input_file list; in that case, the replacement files must be
7437 inserted at the head of the file_chain. */
7439 static lang_input_statement_type
*
7440 find_replacements_insert_point (bfd_boolean
*before
)
7442 lang_input_statement_type
*claim1
, *lastobject
;
7443 lastobject
= (void *) input_file_chain
.head
;
7444 for (claim1
= (void *) file_chain
.head
;
7446 claim1
= claim1
->next
)
7448 if (claim1
->flags
.claimed
)
7450 *before
= claim1
->flags
.claim_archive
;
7451 return claim1
->flags
.claim_archive
? lastobject
: claim1
;
7453 /* Update lastobject if this is a real object file. */
7454 if (claim1
->the_bfd
!= NULL
&& claim1
->the_bfd
->my_archive
== NULL
)
7455 lastobject
= claim1
;
7457 /* No files were claimed by the plugin. Choose the last object
7458 file found on the list (maybe the first, dummy entry) as the
7464 /* Find where to insert ADD, an archive element or shared library
7465 added during a rescan. */
7467 static lang_input_statement_type
**
7468 find_rescan_insertion (lang_input_statement_type
*add
)
7470 bfd
*add_bfd
= add
->the_bfd
;
7471 lang_input_statement_type
*f
;
7472 lang_input_statement_type
*last_loaded
= NULL
;
7473 lang_input_statement_type
*before
= NULL
;
7474 lang_input_statement_type
**iter
= NULL
;
7476 if (add_bfd
->my_archive
!= NULL
)
7477 add_bfd
= add_bfd
->my_archive
;
7479 /* First look through the input file chain, to find an object file
7480 before the one we've rescanned. Normal object files always
7481 appear on both the input file chain and the file chain, so this
7482 lets us get quickly to somewhere near the correct place on the
7483 file chain if it is full of archive elements. Archives don't
7484 appear on the file chain, but if an element has been extracted
7485 then their input_statement->next points at it. */
7486 for (f
= (void *) input_file_chain
.head
;
7488 f
= f
->next_real_file
)
7490 if (f
->the_bfd
== add_bfd
)
7492 before
= last_loaded
;
7493 if (f
->next
!= NULL
)
7494 return &f
->next
->next
;
7496 if (f
->the_bfd
!= NULL
&& f
->next
!= NULL
)
7500 for (iter
= before
? &before
->next
: &file_chain
.head
->input_statement
.next
;
7502 iter
= &(*iter
)->next
)
7503 if (!(*iter
)->flags
.claim_archive
7504 && (*iter
)->the_bfd
->my_archive
== NULL
)
7510 /* Insert SRCLIST into DESTLIST after given element by chaining
7511 on FIELD as the next-pointer. (Counterintuitively does not need
7512 a pointer to the actual after-node itself, just its chain field.) */
7515 lang_list_insert_after (lang_statement_list_type
*destlist
,
7516 lang_statement_list_type
*srclist
,
7517 lang_statement_union_type
**field
)
7519 *(srclist
->tail
) = *field
;
7520 *field
= srclist
->head
;
7521 if (destlist
->tail
== field
)
7522 destlist
->tail
= srclist
->tail
;
7525 /* Detach new nodes added to DESTLIST since the time ORIGLIST
7526 was taken as a copy of it and leave them in ORIGLIST. */
7529 lang_list_remove_tail (lang_statement_list_type
*destlist
,
7530 lang_statement_list_type
*origlist
)
7532 union lang_statement_union
**savetail
;
7533 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
7534 ASSERT (origlist
->head
== destlist
->head
);
7535 savetail
= origlist
->tail
;
7536 origlist
->head
= *(savetail
);
7537 origlist
->tail
= destlist
->tail
;
7538 destlist
->tail
= savetail
;
7542 static lang_statement_union_type
**
7543 find_next_input_statement (lang_statement_union_type
**s
)
7545 for ( ; *s
; s
= &(*s
)->header
.next
)
7547 lang_statement_union_type
**t
;
7548 switch ((*s
)->header
.type
)
7550 case lang_input_statement_enum
:
7552 case lang_wild_statement_enum
:
7553 t
= &(*s
)->wild_statement
.children
.head
;
7555 case lang_group_statement_enum
:
7556 t
= &(*s
)->group_statement
.children
.head
;
7558 case lang_output_section_statement_enum
:
7559 t
= &(*s
)->output_section_statement
.children
.head
;
7564 t
= find_next_input_statement (t
);
7570 #endif /* ENABLE_PLUGINS */
7572 /* Add NAME to the list of garbage collection entry points. */
7575 lang_add_gc_name (const char *name
)
7577 struct bfd_sym_chain
*sym
;
7582 sym
= stat_alloc (sizeof (*sym
));
7584 sym
->next
= link_info
.gc_sym_list
;
7586 link_info
.gc_sym_list
= sym
;
7589 /* Check relocations. */
7592 lang_check_relocs (void)
7594 if (link_info
.check_relocs_after_open_input
)
7598 for (abfd
= link_info
.input_bfds
;
7599 abfd
!= (bfd
*) NULL
; abfd
= abfd
->link
.next
)
7600 if (!bfd_link_check_relocs (abfd
, &link_info
))
7602 /* No object output, fail return. */
7603 config
.make_executable
= FALSE
;
7604 /* Note: we do not abort the loop, but rather
7605 continue the scan in case there are other
7606 bad relocations to report. */
7611 /* Look through all output sections looking for places where we can
7612 propagate forward the lma region. */
7615 lang_propagate_lma_regions (void)
7617 lang_output_section_statement_type
*os
;
7619 for (os
= (void *) lang_os_list
.head
;
7623 if (os
->prev
!= NULL
7624 && os
->lma_region
== NULL
7625 && os
->load_base
== NULL
7626 && os
->addr_tree
== NULL
7627 && os
->region
== os
->prev
->region
)
7628 os
->lma_region
= os
->prev
->lma_region
;
7635 /* Finalize dynamic list. */
7636 if (link_info
.dynamic_list
)
7637 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
7639 current_target
= default_target
;
7641 /* Open the output file. */
7642 lang_for_each_statement (ldlang_open_output
);
7645 ldemul_create_output_section_statements ();
7647 /* Add to the hash table all undefineds on the command line. */
7648 lang_place_undefineds ();
7650 if (!bfd_section_already_linked_table_init ())
7651 einfo (_("%F%P: can not create hash table: %E\n"));
7653 /* Create a bfd for each input file. */
7654 current_target
= default_target
;
7655 lang_statement_iteration
++;
7656 open_input_bfds (statement_list
.head
, OPEN_BFD_NORMAL
);
7657 /* open_input_bfds also handles assignments, so we can give values
7658 to symbolic origin/length now. */
7659 lang_do_memory_regions ();
7661 #ifdef ENABLE_PLUGINS
7662 if (link_info
.lto_plugin_active
)
7664 lang_statement_list_type added
;
7665 lang_statement_list_type files
, inputfiles
;
7667 /* Now all files are read, let the plugin(s) decide if there
7668 are any more to be added to the link before we call the
7669 emulation's after_open hook. We create a private list of
7670 input statements for this purpose, which we will eventually
7671 insert into the global statement list after the first claimed
7674 /* We need to manipulate all three chains in synchrony. */
7676 inputfiles
= input_file_chain
;
7677 if (plugin_call_all_symbols_read ())
7678 einfo (_("%F%P: %s: plugin reported error after all symbols read\n"),
7679 plugin_error_plugin ());
7680 /* Open any newly added files, updating the file chains. */
7681 plugin_undefs
= link_info
.hash
->undefs_tail
;
7682 open_input_bfds (*added
.tail
, OPEN_BFD_NORMAL
);
7683 if (plugin_undefs
== link_info
.hash
->undefs_tail
)
7684 plugin_undefs
= NULL
;
7685 /* Restore the global list pointer now they have all been added. */
7686 lang_list_remove_tail (stat_ptr
, &added
);
7687 /* And detach the fresh ends of the file lists. */
7688 lang_list_remove_tail (&file_chain
, &files
);
7689 lang_list_remove_tail (&input_file_chain
, &inputfiles
);
7690 /* Were any new files added? */
7691 if (added
.head
!= NULL
)
7693 /* If so, we will insert them into the statement list immediately
7694 after the first input file that was claimed by the plugin,
7695 unless that file was an archive in which case it is inserted
7696 immediately before. */
7698 lang_statement_union_type
**prev
;
7699 plugin_insert
= find_replacements_insert_point (&before
);
7700 /* If a plugin adds input files without having claimed any, we
7701 don't really have a good idea where to place them. Just putting
7702 them at the start or end of the list is liable to leave them
7703 outside the crtbegin...crtend range. */
7704 ASSERT (plugin_insert
!= NULL
);
7705 /* Splice the new statement list into the old one. */
7706 prev
= &plugin_insert
->header
.next
;
7709 prev
= find_next_input_statement (prev
);
7710 if (*prev
!= (void *) plugin_insert
->next_real_file
)
7712 /* We didn't find the expected input statement.
7713 Fall back to adding after plugin_insert. */
7714 prev
= &plugin_insert
->header
.next
;
7717 lang_list_insert_after (stat_ptr
, &added
, prev
);
7718 /* Likewise for the file chains. */
7719 lang_list_insert_after (&input_file_chain
, &inputfiles
,
7720 (void *) &plugin_insert
->next_real_file
);
7721 /* We must be careful when relinking file_chain; we may need to
7722 insert the new files at the head of the list if the insert
7723 point chosen is the dummy first input file. */
7724 if (plugin_insert
->filename
)
7725 lang_list_insert_after (&file_chain
, &files
,
7726 (void *) &plugin_insert
->next
);
7728 lang_list_insert_after (&file_chain
, &files
, &file_chain
.head
);
7730 /* Rescan archives in case new undefined symbols have appeared. */
7732 lang_statement_iteration
++;
7733 open_input_bfds (statement_list
.head
, OPEN_BFD_RESCAN
);
7734 lang_list_remove_tail (&file_chain
, &files
);
7735 while (files
.head
!= NULL
)
7737 lang_input_statement_type
**insert
;
7738 lang_input_statement_type
**iter
, *temp
;
7741 insert
= find_rescan_insertion (&files
.head
->input_statement
);
7742 /* All elements from an archive can be added at once. */
7743 iter
= &files
.head
->input_statement
.next
;
7744 my_arch
= files
.head
->input_statement
.the_bfd
->my_archive
;
7745 if (my_arch
!= NULL
)
7746 for (; *iter
!= NULL
; iter
= &(*iter
)->next
)
7747 if ((*iter
)->the_bfd
->my_archive
!= my_arch
)
7750 *insert
= &files
.head
->input_statement
;
7751 files
.head
= (lang_statement_union_type
*) *iter
;
7753 if (my_arch
!= NULL
)
7755 lang_input_statement_type
*parent
= bfd_usrdata (my_arch
);
7757 parent
->next
= (lang_input_statement_type
*)
7759 - offsetof (lang_input_statement_type
, next
));
7764 #endif /* ENABLE_PLUGINS */
7766 /* Make sure that nobody has tried to add a symbol to this list
7768 ASSERT (link_info
.gc_sym_list
== NULL
);
7770 link_info
.gc_sym_list
= &entry_symbol
;
7772 if (entry_symbol
.name
== NULL
)
7774 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
7776 /* entry_symbol is normally initialied by a ENTRY definition in the
7777 linker script or the -e command line option. But if neither of
7778 these have been used, the target specific backend may still have
7779 provided an entry symbol via a call to lang_default_entry().
7780 Unfortunately this value will not be processed until lang_end()
7781 is called, long after this function has finished. So detect this
7782 case here and add the target's entry symbol to the list of starting
7783 points for garbage collection resolution. */
7784 lang_add_gc_name (entry_symbol_default
);
7787 lang_add_gc_name (link_info
.init_function
);
7788 lang_add_gc_name (link_info
.fini_function
);
7790 ldemul_after_open ();
7791 if (config
.map_file
!= NULL
)
7792 lang_print_asneeded ();
7796 bfd_section_already_linked_table_free ();
7798 /* Make sure that we're not mixing architectures. We call this
7799 after all the input files have been opened, but before we do any
7800 other processing, so that any operations merge_private_bfd_data
7801 does on the output file will be known during the rest of the
7805 /* Handle .exports instead of a version script if we're told to do so. */
7806 if (command_line
.version_exports_section
)
7807 lang_do_version_exports_section ();
7809 /* Build all sets based on the information gathered from the input
7811 ldctor_build_sets ();
7813 /* Give initial values for __start and __stop symbols, so that ELF
7814 gc_sections will keep sections referenced by these symbols. Must
7815 be done before lang_do_assignments below. */
7816 if (config
.build_constructors
)
7817 lang_init_start_stop ();
7819 /* PR 13683: We must rerun the assignments prior to running garbage
7820 collection in order to make sure that all symbol aliases are resolved. */
7821 lang_do_assignments (lang_mark_phase_enum
);
7822 expld
.phase
= lang_first_phase_enum
;
7824 /* Size up the common data. */
7827 /* Remove unreferenced sections if asked to. */
7828 lang_gc_sections ();
7830 /* Check relocations. */
7831 lang_check_relocs ();
7833 ldemul_after_check_relocs ();
7835 /* Update wild statements. */
7836 update_wild_statements (statement_list
.head
);
7838 /* Run through the contours of the script and attach input sections
7839 to the correct output sections. */
7840 lang_statement_iteration
++;
7841 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
7843 /* Start at the statement immediately after the special abs_section
7844 output statement, so that it isn't reordered. */
7845 process_insert_statements (&lang_os_list
.head
->header
.next
);
7847 ldemul_before_place_orphans ();
7849 /* Find any sections not attached explicitly and handle them. */
7850 lang_place_orphans ();
7852 if (!bfd_link_relocatable (&link_info
))
7856 /* Merge SEC_MERGE sections. This has to be done after GC of
7857 sections, so that GCed sections are not merged, but before
7858 assigning dynamic symbols, since removing whole input sections
7860 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
7862 /* Look for a text section and set the readonly attribute in it. */
7863 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
7867 if (config
.text_read_only
)
7868 found
->flags
|= SEC_READONLY
;
7870 found
->flags
&= ~SEC_READONLY
;
7874 /* Merge together CTF sections. After this, only the symtab-dependent
7875 function and data object sections need adjustment. */
7878 /* Emit the CTF, iff the emulation doesn't need to do late emission after
7879 examining things laid out late, like the strtab. */
7882 /* Copy forward lma regions for output sections in same lma region. */
7883 lang_propagate_lma_regions ();
7885 /* Defining __start/__stop symbols early for --gc-sections to work
7886 around a glibc build problem can result in these symbols being
7887 defined when they should not be. Fix them now. */
7888 if (config
.build_constructors
)
7889 lang_undef_start_stop ();
7891 /* Define .startof./.sizeof. symbols with preliminary values before
7892 dynamic symbols are created. */
7893 if (!bfd_link_relocatable (&link_info
))
7894 lang_init_startof_sizeof ();
7896 /* Do anything special before sizing sections. This is where ELF
7897 and other back-ends size dynamic sections. */
7898 ldemul_before_allocation ();
7900 /* We must record the program headers before we try to fix the
7901 section positions, since they will affect SIZEOF_HEADERS. */
7902 lang_record_phdrs ();
7904 /* Check relro sections. */
7905 if (link_info
.relro
&& !bfd_link_relocatable (&link_info
))
7906 lang_find_relro_sections ();
7908 /* Size up the sections. */
7909 lang_size_sections (NULL
, !RELAXATION_ENABLED
);
7911 /* See if anything special should be done now we know how big
7912 everything is. This is where relaxation is done. */
7913 ldemul_after_allocation ();
7915 /* Fix any __start, __stop, .startof. or .sizeof. symbols. */
7916 lang_finalize_start_stop ();
7918 /* Do all the assignments again, to report errors. Assignment
7919 statements are processed multiple times, updating symbols; In
7920 open_input_bfds, lang_do_assignments, and lang_size_sections.
7921 Since lang_relax_sections calls lang_do_assignments, symbols are
7922 also updated in ldemul_after_allocation. */
7923 lang_do_assignments (lang_final_phase_enum
);
7927 /* Convert absolute symbols to section relative. */
7928 ldexp_finalize_syms ();
7930 /* Make sure that the section addresses make sense. */
7931 if (command_line
.check_section_addresses
)
7932 lang_check_section_addresses ();
7934 /* Check any required symbols are known. */
7935 ldlang_check_require_defined_symbols ();
7940 /* EXPORTED TO YACC */
7943 lang_add_wild (struct wildcard_spec
*filespec
,
7944 struct wildcard_list
*section_list
,
7945 bfd_boolean keep_sections
)
7947 struct wildcard_list
*curr
, *next
;
7948 lang_wild_statement_type
*new_stmt
;
7950 /* Reverse the list as the parser puts it back to front. */
7951 for (curr
= section_list
, section_list
= NULL
;
7953 section_list
= curr
, curr
= next
)
7956 curr
->next
= section_list
;
7959 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
7961 if (strcmp (filespec
->name
, "*") == 0)
7962 filespec
->name
= NULL
;
7963 else if (!wildcardp (filespec
->name
))
7964 lang_has_input_file
= TRUE
;
7967 new_stmt
= new_stat (lang_wild_statement
, stat_ptr
);
7968 new_stmt
->filename
= NULL
;
7969 new_stmt
->filenames_sorted
= FALSE
;
7970 new_stmt
->section_flag_list
= NULL
;
7971 new_stmt
->exclude_name_list
= NULL
;
7972 if (filespec
!= NULL
)
7974 new_stmt
->filename
= filespec
->name
;
7975 new_stmt
->filenames_sorted
= filespec
->sorted
== by_name
;
7976 new_stmt
->section_flag_list
= filespec
->section_flag_list
;
7977 new_stmt
->exclude_name_list
= filespec
->exclude_name_list
;
7979 new_stmt
->section_list
= section_list
;
7980 new_stmt
->keep_sections
= keep_sections
;
7981 lang_list_init (&new_stmt
->children
);
7982 analyze_walk_wild_section_handler (new_stmt
);
7986 lang_section_start (const char *name
, etree_type
*address
,
7987 const segment_type
*segment
)
7989 lang_address_statement_type
*ad
;
7991 ad
= new_stat (lang_address_statement
, stat_ptr
);
7992 ad
->section_name
= name
;
7993 ad
->address
= address
;
7994 ad
->segment
= segment
;
7997 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
7998 because of a -e argument on the command line, or zero if this is
7999 called by ENTRY in a linker script. Command line arguments take
8003 lang_add_entry (const char *name
, bfd_boolean cmdline
)
8005 if (entry_symbol
.name
== NULL
8007 || !entry_from_cmdline
)
8009 entry_symbol
.name
= name
;
8010 entry_from_cmdline
= cmdline
;
8014 /* Set the default start symbol to NAME. .em files should use this,
8015 not lang_add_entry, to override the use of "start" if neither the
8016 linker script nor the command line specifies an entry point. NAME
8017 must be permanently allocated. */
8019 lang_default_entry (const char *name
)
8021 entry_symbol_default
= name
;
8025 lang_add_target (const char *name
)
8027 lang_target_statement_type
*new_stmt
;
8029 new_stmt
= new_stat (lang_target_statement
, stat_ptr
);
8030 new_stmt
->target
= name
;
8034 lang_add_map (const char *name
)
8041 map_option_f
= TRUE
;
8049 lang_add_fill (fill_type
*fill
)
8051 lang_fill_statement_type
*new_stmt
;
8053 new_stmt
= new_stat (lang_fill_statement
, stat_ptr
);
8054 new_stmt
->fill
= fill
;
8058 lang_add_data (int type
, union etree_union
*exp
)
8060 lang_data_statement_type
*new_stmt
;
8062 new_stmt
= new_stat (lang_data_statement
, stat_ptr
);
8063 new_stmt
->exp
= exp
;
8064 new_stmt
->type
= type
;
8067 /* Create a new reloc statement. RELOC is the BFD relocation type to
8068 generate. HOWTO is the corresponding howto structure (we could
8069 look this up, but the caller has already done so). SECTION is the
8070 section to generate a reloc against, or NAME is the name of the
8071 symbol to generate a reloc against. Exactly one of SECTION and
8072 NAME must be NULL. ADDEND is an expression for the addend. */
8075 lang_add_reloc (bfd_reloc_code_real_type reloc
,
8076 reloc_howto_type
*howto
,
8079 union etree_union
*addend
)
8081 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
8085 p
->section
= section
;
8087 p
->addend_exp
= addend
;
8089 p
->addend_value
= 0;
8090 p
->output_section
= NULL
;
8091 p
->output_offset
= 0;
8094 lang_assignment_statement_type
*
8095 lang_add_assignment (etree_type
*exp
)
8097 lang_assignment_statement_type
*new_stmt
;
8099 new_stmt
= new_stat (lang_assignment_statement
, stat_ptr
);
8100 new_stmt
->exp
= exp
;
8105 lang_add_attribute (enum statement_enum attribute
)
8107 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
8111 lang_startup (const char *name
)
8113 if (first_file
->filename
!= NULL
)
8115 einfo (_("%F%P: multiple STARTUP files\n"));
8117 first_file
->filename
= name
;
8118 first_file
->local_sym_name
= name
;
8119 first_file
->flags
.real
= TRUE
;
8123 lang_float (bfd_boolean maybe
)
8125 lang_float_flag
= maybe
;
8129 /* Work out the load- and run-time regions from a script statement, and
8130 store them in *LMA_REGION and *REGION respectively.
8132 MEMSPEC is the name of the run-time region, or the value of
8133 DEFAULT_MEMORY_REGION if the statement didn't specify one.
8134 LMA_MEMSPEC is the name of the load-time region, or null if the
8135 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
8136 had an explicit load address.
8138 It is an error to specify both a load region and a load address. */
8141 lang_get_regions (lang_memory_region_type
**region
,
8142 lang_memory_region_type
**lma_region
,
8143 const char *memspec
,
8144 const char *lma_memspec
,
8145 bfd_boolean have_lma
,
8146 bfd_boolean have_vma
)
8148 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
8150 /* If no runtime region or VMA has been specified, but the load region
8151 has been specified, then use the load region for the runtime region
8153 if (lma_memspec
!= NULL
8155 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
8156 *region
= *lma_region
;
8158 *region
= lang_memory_region_lookup (memspec
, FALSE
);
8160 if (have_lma
&& lma_memspec
!= 0)
8161 einfo (_("%X%P:%pS: section has both a load address and a load region\n"),
8166 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
8167 lang_output_section_phdr_list
*phdrs
,
8168 const char *lma_memspec
)
8170 lang_get_regions (¤t_section
->region
,
8171 ¤t_section
->lma_region
,
8172 memspec
, lma_memspec
,
8173 current_section
->load_base
!= NULL
,
8174 current_section
->addr_tree
!= NULL
);
8176 current_section
->fill
= fill
;
8177 current_section
->phdrs
= phdrs
;
8181 /* Set the output format type. -oformat overrides scripts. */
8184 lang_add_output_format (const char *format
,
8189 if (output_target
== NULL
|| !from_script
)
8191 if (command_line
.endian
== ENDIAN_BIG
8194 else if (command_line
.endian
== ENDIAN_LITTLE
8198 output_target
= format
;
8203 lang_add_insert (const char *where
, int is_before
)
8205 lang_insert_statement_type
*new_stmt
;
8207 new_stmt
= new_stat (lang_insert_statement
, stat_ptr
);
8208 new_stmt
->where
= where
;
8209 new_stmt
->is_before
= is_before
;
8210 saved_script_handle
= previous_script_handle
;
8213 /* Enter a group. This creates a new lang_group_statement, and sets
8214 stat_ptr to build new statements within the group. */
8217 lang_enter_group (void)
8219 lang_group_statement_type
*g
;
8221 g
= new_stat (lang_group_statement
, stat_ptr
);
8222 lang_list_init (&g
->children
);
8223 push_stat_ptr (&g
->children
);
8226 /* Leave a group. This just resets stat_ptr to start writing to the
8227 regular list of statements again. Note that this will not work if
8228 groups can occur inside anything else which can adjust stat_ptr,
8229 but currently they can't. */
8232 lang_leave_group (void)
8237 /* Add a new program header. This is called for each entry in a PHDRS
8238 command in a linker script. */
8241 lang_new_phdr (const char *name
,
8243 bfd_boolean filehdr
,
8248 struct lang_phdr
*n
, **pp
;
8251 n
= stat_alloc (sizeof (struct lang_phdr
));
8254 n
->type
= exp_get_vma (type
, 0, "program header type");
8255 n
->filehdr
= filehdr
;
8260 hdrs
= n
->type
== 1 && (phdrs
|| filehdr
);
8262 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
8265 && !((*pp
)->filehdr
|| (*pp
)->phdrs
))
8267 einfo (_("%X%P:%pS: PHDRS and FILEHDR are not supported"
8268 " when prior PT_LOAD headers lack them\n"), NULL
);
8275 /* Record the program header information in the output BFD. FIXME: We
8276 should not be calling an ELF specific function here. */
8279 lang_record_phdrs (void)
8283 lang_output_section_phdr_list
*last
;
8284 struct lang_phdr
*l
;
8285 lang_output_section_statement_type
*os
;
8288 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
8291 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
8298 for (os
= (void *) lang_os_list
.head
;
8302 lang_output_section_phdr_list
*pl
;
8304 if (os
->constraint
< 0)
8312 if (os
->sectype
== noload_section
8313 || os
->bfd_section
== NULL
8314 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
8317 /* Don't add orphans to PT_INTERP header. */
8323 lang_output_section_statement_type
*tmp_os
;
8325 /* If we have not run across a section with a program
8326 header assigned to it yet, then scan forwards to find
8327 one. This prevents inconsistencies in the linker's
8328 behaviour when a script has specified just a single
8329 header and there are sections in that script which are
8330 not assigned to it, and which occur before the first
8331 use of that header. See here for more details:
8332 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
8333 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
8336 last
= tmp_os
->phdrs
;
8340 einfo (_("%F%P: no sections assigned to phdrs\n"));
8345 if (os
->bfd_section
== NULL
)
8348 for (; pl
!= NULL
; pl
= pl
->next
)
8350 if (strcmp (pl
->name
, l
->name
) == 0)
8355 secs
= (asection
**) xrealloc (secs
,
8356 alc
* sizeof (asection
*));
8358 secs
[c
] = os
->bfd_section
;
8365 if (l
->flags
== NULL
)
8368 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
8373 at
= exp_get_vma (l
->at
, 0, "phdr load address");
8375 if (!bfd_record_phdr (link_info
.output_bfd
, l
->type
,
8376 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
8377 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
8378 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
8383 /* Make sure all the phdr assignments succeeded. */
8384 for (os
= (void *) lang_os_list
.head
;
8388 lang_output_section_phdr_list
*pl
;
8390 if (os
->constraint
< 0
8391 || os
->bfd_section
== NULL
)
8394 for (pl
= os
->phdrs
;
8397 if (!pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
8398 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
8399 os
->name
, pl
->name
);
8403 /* Record a list of sections which may not be cross referenced. */
8406 lang_add_nocrossref (lang_nocrossref_type
*l
)
8408 struct lang_nocrossrefs
*n
;
8410 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
8411 n
->next
= nocrossref_list
;
8413 n
->onlyfirst
= FALSE
;
8414 nocrossref_list
= n
;
8416 /* Set notice_all so that we get informed about all symbols. */
8417 link_info
.notice_all
= TRUE
;
8420 /* Record a section that cannot be referenced from a list of sections. */
8423 lang_add_nocrossref_to (lang_nocrossref_type
*l
)
8425 lang_add_nocrossref (l
);
8426 nocrossref_list
->onlyfirst
= TRUE
;
8429 /* Overlay handling. We handle overlays with some static variables. */
8431 /* The overlay virtual address. */
8432 static etree_type
*overlay_vma
;
8433 /* And subsection alignment. */
8434 static etree_type
*overlay_subalign
;
8436 /* An expression for the maximum section size seen so far. */
8437 static etree_type
*overlay_max
;
8439 /* A list of all the sections in this overlay. */
8441 struct overlay_list
{
8442 struct overlay_list
*next
;
8443 lang_output_section_statement_type
*os
;
8446 static struct overlay_list
*overlay_list
;
8448 /* Start handling an overlay. */
8451 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
8453 /* The grammar should prevent nested overlays from occurring. */
8454 ASSERT (overlay_vma
== NULL
8455 && overlay_subalign
== NULL
8456 && overlay_max
== NULL
);
8458 overlay_vma
= vma_expr
;
8459 overlay_subalign
= subalign
;
8462 /* Start a section in an overlay. We handle this by calling
8463 lang_enter_output_section_statement with the correct VMA.
8464 lang_leave_overlay sets up the LMA and memory regions. */
8467 lang_enter_overlay_section (const char *name
)
8469 struct overlay_list
*n
;
8472 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
8473 0, overlay_subalign
, 0, 0, 0);
8475 /* If this is the first section, then base the VMA of future
8476 sections on this one. This will work correctly even if `.' is
8477 used in the addresses. */
8478 if (overlay_list
== NULL
)
8479 overlay_vma
= exp_nameop (ADDR
, name
);
8481 /* Remember the section. */
8482 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
8483 n
->os
= current_section
;
8484 n
->next
= overlay_list
;
8487 size
= exp_nameop (SIZEOF
, name
);
8489 /* Arrange to work out the maximum section end address. */
8490 if (overlay_max
== NULL
)
8493 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
8496 /* Finish a section in an overlay. There isn't any special to do
8500 lang_leave_overlay_section (fill_type
*fill
,
8501 lang_output_section_phdr_list
*phdrs
)
8508 name
= current_section
->name
;
8510 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
8511 region and that no load-time region has been specified. It doesn't
8512 really matter what we say here, since lang_leave_overlay will
8514 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
8516 /* Define the magic symbols. */
8518 clean
= (char *) xmalloc (strlen (name
) + 1);
8520 for (s1
= name
; *s1
!= '\0'; s1
++)
8521 if (ISALNUM (*s1
) || *s1
== '_')
8525 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_start_");
8526 sprintf (buf
, "__load_start_%s", clean
);
8527 lang_add_assignment (exp_provide (buf
,
8528 exp_nameop (LOADADDR
, name
),
8531 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_stop_");
8532 sprintf (buf
, "__load_stop_%s", clean
);
8533 lang_add_assignment (exp_provide (buf
,
8535 exp_nameop (LOADADDR
, name
),
8536 exp_nameop (SIZEOF
, name
)),
8542 /* Finish an overlay. If there are any overlay wide settings, this
8543 looks through all the sections in the overlay and sets them. */
8546 lang_leave_overlay (etree_type
*lma_expr
,
8549 const char *memspec
,
8550 lang_output_section_phdr_list
*phdrs
,
8551 const char *lma_memspec
)
8553 lang_memory_region_type
*region
;
8554 lang_memory_region_type
*lma_region
;
8555 struct overlay_list
*l
;
8556 lang_nocrossref_type
*nocrossref
;
8558 lang_get_regions (®ion
, &lma_region
,
8559 memspec
, lma_memspec
,
8560 lma_expr
!= NULL
, FALSE
);
8564 /* After setting the size of the last section, set '.' to end of the
8566 if (overlay_list
!= NULL
)
8568 overlay_list
->os
->update_dot
= 1;
8569 overlay_list
->os
->update_dot_tree
8570 = exp_assign (".", exp_binop ('+', overlay_vma
, overlay_max
), FALSE
);
8576 struct overlay_list
*next
;
8578 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
8581 l
->os
->region
= region
;
8582 l
->os
->lma_region
= lma_region
;
8584 /* The first section has the load address specified in the
8585 OVERLAY statement. The rest are worked out from that.
8586 The base address is not needed (and should be null) if
8587 an LMA region was specified. */
8590 l
->os
->load_base
= lma_expr
;
8591 l
->os
->sectype
= first_overlay_section
;
8593 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
8594 l
->os
->phdrs
= phdrs
;
8598 lang_nocrossref_type
*nc
;
8600 nc
= (lang_nocrossref_type
*) xmalloc (sizeof *nc
);
8601 nc
->name
= l
->os
->name
;
8602 nc
->next
= nocrossref
;
8611 if (nocrossref
!= NULL
)
8612 lang_add_nocrossref (nocrossref
);
8615 overlay_list
= NULL
;
8617 overlay_subalign
= NULL
;
8620 /* Version handling. This is only useful for ELF. */
8622 /* If PREV is NULL, return first version pattern matching particular symbol.
8623 If PREV is non-NULL, return first version pattern matching particular
8624 symbol after PREV (previously returned by lang_vers_match). */
8626 static struct bfd_elf_version_expr
*
8627 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
8628 struct bfd_elf_version_expr
*prev
,
8632 const char *cxx_sym
= sym
;
8633 const char *java_sym
= sym
;
8634 struct bfd_elf_version_expr
*expr
= NULL
;
8635 enum demangling_styles curr_style
;
8637 curr_style
= CURRENT_DEMANGLING_STYLE
;
8638 cplus_demangle_set_style (no_demangling
);
8639 c_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_NO_OPTS
);
8642 cplus_demangle_set_style (curr_style
);
8644 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8646 cxx_sym
= bfd_demangle (link_info
.output_bfd
, sym
,
8647 DMGL_PARAMS
| DMGL_ANSI
);
8651 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8653 java_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_JAVA
);
8658 if (head
->htab
&& (prev
== NULL
|| prev
->literal
))
8660 struct bfd_elf_version_expr e
;
8662 switch (prev
? prev
->mask
: 0)
8665 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
8668 expr
= (struct bfd_elf_version_expr
*)
8669 htab_find ((htab_t
) head
->htab
, &e
);
8670 while (expr
&& strcmp (expr
->pattern
, c_sym
) == 0)
8671 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
8677 case BFD_ELF_VERSION_C_TYPE
:
8678 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8680 e
.pattern
= cxx_sym
;
8681 expr
= (struct bfd_elf_version_expr
*)
8682 htab_find ((htab_t
) head
->htab
, &e
);
8683 while (expr
&& strcmp (expr
->pattern
, cxx_sym
) == 0)
8684 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
8690 case BFD_ELF_VERSION_CXX_TYPE
:
8691 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8693 e
.pattern
= java_sym
;
8694 expr
= (struct bfd_elf_version_expr
*)
8695 htab_find ((htab_t
) head
->htab
, &e
);
8696 while (expr
&& strcmp (expr
->pattern
, java_sym
) == 0)
8697 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8708 /* Finally, try the wildcards. */
8709 if (prev
== NULL
|| prev
->literal
)
8710 expr
= head
->remaining
;
8713 for (; expr
; expr
= expr
->next
)
8720 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
8723 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8725 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
8729 if (fnmatch (expr
->pattern
, s
, 0) == 0)
8735 free ((char *) c_sym
);
8737 free ((char *) cxx_sym
);
8738 if (java_sym
!= sym
)
8739 free ((char *) java_sym
);
8743 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
8744 return a pointer to the symbol name with any backslash quotes removed. */
8747 realsymbol (const char *pattern
)
8750 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
8751 char *s
, *symbol
= (char *) xmalloc (strlen (pattern
) + 1);
8753 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
8755 /* It is a glob pattern only if there is no preceding
8759 /* Remove the preceding backslash. */
8766 if (*p
== '?' || *p
== '*' || *p
== '[')
8773 backslash
= *p
== '\\';
8789 /* This is called for each variable name or match expression. NEW_NAME is
8790 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
8791 pattern to be matched against symbol names. */
8793 struct bfd_elf_version_expr
*
8794 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
8795 const char *new_name
,
8797 bfd_boolean literal_p
)
8799 struct bfd_elf_version_expr
*ret
;
8801 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
8805 ret
->literal
= TRUE
;
8806 ret
->pattern
= literal_p
? new_name
: realsymbol (new_name
);
8807 if (ret
->pattern
== NULL
)
8809 ret
->pattern
= new_name
;
8810 ret
->literal
= FALSE
;
8813 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
8814 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
8815 else if (strcasecmp (lang
, "C++") == 0)
8816 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
8817 else if (strcasecmp (lang
, "Java") == 0)
8818 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
8821 einfo (_("%X%P: unknown language `%s' in version information\n"),
8823 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
8826 return ldemul_new_vers_pattern (ret
);
8829 /* This is called for each set of variable names and match
8832 struct bfd_elf_version_tree
*
8833 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
8834 struct bfd_elf_version_expr
*locals
)
8836 struct bfd_elf_version_tree
*ret
;
8838 ret
= (struct bfd_elf_version_tree
*) xcalloc (1, sizeof *ret
);
8839 ret
->globals
.list
= globals
;
8840 ret
->locals
.list
= locals
;
8841 ret
->match
= lang_vers_match
;
8842 ret
->name_indx
= (unsigned int) -1;
8846 /* This static variable keeps track of version indices. */
8848 static int version_index
;
8851 version_expr_head_hash (const void *p
)
8853 const struct bfd_elf_version_expr
*e
=
8854 (const struct bfd_elf_version_expr
*) p
;
8856 return htab_hash_string (e
->pattern
);
8860 version_expr_head_eq (const void *p1
, const void *p2
)
8862 const struct bfd_elf_version_expr
*e1
=
8863 (const struct bfd_elf_version_expr
*) p1
;
8864 const struct bfd_elf_version_expr
*e2
=
8865 (const struct bfd_elf_version_expr
*) p2
;
8867 return strcmp (e1
->pattern
, e2
->pattern
) == 0;
8871 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
8874 struct bfd_elf_version_expr
*e
, *next
;
8875 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
8877 for (e
= head
->list
; e
; e
= e
->next
)
8881 head
->mask
|= e
->mask
;
8886 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
8887 version_expr_head_eq
, NULL
);
8888 list_loc
= &head
->list
;
8889 remaining_loc
= &head
->remaining
;
8890 for (e
= head
->list
; e
; e
= next
)
8896 remaining_loc
= &e
->next
;
8900 void **loc
= htab_find_slot ((htab_t
) head
->htab
, e
, INSERT
);
8904 struct bfd_elf_version_expr
*e1
, *last
;
8906 e1
= (struct bfd_elf_version_expr
*) *loc
;
8910 if (e1
->mask
== e
->mask
)
8918 while (e1
&& strcmp (e1
->pattern
, e
->pattern
) == 0);
8922 /* This is a duplicate. */
8923 /* FIXME: Memory leak. Sometimes pattern is not
8924 xmalloced alone, but in larger chunk of memory. */
8925 /* free (e->pattern); */
8930 e
->next
= last
->next
;
8938 list_loc
= &e
->next
;
8942 *remaining_loc
= NULL
;
8943 *list_loc
= head
->remaining
;
8946 head
->remaining
= head
->list
;
8949 /* This is called when we know the name and dependencies of the
8953 lang_register_vers_node (const char *name
,
8954 struct bfd_elf_version_tree
*version
,
8955 struct bfd_elf_version_deps
*deps
)
8957 struct bfd_elf_version_tree
*t
, **pp
;
8958 struct bfd_elf_version_expr
*e1
;
8963 if (link_info
.version_info
!= NULL
8964 && (name
[0] == '\0' || link_info
.version_info
->name
[0] == '\0'))
8966 einfo (_("%X%P: anonymous version tag cannot be combined"
8967 " with other version tags\n"));
8972 /* Make sure this node has a unique name. */
8973 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8974 if (strcmp (t
->name
, name
) == 0)
8975 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
8977 lang_finalize_version_expr_head (&version
->globals
);
8978 lang_finalize_version_expr_head (&version
->locals
);
8980 /* Check the global and local match names, and make sure there
8981 aren't any duplicates. */
8983 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
8985 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8987 struct bfd_elf_version_expr
*e2
;
8989 if (t
->locals
.htab
&& e1
->literal
)
8991 e2
= (struct bfd_elf_version_expr
*)
8992 htab_find ((htab_t
) t
->locals
.htab
, e1
);
8993 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
8995 if (e1
->mask
== e2
->mask
)
8996 einfo (_("%X%P: duplicate expression `%s'"
8997 " in version information\n"), e1
->pattern
);
9001 else if (!e1
->literal
)
9002 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
9003 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
9004 && e1
->mask
== e2
->mask
)
9005 einfo (_("%X%P: duplicate expression `%s'"
9006 " in version information\n"), e1
->pattern
);
9010 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
9012 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9014 struct bfd_elf_version_expr
*e2
;
9016 if (t
->globals
.htab
&& e1
->literal
)
9018 e2
= (struct bfd_elf_version_expr
*)
9019 htab_find ((htab_t
) t
->globals
.htab
, e1
);
9020 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
9022 if (e1
->mask
== e2
->mask
)
9023 einfo (_("%X%P: duplicate expression `%s'"
9024 " in version information\n"),
9029 else if (!e1
->literal
)
9030 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
9031 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
9032 && e1
->mask
== e2
->mask
)
9033 einfo (_("%X%P: duplicate expression `%s'"
9034 " in version information\n"), e1
->pattern
);
9038 version
->deps
= deps
;
9039 version
->name
= name
;
9040 if (name
[0] != '\0')
9043 version
->vernum
= version_index
;
9046 version
->vernum
= 0;
9048 for (pp
= &link_info
.version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
9053 /* This is called when we see a version dependency. */
9055 struct bfd_elf_version_deps
*
9056 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
9058 struct bfd_elf_version_deps
*ret
;
9059 struct bfd_elf_version_tree
*t
;
9061 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
9064 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9066 if (strcmp (t
->name
, name
) == 0)
9068 ret
->version_needed
= t
;
9073 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
9075 ret
->version_needed
= NULL
;
9080 lang_do_version_exports_section (void)
9082 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
9084 LANG_FOR_EACH_INPUT_STATEMENT (is
)
9086 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
9094 contents
= (char *) xmalloc (len
);
9095 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
9096 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
9099 while (p
< contents
+ len
)
9101 greg
= lang_new_vers_pattern (greg
, p
, NULL
, FALSE
);
9102 p
= strchr (p
, '\0') + 1;
9105 /* Do not free the contents, as we used them creating the regex. */
9107 /* Do not include this section in the link. */
9108 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
9111 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, FALSE
);
9112 lang_register_vers_node (command_line
.version_exports_section
,
9113 lang_new_vers_node (greg
, lreg
), NULL
);
9116 /* Evaluate LENGTH and ORIGIN parts of MEMORY spec */
9119 lang_do_memory_regions (void)
9121 lang_memory_region_type
*r
= lang_memory_region_list
;
9123 for (; r
!= NULL
; r
= r
->next
)
9127 exp_fold_tree_no_dot (r
->origin_exp
);
9128 if (expld
.result
.valid_p
)
9130 r
->origin
= expld
.result
.value
;
9131 r
->current
= r
->origin
;
9134 einfo (_("%F%P: invalid origin for memory region %s\n"),
9139 exp_fold_tree_no_dot (r
->length_exp
);
9140 if (expld
.result
.valid_p
)
9141 r
->length
= expld
.result
.value
;
9143 einfo (_("%F%P: invalid length for memory region %s\n"),
9150 lang_add_unique (const char *name
)
9152 struct unique_sections
*ent
;
9154 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
9155 if (strcmp (ent
->name
, name
) == 0)
9158 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
9159 ent
->name
= xstrdup (name
);
9160 ent
->next
= unique_section_list
;
9161 unique_section_list
= ent
;
9164 /* Append the list of dynamic symbols to the existing one. */
9167 lang_append_dynamic_list (struct bfd_elf_version_expr
*dynamic
)
9169 if (link_info
.dynamic_list
)
9171 struct bfd_elf_version_expr
*tail
;
9172 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
9174 tail
->next
= link_info
.dynamic_list
->head
.list
;
9175 link_info
.dynamic_list
->head
.list
= dynamic
;
9179 struct bfd_elf_dynamic_list
*d
;
9181 d
= (struct bfd_elf_dynamic_list
*) xcalloc (1, sizeof *d
);
9182 d
->head
.list
= dynamic
;
9183 d
->match
= lang_vers_match
;
9184 link_info
.dynamic_list
= d
;
9188 /* Append the list of C++ typeinfo dynamic symbols to the existing
9192 lang_append_dynamic_list_cpp_typeinfo (void)
9194 const char *symbols
[] =
9196 "typeinfo name for*",
9199 struct bfd_elf_version_expr
*dynamic
= NULL
;
9202 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9203 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9206 lang_append_dynamic_list (dynamic
);
9209 /* Append the list of C++ operator new and delete dynamic symbols to the
9213 lang_append_dynamic_list_cpp_new (void)
9215 const char *symbols
[] =
9220 struct bfd_elf_version_expr
*dynamic
= NULL
;
9223 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9224 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9227 lang_append_dynamic_list (dynamic
);
9230 /* Scan a space and/or comma separated string of features. */
9233 lang_ld_feature (char *str
)
9241 while (*p
== ',' || ISSPACE (*p
))
9246 while (*q
&& *q
!= ',' && !ISSPACE (*q
))
9250 if (strcasecmp (p
, "SANE_EXPR") == 0)
9251 config
.sane_expr
= TRUE
;
9253 einfo (_("%X%P: unknown feature `%s'\n"), p
);
9259 /* Pretty print memory amount. */
9262 lang_print_memory_size (bfd_vma sz
)
9264 if ((sz
& 0x3fffffff) == 0)
9265 printf ("%10" BFD_VMA_FMT
"u GB", sz
>> 30);
9266 else if ((sz
& 0xfffff) == 0)
9267 printf ("%10" BFD_VMA_FMT
"u MB", sz
>> 20);
9268 else if ((sz
& 0x3ff) == 0)
9269 printf ("%10" BFD_VMA_FMT
"u KB", sz
>> 10);
9271 printf (" %10" BFD_VMA_FMT
"u B", sz
);
9274 /* Implement --print-memory-usage: disply per region memory usage. */
9277 lang_print_memory_usage (void)
9279 lang_memory_region_type
*r
;
9281 printf ("Memory region Used Size Region Size %%age Used\n");
9282 for (r
= lang_memory_region_list
; r
->next
!= NULL
; r
= r
->next
)
9284 bfd_vma used_length
= r
->current
- r
->origin
;
9286 printf ("%16s: ",r
->name_list
.name
);
9287 lang_print_memory_size (used_length
);
9288 lang_print_memory_size ((bfd_vma
) r
->length
);
9292 double percent
= used_length
* 100.0 / r
->length
;
9293 printf (" %6.2f%%", percent
);