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)
5601 /* Only report adjustments that would change
5602 alignment from what we have already reported. */
5603 diff
= newdot
- os
->bfd_section
->vma
;
5604 if (!(diff
& (((bfd_vma
) 1 << section_alignment
) - 1)))
5608 && (config
.warn_section_align
5609 || os
->addr_tree
!= NULL
))
5610 einfo (_("%P: warning: "
5611 "start of section %s changed by %ld\n"),
5612 os
->name
, (long) diff
);
5615 bfd_set_section_vma (os
->bfd_section
, newdot
);
5617 os
->bfd_section
->output_offset
= 0;
5620 lang_size_sections_1 (&os
->children
.head
, os
,
5621 os
->fill
, newdot
, relax
, check_regions
);
5623 os
->processed_vma
= TRUE
;
5625 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5626 /* Except for some special linker created sections,
5627 no output section should change from zero size
5628 after strip_excluded_output_sections. A non-zero
5629 size on an ignored section indicates that some
5630 input section was not sized early enough. */
5631 ASSERT (os
->bfd_section
->size
== 0);
5634 dot
= os
->bfd_section
->vma
;
5636 /* Put the section within the requested block size, or
5637 align at the block boundary. */
5639 + TO_ADDR (os
->bfd_section
->size
)
5640 + os
->block_value
- 1)
5641 & - (bfd_vma
) os
->block_value
);
5643 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5644 os
->bfd_section
->size
= TO_SIZE (after
5645 - os
->bfd_section
->vma
);
5648 /* Set section lma. */
5651 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
5655 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
5656 os
->bfd_section
->lma
= lma
;
5658 else if (os
->lma_region
!= NULL
)
5660 bfd_vma lma
= os
->lma_region
->current
;
5662 if (os
->align_lma_with_input
)
5666 /* When LMA_REGION is the same as REGION, align the LMA
5667 as we did for the VMA, possibly including alignment
5668 from the bfd section. If a different region, then
5669 only align according to the value in the output
5671 if (os
->lma_region
!= os
->region
)
5672 section_alignment
= exp_get_power (os
->section_alignment
,
5673 "section alignment");
5674 if (section_alignment
> 0)
5675 lma
= align_power (lma
, section_alignment
);
5677 os
->bfd_section
->lma
= lma
;
5679 else if (r
->last_os
!= NULL
5680 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5685 last
= r
->last_os
->output_section_statement
.bfd_section
;
5687 /* A backwards move of dot should be accompanied by
5688 an explicit assignment to the section LMA (ie.
5689 os->load_base set) because backwards moves can
5690 create overlapping LMAs. */
5692 && os
->bfd_section
->size
!= 0
5693 && dot
+ TO_ADDR (os
->bfd_section
->size
) <= last
->vma
)
5695 /* If dot moved backwards then leave lma equal to
5696 vma. This is the old default lma, which might
5697 just happen to work when the backwards move is
5698 sufficiently large. Nag if this changes anything,
5699 so people can fix their linker scripts. */
5701 if (last
->vma
!= last
->lma
)
5702 einfo (_("%P: warning: dot moved backwards "
5703 "before `%s'\n"), os
->name
);
5707 /* If this is an overlay, set the current lma to that
5708 at the end of the previous section. */
5709 if (os
->sectype
== overlay_section
)
5710 lma
= last
->lma
+ TO_ADDR (last
->size
);
5712 /* Otherwise, keep the same lma to vma relationship
5713 as the previous section. */
5715 lma
= os
->bfd_section
->vma
+ last
->lma
- last
->vma
;
5717 if (section_alignment
> 0)
5718 lma
= align_power (lma
, section_alignment
);
5719 os
->bfd_section
->lma
= lma
;
5722 os
->processed_lma
= TRUE
;
5724 /* Keep track of normal sections using the default
5725 lma region. We use this to set the lma for
5726 following sections. Overlays or other linker
5727 script assignment to lma might mean that the
5728 default lma == vma is incorrect.
5729 To avoid warnings about dot moving backwards when using
5730 -Ttext, don't start tracking sections until we find one
5731 of non-zero size or with lma set differently to vma.
5732 Do this tracking before we short-cut the loop so that we
5733 track changes for the case where the section size is zero,
5734 but the lma is set differently to the vma. This is
5735 important, if an orphan section is placed after an
5736 otherwise empty output section that has an explicit lma
5737 set, we want that lma reflected in the orphans lma. */
5738 if (((!IGNORE_SECTION (os
->bfd_section
)
5739 && (os
->bfd_section
->size
!= 0
5740 || (r
->last_os
== NULL
5741 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
5742 || (r
->last_os
!= NULL
5743 && dot
>= (r
->last_os
->output_section_statement
5744 .bfd_section
->vma
))))
5745 || os
->sectype
== first_overlay_section
)
5746 && os
->lma_region
== NULL
5747 && !bfd_link_relocatable (&link_info
))
5750 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5753 /* .tbss sections effectively have zero size. */
5754 if (!IS_TBSS (os
->bfd_section
)
5755 || bfd_link_relocatable (&link_info
))
5756 dotdelta
= TO_ADDR (os
->bfd_section
->size
);
5761 if (os
->update_dot_tree
!= 0)
5762 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5764 /* Update dot in the region ?
5765 We only do this if the section is going to be allocated,
5766 since unallocated sections do not contribute to the region's
5767 overall size in memory. */
5768 if (os
->region
!= NULL
5769 && (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)))
5771 os
->region
->current
= dot
;
5774 /* Make sure the new address is within the region. */
5775 os_region_check (os
, os
->region
, os
->addr_tree
,
5776 os
->bfd_section
->vma
);
5778 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
5779 && ((os
->bfd_section
->flags
& SEC_LOAD
)
5780 || os
->align_lma_with_input
))
5782 os
->lma_region
->current
= os
->bfd_section
->lma
+ dotdelta
;
5785 os_region_check (os
, os
->lma_region
, NULL
,
5786 os
->bfd_section
->lma
);
5792 case lang_constructors_statement_enum
:
5793 dot
= lang_size_sections_1 (&constructor_list
.head
,
5794 output_section_statement
,
5795 fill
, dot
, relax
, check_regions
);
5798 case lang_data_statement_enum
:
5800 unsigned int size
= 0;
5802 s
->data_statement
.output_offset
=
5803 dot
- output_section_statement
->bfd_section
->vma
;
5804 s
->data_statement
.output_section
=
5805 output_section_statement
->bfd_section
;
5807 /* We might refer to provided symbols in the expression, and
5808 need to mark them as needed. */
5809 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5811 switch (s
->data_statement
.type
)
5829 if (size
< TO_SIZE ((unsigned) 1))
5830 size
= TO_SIZE ((unsigned) 1);
5831 dot
+= TO_ADDR (size
);
5832 if (!(output_section_statement
->bfd_section
->flags
5834 output_section_statement
->bfd_section
->size
5835 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5840 case lang_reloc_statement_enum
:
5844 s
->reloc_statement
.output_offset
=
5845 dot
- output_section_statement
->bfd_section
->vma
;
5846 s
->reloc_statement
.output_section
=
5847 output_section_statement
->bfd_section
;
5848 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
5849 dot
+= TO_ADDR (size
);
5850 if (!(output_section_statement
->bfd_section
->flags
5852 output_section_statement
->bfd_section
->size
5853 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5857 case lang_wild_statement_enum
:
5858 dot
= lang_size_sections_1 (&s
->wild_statement
.children
.head
,
5859 output_section_statement
,
5860 fill
, dot
, relax
, check_regions
);
5863 case lang_object_symbols_statement_enum
:
5864 link_info
.create_object_symbols_section
5865 = output_section_statement
->bfd_section
;
5866 output_section_statement
->bfd_section
->flags
|= SEC_KEEP
;
5869 case lang_output_statement_enum
:
5870 case lang_target_statement_enum
:
5873 case lang_input_section_enum
:
5877 i
= s
->input_section
.section
;
5882 if (!bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
5883 einfo (_("%F%P: can't relax section: %E\n"));
5887 dot
= size_input_section (prev
, output_section_statement
,
5892 case lang_input_statement_enum
:
5895 case lang_fill_statement_enum
:
5896 s
->fill_statement
.output_section
=
5897 output_section_statement
->bfd_section
;
5899 fill
= s
->fill_statement
.fill
;
5902 case lang_assignment_statement_enum
:
5904 bfd_vma newdot
= dot
;
5905 etree_type
*tree
= s
->assignment_statement
.exp
;
5907 expld
.dataseg
.relro
= exp_seg_relro_none
;
5909 exp_fold_tree (tree
,
5910 output_section_statement
->bfd_section
,
5913 ldlang_check_relro_region (s
, &expld
.dataseg
);
5915 expld
.dataseg
.relro
= exp_seg_relro_none
;
5917 /* This symbol may be relative to this section. */
5918 if ((tree
->type
.node_class
== etree_provided
5919 || tree
->type
.node_class
== etree_assign
)
5920 && (tree
->assign
.dst
[0] != '.'
5921 || tree
->assign
.dst
[1] != '\0'))
5922 output_section_statement
->update_dot
= 1;
5924 if (!output_section_statement
->ignored
)
5926 if (output_section_statement
== abs_output_section
)
5928 /* If we don't have an output section, then just adjust
5929 the default memory address. */
5930 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
5931 FALSE
)->current
= newdot
;
5933 else if (newdot
!= dot
)
5935 /* Insert a pad after this statement. We can't
5936 put the pad before when relaxing, in case the
5937 assignment references dot. */
5938 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
5939 output_section_statement
->bfd_section
, dot
);
5941 /* Don't neuter the pad below when relaxing. */
5944 /* If dot is advanced, this implies that the section
5945 should have space allocated to it, unless the
5946 user has explicitly stated that the section
5947 should not be allocated. */
5948 if (output_section_statement
->sectype
!= noalloc_section
5949 && (output_section_statement
->sectype
!= noload_section
5950 || (bfd_get_flavour (link_info
.output_bfd
)
5951 == bfd_target_elf_flavour
)))
5952 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
5959 case lang_padding_statement_enum
:
5960 /* If this is the first time lang_size_sections is called,
5961 we won't have any padding statements. If this is the
5962 second or later passes when relaxing, we should allow
5963 padding to shrink. If padding is needed on this pass, it
5964 will be added back in. */
5965 s
->padding_statement
.size
= 0;
5967 /* Make sure output_offset is valid. If relaxation shrinks
5968 the section and this pad isn't needed, it's possible to
5969 have output_offset larger than the final size of the
5970 section. bfd_set_section_contents will complain even for
5971 a pad size of zero. */
5972 s
->padding_statement
.output_offset
5973 = dot
- output_section_statement
->bfd_section
->vma
;
5976 case lang_group_statement_enum
:
5977 dot
= lang_size_sections_1 (&s
->group_statement
.children
.head
,
5978 output_section_statement
,
5979 fill
, dot
, relax
, check_regions
);
5982 case lang_insert_statement_enum
:
5985 /* We can only get here when relaxing is turned on. */
5986 case lang_address_statement_enum
:
5993 prev
= &s
->header
.next
;
5998 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
5999 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
6000 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
6001 segments. We are allowed an opportunity to override this decision. */
6004 ldlang_override_segment_assignment (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6005 bfd
*abfd ATTRIBUTE_UNUSED
,
6006 asection
*current_section
,
6007 asection
*previous_section
,
6008 bfd_boolean new_segment
)
6010 lang_output_section_statement_type
*cur
;
6011 lang_output_section_statement_type
*prev
;
6013 /* The checks below are only necessary when the BFD library has decided
6014 that the two sections ought to be placed into the same segment. */
6018 /* Paranoia checks. */
6019 if (current_section
== NULL
|| previous_section
== NULL
)
6022 /* If this flag is set, the target never wants code and non-code
6023 sections comingled in the same segment. */
6024 if (config
.separate_code
6025 && ((current_section
->flags
^ previous_section
->flags
) & SEC_CODE
))
6028 /* Find the memory regions associated with the two sections.
6029 We call lang_output_section_find() here rather than scanning the list
6030 of output sections looking for a matching section pointer because if
6031 we have a large number of sections then a hash lookup is faster. */
6032 cur
= lang_output_section_find (current_section
->name
);
6033 prev
= lang_output_section_find (previous_section
->name
);
6035 /* More paranoia. */
6036 if (cur
== NULL
|| prev
== NULL
)
6039 /* If the regions are different then force the sections to live in
6040 different segments. See the email thread starting at the following
6041 URL for the reasons why this is necessary:
6042 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
6043 return cur
->region
!= prev
->region
;
6047 one_lang_size_sections_pass (bfd_boolean
*relax
, bfd_boolean check_regions
)
6049 lang_statement_iteration
++;
6050 if (expld
.phase
!= lang_mark_phase_enum
)
6051 lang_sizing_iteration
++;
6052 lang_size_sections_1 (&statement_list
.head
, abs_output_section
,
6053 0, 0, relax
, check_regions
);
6057 lang_size_segment (seg_align_type
*seg
)
6059 /* If XXX_SEGMENT_ALIGN XXX_SEGMENT_END pair was seen, check whether
6060 a page could be saved in the data segment. */
6061 bfd_vma first
, last
;
6063 first
= -seg
->base
& (seg
->pagesize
- 1);
6064 last
= seg
->end
& (seg
->pagesize
- 1);
6066 && ((seg
->base
& ~(seg
->pagesize
- 1))
6067 != (seg
->end
& ~(seg
->pagesize
- 1)))
6068 && first
+ last
<= seg
->pagesize
)
6070 seg
->phase
= exp_seg_adjust
;
6074 seg
->phase
= exp_seg_done
;
6079 lang_size_relro_segment_1 (seg_align_type
*seg
)
6081 bfd_vma relro_end
, desired_end
;
6084 /* Compute the expected PT_GNU_RELRO/PT_LOAD segment end. */
6085 relro_end
= ((seg
->relro_end
+ seg
->pagesize
- 1)
6086 & ~(seg
->pagesize
- 1));
6088 /* Adjust by the offset arg of XXX_SEGMENT_RELRO_END. */
6089 desired_end
= relro_end
- seg
->relro_offset
;
6091 /* For sections in the relro segment.. */
6092 for (sec
= link_info
.output_bfd
->section_last
; sec
; sec
= sec
->prev
)
6093 if ((sec
->flags
& SEC_ALLOC
) != 0
6094 && sec
->vma
>= seg
->base
6095 && sec
->vma
< seg
->relro_end
- seg
->relro_offset
)
6097 /* Where do we want to put this section so that it ends as
6099 bfd_vma start
, end
, bump
;
6101 end
= start
= sec
->vma
;
6103 end
+= TO_ADDR (sec
->size
);
6104 bump
= desired_end
- end
;
6105 /* We'd like to increase START by BUMP, but we must heed
6106 alignment so the increase might be less than optimum. */
6108 start
&= ~(((bfd_vma
) 1 << sec
->alignment_power
) - 1);
6109 /* This is now the desired end for the previous section. */
6110 desired_end
= start
;
6113 seg
->phase
= exp_seg_relro_adjust
;
6114 ASSERT (desired_end
>= seg
->base
);
6115 seg
->base
= desired_end
;
6120 lang_size_relro_segment (bfd_boolean
*relax
, bfd_boolean check_regions
)
6122 bfd_boolean do_reset
= FALSE
;
6123 bfd_boolean do_data_relro
;
6124 bfd_vma data_initial_base
, data_relro_end
;
6126 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
6128 do_data_relro
= TRUE
;
6129 data_initial_base
= expld
.dataseg
.base
;
6130 data_relro_end
= lang_size_relro_segment_1 (&expld
.dataseg
);
6134 do_data_relro
= FALSE
;
6135 data_initial_base
= data_relro_end
= 0;
6140 lang_reset_memory_regions ();
6141 one_lang_size_sections_pass (relax
, check_regions
);
6143 /* Assignments to dot, or to output section address in a user
6144 script have increased padding over the original. Revert. */
6145 if (do_data_relro
&& expld
.dataseg
.relro_end
> data_relro_end
)
6147 expld
.dataseg
.base
= data_initial_base
;;
6152 if (!do_data_relro
&& lang_size_segment (&expld
.dataseg
))
6159 lang_size_sections (bfd_boolean
*relax
, bfd_boolean check_regions
)
6161 expld
.phase
= lang_allocating_phase_enum
;
6162 expld
.dataseg
.phase
= exp_seg_none
;
6164 one_lang_size_sections_pass (relax
, check_regions
);
6166 if (expld
.dataseg
.phase
!= exp_seg_end_seen
)
6167 expld
.dataseg
.phase
= exp_seg_done
;
6169 if (expld
.dataseg
.phase
== exp_seg_end_seen
)
6171 bfd_boolean do_reset
6172 = lang_size_relro_segment (relax
, check_regions
);
6176 lang_reset_memory_regions ();
6177 one_lang_size_sections_pass (relax
, check_regions
);
6180 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
6182 link_info
.relro_start
= expld
.dataseg
.base
;
6183 link_info
.relro_end
= expld
.dataseg
.relro_end
;
6188 static lang_output_section_statement_type
*current_section
;
6189 static lang_assignment_statement_type
*current_assign
;
6190 static bfd_boolean prefer_next_section
;
6192 /* Worker function for lang_do_assignments. Recursiveness goes here. */
6195 lang_do_assignments_1 (lang_statement_union_type
*s
,
6196 lang_output_section_statement_type
*current_os
,
6199 bfd_boolean
*found_end
)
6201 for (; s
!= NULL
; s
= s
->header
.next
)
6203 switch (s
->header
.type
)
6205 case lang_constructors_statement_enum
:
6206 dot
= lang_do_assignments_1 (constructor_list
.head
,
6207 current_os
, fill
, dot
, found_end
);
6210 case lang_output_section_statement_enum
:
6212 lang_output_section_statement_type
*os
;
6215 os
= &(s
->output_section_statement
);
6216 os
->after_end
= *found_end
;
6217 init_opb (os
->bfd_section
);
6218 if (os
->bfd_section
!= NULL
&& !os
->ignored
)
6220 if ((os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
6222 current_section
= os
;
6223 prefer_next_section
= FALSE
;
6225 dot
= os
->bfd_section
->vma
;
6227 newdot
= lang_do_assignments_1 (os
->children
.head
,
6228 os
, os
->fill
, dot
, found_end
);
6231 if (os
->bfd_section
!= NULL
)
6233 /* .tbss sections effectively have zero size. */
6234 if (!IS_TBSS (os
->bfd_section
)
6235 || bfd_link_relocatable (&link_info
))
6236 dot
+= TO_ADDR (os
->bfd_section
->size
);
6238 if (os
->update_dot_tree
!= NULL
)
6239 exp_fold_tree (os
->update_dot_tree
,
6240 bfd_abs_section_ptr
, &dot
);
6248 case lang_wild_statement_enum
:
6250 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
6251 current_os
, fill
, dot
, found_end
);
6254 case lang_object_symbols_statement_enum
:
6255 case lang_output_statement_enum
:
6256 case lang_target_statement_enum
:
6259 case lang_data_statement_enum
:
6260 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
6261 if (expld
.result
.valid_p
)
6263 s
->data_statement
.value
= expld
.result
.value
;
6264 if (expld
.result
.section
!= NULL
)
6265 s
->data_statement
.value
+= expld
.result
.section
->vma
;
6267 else if (expld
.phase
== lang_final_phase_enum
)
6268 einfo (_("%F%P: invalid data statement\n"));
6271 switch (s
->data_statement
.type
)
6289 if (size
< TO_SIZE ((unsigned) 1))
6290 size
= TO_SIZE ((unsigned) 1);
6291 dot
+= TO_ADDR (size
);
6295 case lang_reloc_statement_enum
:
6296 exp_fold_tree (s
->reloc_statement
.addend_exp
,
6297 bfd_abs_section_ptr
, &dot
);
6298 if (expld
.result
.valid_p
)
6299 s
->reloc_statement
.addend_value
= expld
.result
.value
;
6300 else if (expld
.phase
== lang_final_phase_enum
)
6301 einfo (_("%F%P: invalid reloc statement\n"));
6302 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
6305 case lang_input_section_enum
:
6307 asection
*in
= s
->input_section
.section
;
6309 if ((in
->flags
& SEC_EXCLUDE
) == 0)
6310 dot
+= TO_ADDR (in
->size
);
6314 case lang_input_statement_enum
:
6317 case lang_fill_statement_enum
:
6318 fill
= s
->fill_statement
.fill
;
6321 case lang_assignment_statement_enum
:
6322 current_assign
= &s
->assignment_statement
;
6323 if (current_assign
->exp
->type
.node_class
!= etree_assert
)
6325 const char *p
= current_assign
->exp
->assign
.dst
;
6327 if (current_os
== abs_output_section
&& p
[0] == '.' && p
[1] == 0)
6328 prefer_next_section
= TRUE
;
6332 if (strcmp (p
, "end") == 0)
6335 exp_fold_tree (s
->assignment_statement
.exp
,
6336 (current_os
->bfd_section
!= NULL
6337 ? current_os
->bfd_section
: bfd_und_section_ptr
),
6341 case lang_padding_statement_enum
:
6342 dot
+= TO_ADDR (s
->padding_statement
.size
);
6345 case lang_group_statement_enum
:
6346 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
6347 current_os
, fill
, dot
, found_end
);
6350 case lang_insert_statement_enum
:
6353 case lang_address_statement_enum
:
6365 lang_do_assignments (lang_phase_type phase
)
6367 bfd_boolean found_end
= FALSE
;
6369 current_section
= NULL
;
6370 prefer_next_section
= FALSE
;
6371 expld
.phase
= phase
;
6372 lang_statement_iteration
++;
6373 lang_do_assignments_1 (statement_list
.head
,
6374 abs_output_section
, NULL
, 0, &found_end
);
6377 /* For an assignment statement outside of an output section statement,
6378 choose the best of neighbouring output sections to use for values
6382 section_for_dot (void)
6386 /* Assignments belong to the previous output section, unless there
6387 has been an assignment to "dot", in which case following
6388 assignments belong to the next output section. (The assumption
6389 is that an assignment to "dot" is setting up the address for the
6390 next output section.) Except that past the assignment to "_end"
6391 we always associate with the previous section. This exception is
6392 for targets like SH that define an alloc .stack or other
6393 weirdness after non-alloc sections. */
6394 if (current_section
== NULL
|| prefer_next_section
)
6396 lang_statement_union_type
*stmt
;
6397 lang_output_section_statement_type
*os
;
6399 for (stmt
= (lang_statement_union_type
*) current_assign
;
6401 stmt
= stmt
->header
.next
)
6402 if (stmt
->header
.type
== lang_output_section_statement_enum
)
6405 os
= &stmt
->output_section_statement
;
6408 && (os
->bfd_section
== NULL
6409 || (os
->bfd_section
->flags
& SEC_EXCLUDE
) != 0
6410 || bfd_section_removed_from_list (link_info
.output_bfd
,
6414 if (current_section
== NULL
|| os
== NULL
|| !os
->after_end
)
6417 s
= os
->bfd_section
;
6419 s
= link_info
.output_bfd
->section_last
;
6421 && ((s
->flags
& SEC_ALLOC
) == 0
6422 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6427 return bfd_abs_section_ptr
;
6431 s
= current_section
->bfd_section
;
6433 /* The section may have been stripped. */
6435 && ((s
->flags
& SEC_EXCLUDE
) != 0
6436 || (s
->flags
& SEC_ALLOC
) == 0
6437 || (s
->flags
& SEC_THREAD_LOCAL
) != 0
6438 || bfd_section_removed_from_list (link_info
.output_bfd
, s
)))
6441 s
= link_info
.output_bfd
->sections
;
6443 && ((s
->flags
& SEC_ALLOC
) == 0
6444 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6449 return bfd_abs_section_ptr
;
6452 /* Array of __start/__stop/.startof./.sizeof/ symbols. */
6454 static struct bfd_link_hash_entry
**start_stop_syms
;
6455 static size_t start_stop_count
= 0;
6456 static size_t start_stop_alloc
= 0;
6458 /* Give start/stop SYMBOL for SEC a preliminary definition, and add it
6459 to start_stop_syms. */
6462 lang_define_start_stop (const char *symbol
, asection
*sec
)
6464 struct bfd_link_hash_entry
*h
;
6466 h
= bfd_define_start_stop (link_info
.output_bfd
, &link_info
, symbol
, sec
);
6469 if (start_stop_count
== start_stop_alloc
)
6471 start_stop_alloc
= 2 * start_stop_alloc
+ 10;
6473 = xrealloc (start_stop_syms
,
6474 start_stop_alloc
* sizeof (*start_stop_syms
));
6476 start_stop_syms
[start_stop_count
++] = h
;
6480 /* Check for input sections whose names match references to
6481 __start_SECNAME or __stop_SECNAME symbols. Give the symbols
6482 preliminary definitions. */
6485 lang_init_start_stop (void)
6489 char leading_char
= bfd_get_symbol_leading_char (link_info
.output_bfd
);
6491 for (abfd
= link_info
.input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6492 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6495 const char *secname
= s
->name
;
6497 for (ps
= secname
; *ps
!= '\0'; ps
++)
6498 if (!ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
6502 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6504 symbol
[0] = leading_char
;
6505 sprintf (symbol
+ (leading_char
!= 0), "__start_%s", secname
);
6506 lang_define_start_stop (symbol
, s
);
6508 symbol
[1] = leading_char
;
6509 memcpy (symbol
+ 1 + (leading_char
!= 0), "__stop", 6);
6510 lang_define_start_stop (symbol
+ 1, s
);
6517 /* Iterate over start_stop_syms. */
6520 foreach_start_stop (void (*func
) (struct bfd_link_hash_entry
*))
6524 for (i
= 0; i
< start_stop_count
; ++i
)
6525 func (start_stop_syms
[i
]);
6528 /* __start and __stop symbols are only supposed to be defined by the
6529 linker for orphan sections, but we now extend that to sections that
6530 map to an output section of the same name. The symbols were
6531 defined early for --gc-sections, before we mapped input to output
6532 sections, so undo those that don't satisfy this rule. */
6535 undef_start_stop (struct bfd_link_hash_entry
*h
)
6537 if (h
->ldscript_def
)
6540 if (h
->u
.def
.section
->output_section
== NULL
6541 || h
->u
.def
.section
->output_section
->owner
!= link_info
.output_bfd
6542 || strcmp (h
->u
.def
.section
->name
,
6543 h
->u
.def
.section
->output_section
->name
) != 0)
6545 asection
*sec
= bfd_get_section_by_name (link_info
.output_bfd
,
6546 h
->u
.def
.section
->name
);
6549 /* When there are more than one input sections with the same
6550 section name, SECNAME, linker picks the first one to define
6551 __start_SECNAME and __stop_SECNAME symbols. When the first
6552 input section is removed by comdat group, we need to check
6553 if there is still an output section with section name
6556 for (i
= sec
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
6557 if (strcmp (h
->u
.def
.section
->name
, i
->name
) == 0)
6559 h
->u
.def
.section
= i
;
6563 h
->type
= bfd_link_hash_undefined
;
6564 h
->u
.undef
.abfd
= NULL
;
6569 lang_undef_start_stop (void)
6571 foreach_start_stop (undef_start_stop
);
6574 /* Check for output sections whose names match references to
6575 .startof.SECNAME or .sizeof.SECNAME symbols. Give the symbols
6576 preliminary definitions. */
6579 lang_init_startof_sizeof (void)
6583 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6585 const char *secname
= s
->name
;
6586 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6588 sprintf (symbol
, ".startof.%s", secname
);
6589 lang_define_start_stop (symbol
, s
);
6591 memcpy (symbol
+ 1, ".size", 5);
6592 lang_define_start_stop (symbol
+ 1, s
);
6597 /* Set .startof., .sizeof., __start and __stop symbols final values. */
6600 set_start_stop (struct bfd_link_hash_entry
*h
)
6603 || h
->type
!= bfd_link_hash_defined
)
6606 if (h
->root
.string
[0] == '.')
6608 /* .startof. or .sizeof. symbol.
6609 .startof. already has final value. */
6610 if (h
->root
.string
[2] == 'i')
6613 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6614 h
->u
.def
.section
= bfd_abs_section_ptr
;
6619 /* __start or __stop symbol. */
6620 int has_lead
= bfd_get_symbol_leading_char (link_info
.output_bfd
) != 0;
6622 h
->u
.def
.section
= h
->u
.def
.section
->output_section
;
6623 if (h
->root
.string
[4 + has_lead
] == 'o')
6626 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6632 lang_finalize_start_stop (void)
6634 foreach_start_stop (set_start_stop
);
6640 struct bfd_link_hash_entry
*h
;
6643 if ((bfd_link_relocatable (&link_info
) && !link_info
.gc_sections
)
6644 || bfd_link_dll (&link_info
))
6645 warn
= entry_from_cmdline
;
6649 /* Force the user to specify a root when generating a relocatable with
6650 --gc-sections, unless --gc-keep-exported was also given. */
6651 if (bfd_link_relocatable (&link_info
)
6652 && link_info
.gc_sections
6653 && !link_info
.gc_keep_exported
6654 && !(entry_from_cmdline
|| undef_from_cmdline
))
6655 einfo (_("%F%P: gc-sections requires either an entry or "
6656 "an undefined symbol\n"));
6658 if (entry_symbol
.name
== NULL
)
6660 /* No entry has been specified. Look for the default entry, but
6661 don't warn if we don't find it. */
6662 entry_symbol
.name
= entry_symbol_default
;
6666 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
6667 FALSE
, FALSE
, TRUE
);
6669 && (h
->type
== bfd_link_hash_defined
6670 || h
->type
== bfd_link_hash_defweak
)
6671 && h
->u
.def
.section
->output_section
!= NULL
)
6675 val
= (h
->u
.def
.value
6676 + bfd_section_vma (h
->u
.def
.section
->output_section
)
6677 + h
->u
.def
.section
->output_offset
);
6678 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6679 einfo (_("%F%P: %s: can't set start address\n"), entry_symbol
.name
);
6686 /* We couldn't find the entry symbol. Try parsing it as a
6688 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
6691 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6692 einfo (_("%F%P: can't set start address\n"));
6698 /* Can't find the entry symbol, and it's not a number. Use
6699 the first address in the text section. */
6700 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
6704 einfo (_("%P: warning: cannot find entry symbol %s;"
6705 " defaulting to %V\n"),
6707 bfd_section_vma (ts
));
6708 if (!bfd_set_start_address (link_info
.output_bfd
,
6709 bfd_section_vma (ts
)))
6710 einfo (_("%F%P: can't set start address\n"));
6715 einfo (_("%P: warning: cannot find entry symbol %s;"
6716 " not setting start address\n"),
6723 /* This is a small function used when we want to ignore errors from
6727 ignore_bfd_errors (const char *fmt ATTRIBUTE_UNUSED
,
6728 va_list ap ATTRIBUTE_UNUSED
)
6730 /* Don't do anything. */
6733 /* Check that the architecture of all the input files is compatible
6734 with the output file. Also call the backend to let it do any
6735 other checking that is needed. */
6740 lang_input_statement_type
*file
;
6742 const bfd_arch_info_type
*compatible
;
6744 for (file
= (void *) file_chain
.head
;
6748 #ifdef ENABLE_PLUGINS
6749 /* Don't check format of files claimed by plugin. */
6750 if (file
->flags
.claimed
)
6752 #endif /* ENABLE_PLUGINS */
6753 input_bfd
= file
->the_bfd
;
6755 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
6756 command_line
.accept_unknown_input_arch
);
6758 /* In general it is not possible to perform a relocatable
6759 link between differing object formats when the input
6760 file has relocations, because the relocations in the
6761 input format may not have equivalent representations in
6762 the output format (and besides BFD does not translate
6763 relocs for other link purposes than a final link). */
6764 if ((bfd_link_relocatable (&link_info
)
6765 || link_info
.emitrelocations
)
6766 && (compatible
== NULL
6767 || (bfd_get_flavour (input_bfd
)
6768 != bfd_get_flavour (link_info
.output_bfd
)))
6769 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
6771 einfo (_("%F%P: relocatable linking with relocations from"
6772 " format %s (%pB) to format %s (%pB) is not supported\n"),
6773 bfd_get_target (input_bfd
), input_bfd
,
6774 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
6775 /* einfo with %F exits. */
6778 if (compatible
== NULL
)
6780 if (command_line
.warn_mismatch
)
6781 einfo (_("%X%P: %s architecture of input file `%pB'"
6782 " is incompatible with %s output\n"),
6783 bfd_printable_name (input_bfd
), input_bfd
,
6784 bfd_printable_name (link_info
.output_bfd
));
6786 else if (bfd_count_sections (input_bfd
))
6788 /* If the input bfd has no contents, it shouldn't set the
6789 private data of the output bfd. */
6791 bfd_error_handler_type pfn
= NULL
;
6793 /* If we aren't supposed to warn about mismatched input
6794 files, temporarily set the BFD error handler to a
6795 function which will do nothing. We still want to call
6796 bfd_merge_private_bfd_data, since it may set up
6797 information which is needed in the output file. */
6798 if (!command_line
.warn_mismatch
)
6799 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
6800 if (!bfd_merge_private_bfd_data (input_bfd
, &link_info
))
6802 if (command_line
.warn_mismatch
)
6803 einfo (_("%X%P: failed to merge target specific data"
6804 " of file %pB\n"), input_bfd
);
6806 if (!command_line
.warn_mismatch
)
6807 bfd_set_error_handler (pfn
);
6812 /* Look through all the global common symbols and attach them to the
6813 correct section. The -sort-common command line switch may be used
6814 to roughly sort the entries by alignment. */
6819 if (link_info
.inhibit_common_definition
)
6821 if (bfd_link_relocatable (&link_info
)
6822 && !command_line
.force_common_definition
)
6825 if (!config
.sort_common
)
6826 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
6831 if (config
.sort_common
== sort_descending
)
6833 for (power
= 4; power
> 0; power
--)
6834 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6837 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6841 for (power
= 0; power
<= 4; power
++)
6842 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6844 power
= (unsigned int) -1;
6845 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6850 /* Place one common symbol in the correct section. */
6853 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
6855 unsigned int power_of_two
;
6859 if (h
->type
!= bfd_link_hash_common
)
6863 power_of_two
= h
->u
.c
.p
->alignment_power
;
6865 if (config
.sort_common
== sort_descending
6866 && power_of_two
< *(unsigned int *) info
)
6868 else if (config
.sort_common
== sort_ascending
6869 && power_of_two
> *(unsigned int *) info
)
6872 section
= h
->u
.c
.p
->section
;
6873 if (!bfd_define_common_symbol (link_info
.output_bfd
, &link_info
, h
))
6874 einfo (_("%F%P: could not define common symbol `%pT': %E\n"),
6877 if (config
.map_file
!= NULL
)
6879 static bfd_boolean header_printed
;
6884 if (!header_printed
)
6886 minfo (_("\nAllocating common symbols\n"));
6887 minfo (_("Common symbol size file\n\n"));
6888 header_printed
= TRUE
;
6891 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
6892 DMGL_ANSI
| DMGL_PARAMS
);
6895 minfo ("%s", h
->root
.string
);
6896 len
= strlen (h
->root
.string
);
6901 len
= strlen (name
);
6917 if (size
<= 0xffffffff)
6918 sprintf (buf
, "%lx", (unsigned long) size
);
6920 sprintf_vma (buf
, size
);
6930 minfo ("%pB\n", section
->owner
);
6936 /* Handle a single orphan section S, placing the orphan into an appropriate
6937 output section. The effects of the --orphan-handling command line
6938 option are handled here. */
6941 ldlang_place_orphan (asection
*s
)
6943 if (config
.orphan_handling
== orphan_handling_discard
)
6945 lang_output_section_statement_type
*os
;
6946 os
= lang_output_section_statement_lookup (DISCARD_SECTION_NAME
, 0,
6948 if (os
->addr_tree
== NULL
6949 && (bfd_link_relocatable (&link_info
)
6950 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6951 os
->addr_tree
= exp_intop (0);
6952 lang_add_section (&os
->children
, s
, NULL
, os
);
6956 lang_output_section_statement_type
*os
;
6957 const char *name
= s
->name
;
6960 if (config
.orphan_handling
== orphan_handling_error
)
6961 einfo (_("%X%P: error: unplaced orphan section `%pA' from `%pB'\n"),
6964 if (config
.unique_orphan_sections
|| unique_section_p (s
, NULL
))
6965 constraint
= SPECIAL
;
6967 os
= ldemul_place_orphan (s
, name
, constraint
);
6970 os
= lang_output_section_statement_lookup (name
, constraint
, TRUE
);
6971 if (os
->addr_tree
== NULL
6972 && (bfd_link_relocatable (&link_info
)
6973 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6974 os
->addr_tree
= exp_intop (0);
6975 lang_add_section (&os
->children
, s
, NULL
, os
);
6978 if (config
.orphan_handling
== orphan_handling_warn
)
6979 einfo (_("%P: warning: orphan section `%pA' from `%pB' being "
6980 "placed in section `%s'\n"),
6981 s
, s
->owner
, os
->name
);
6985 /* Run through the input files and ensure that every input section has
6986 somewhere to go. If one is found without a destination then create
6987 an input request and place it into the statement tree. */
6990 lang_place_orphans (void)
6992 LANG_FOR_EACH_INPUT_STATEMENT (file
)
6996 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6998 if (s
->output_section
== NULL
)
7000 /* This section of the file is not attached, root
7001 around for a sensible place for it to go. */
7003 if (file
->flags
.just_syms
)
7004 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
7005 else if (lang_discard_section_p (s
))
7006 s
->output_section
= bfd_abs_section_ptr
;
7007 else if (strcmp (s
->name
, "COMMON") == 0)
7009 /* This is a lonely common section which must have
7010 come from an archive. We attach to the section
7011 with the wildcard. */
7012 if (!bfd_link_relocatable (&link_info
)
7013 || command_line
.force_common_definition
)
7015 if (default_common_section
== NULL
)
7016 default_common_section
7017 = lang_output_section_statement_lookup (".bss", 0,
7019 lang_add_section (&default_common_section
->children
, s
,
7020 NULL
, default_common_section
);
7024 ldlang_place_orphan (s
);
7031 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
7033 flagword
*ptr_flags
;
7035 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
7041 /* PR 17900: An exclamation mark in the attributes reverses
7042 the sense of any of the attributes that follow. */
7045 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
7049 *ptr_flags
|= SEC_ALLOC
;
7053 *ptr_flags
|= SEC_READONLY
;
7057 *ptr_flags
|= SEC_DATA
;
7061 *ptr_flags
|= SEC_CODE
;
7066 *ptr_flags
|= SEC_LOAD
;
7070 einfo (_("%F%P: invalid character %c (%d) in flags\n"),
7078 /* Call a function on each real input file. This function will be
7079 called on an archive, but not on the elements. */
7082 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
7084 lang_input_statement_type
*f
;
7086 for (f
= (void *) input_file_chain
.head
;
7088 f
= f
->next_real_file
)
7093 /* Call a function on each real file. The function will be called on
7094 all the elements of an archive which are included in the link, but
7095 will not be called on the archive file itself. */
7098 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
7100 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7108 ldlang_add_file (lang_input_statement_type
*entry
)
7110 lang_statement_append (&file_chain
, entry
, &entry
->next
);
7112 /* The BFD linker needs to have a list of all input BFDs involved in
7114 ASSERT (entry
->the_bfd
->link
.next
== NULL
);
7115 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
7117 *link_info
.input_bfds_tail
= entry
->the_bfd
;
7118 link_info
.input_bfds_tail
= &entry
->the_bfd
->link
.next
;
7119 bfd_set_usrdata (entry
->the_bfd
, entry
);
7120 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
7122 /* Look through the sections and check for any which should not be
7123 included in the link. We need to do this now, so that we can
7124 notice when the backend linker tries to report multiple
7125 definition errors for symbols which are in sections we aren't
7126 going to link. FIXME: It might be better to entirely ignore
7127 symbols which are defined in sections which are going to be
7128 discarded. This would require modifying the backend linker for
7129 each backend which might set the SEC_LINK_ONCE flag. If we do
7130 this, we should probably handle SEC_EXCLUDE in the same way. */
7132 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
7136 lang_add_output (const char *name
, int from_script
)
7138 /* Make -o on command line override OUTPUT in script. */
7139 if (!had_output_filename
|| !from_script
)
7141 output_filename
= name
;
7142 had_output_filename
= TRUE
;
7146 lang_output_section_statement_type
*
7147 lang_enter_output_section_statement (const char *output_section_statement_name
,
7148 etree_type
*address_exp
,
7149 enum section_type sectype
,
7151 etree_type
*subalign
,
7154 int align_with_input
)
7156 lang_output_section_statement_type
*os
;
7158 os
= lang_output_section_statement_lookup (output_section_statement_name
,
7160 current_section
= os
;
7162 if (os
->addr_tree
== NULL
)
7164 os
->addr_tree
= address_exp
;
7166 os
->sectype
= sectype
;
7167 if (sectype
!= noload_section
)
7168 os
->flags
= SEC_NO_FLAGS
;
7170 os
->flags
= SEC_NEVER_LOAD
;
7171 os
->block_value
= 1;
7173 /* Make next things chain into subchain of this. */
7174 push_stat_ptr (&os
->children
);
7176 os
->align_lma_with_input
= align_with_input
== ALIGN_WITH_INPUT
;
7177 if (os
->align_lma_with_input
&& align
!= NULL
)
7178 einfo (_("%F%P:%pS: error: align with input and explicit align specified\n"),
7181 os
->subsection_alignment
= subalign
;
7182 os
->section_alignment
= align
;
7184 os
->load_base
= ebase
;
7191 lang_output_statement_type
*new_stmt
;
7193 new_stmt
= new_stat (lang_output_statement
, stat_ptr
);
7194 new_stmt
->name
= output_filename
;
7197 /* Reset the current counters in the regions. */
7200 lang_reset_memory_regions (void)
7202 lang_memory_region_type
*p
= lang_memory_region_list
;
7204 lang_output_section_statement_type
*os
;
7206 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
7208 p
->current
= p
->origin
;
7212 for (os
= (void *) lang_os_list
.head
;
7216 os
->processed_vma
= FALSE
;
7217 os
->processed_lma
= FALSE
;
7220 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
7222 /* Save the last size for possible use by bfd_relax_section. */
7223 o
->rawsize
= o
->size
;
7224 if (!(o
->flags
& SEC_FIXED_SIZE
))
7229 /* Worker for lang_gc_sections_1. */
7232 gc_section_callback (lang_wild_statement_type
*ptr
,
7233 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7235 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
7236 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7237 void *data ATTRIBUTE_UNUSED
)
7239 /* If the wild pattern was marked KEEP, the member sections
7240 should be as well. */
7241 if (ptr
->keep_sections
)
7242 section
->flags
|= SEC_KEEP
;
7245 /* Iterate over sections marking them against GC. */
7248 lang_gc_sections_1 (lang_statement_union_type
*s
)
7250 for (; s
!= NULL
; s
= s
->header
.next
)
7252 switch (s
->header
.type
)
7254 case lang_wild_statement_enum
:
7255 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
7257 case lang_constructors_statement_enum
:
7258 lang_gc_sections_1 (constructor_list
.head
);
7260 case lang_output_section_statement_enum
:
7261 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
7263 case lang_group_statement_enum
:
7264 lang_gc_sections_1 (s
->group_statement
.children
.head
);
7273 lang_gc_sections (void)
7275 /* Keep all sections so marked in the link script. */
7276 lang_gc_sections_1 (statement_list
.head
);
7278 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
7279 the special case of debug info. (See bfd/stabs.c)
7280 Twiddle the flag here, to simplify later linker code. */
7281 if (bfd_link_relocatable (&link_info
))
7283 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7286 #ifdef ENABLE_PLUGINS
7287 if (f
->flags
.claimed
)
7290 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7291 if ((sec
->flags
& SEC_DEBUGGING
) == 0)
7292 sec
->flags
&= ~SEC_EXCLUDE
;
7296 if (link_info
.gc_sections
)
7297 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
7300 /* Worker for lang_find_relro_sections_1. */
7303 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
7304 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7306 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
7307 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7310 /* Discarded, excluded and ignored sections effectively have zero
7312 if (section
->output_section
!= NULL
7313 && section
->output_section
->owner
== link_info
.output_bfd
7314 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
7315 && !IGNORE_SECTION (section
)
7316 && section
->size
!= 0)
7318 bfd_boolean
*has_relro_section
= (bfd_boolean
*) data
;
7319 *has_relro_section
= TRUE
;
7323 /* Iterate over sections for relro sections. */
7326 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
7327 seg_align_type
*seg
,
7328 bfd_boolean
*has_relro_section
)
7330 if (*has_relro_section
)
7333 for (; s
!= NULL
; s
= s
->header
.next
)
7335 if (s
== seg
->relro_end_stat
)
7338 switch (s
->header
.type
)
7340 case lang_wild_statement_enum
:
7341 walk_wild (&s
->wild_statement
,
7342 find_relro_section_callback
,
7345 case lang_constructors_statement_enum
:
7346 lang_find_relro_sections_1 (constructor_list
.head
,
7347 seg
, has_relro_section
);
7349 case lang_output_section_statement_enum
:
7350 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
7351 seg
, has_relro_section
);
7353 case lang_group_statement_enum
:
7354 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
7355 seg
, has_relro_section
);
7364 lang_find_relro_sections (void)
7366 bfd_boolean has_relro_section
= FALSE
;
7368 /* Check all sections in the link script. */
7370 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
7371 &expld
.dataseg
, &has_relro_section
);
7373 if (!has_relro_section
)
7374 link_info
.relro
= FALSE
;
7377 /* Relax all sections until bfd_relax_section gives up. */
7380 lang_relax_sections (bfd_boolean need_layout
)
7382 if (RELAXATION_ENABLED
)
7384 /* We may need more than one relaxation pass. */
7385 int i
= link_info
.relax_pass
;
7387 /* The backend can use it to determine the current pass. */
7388 link_info
.relax_pass
= 0;
7392 /* Keep relaxing until bfd_relax_section gives up. */
7393 bfd_boolean relax_again
;
7395 link_info
.relax_trip
= -1;
7398 link_info
.relax_trip
++;
7400 /* Note: pe-dll.c does something like this also. If you find
7401 you need to change this code, you probably need to change
7402 pe-dll.c also. DJ */
7404 /* Do all the assignments with our current guesses as to
7406 lang_do_assignments (lang_assigning_phase_enum
);
7408 /* We must do this after lang_do_assignments, because it uses
7410 lang_reset_memory_regions ();
7412 /* Perform another relax pass - this time we know where the
7413 globals are, so can make a better guess. */
7414 relax_again
= FALSE
;
7415 lang_size_sections (&relax_again
, FALSE
);
7417 while (relax_again
);
7419 link_info
.relax_pass
++;
7426 /* Final extra sizing to report errors. */
7427 lang_do_assignments (lang_assigning_phase_enum
);
7428 lang_reset_memory_regions ();
7429 lang_size_sections (NULL
, TRUE
);
7433 #ifdef ENABLE_PLUGINS
7434 /* Find the insert point for the plugin's replacement files. We
7435 place them after the first claimed real object file, or if the
7436 first claimed object is an archive member, after the last real
7437 object file immediately preceding the archive. In the event
7438 no objects have been claimed at all, we return the first dummy
7439 object file on the list as the insert point; that works, but
7440 the callee must be careful when relinking the file_chain as it
7441 is not actually on that chain, only the statement_list and the
7442 input_file list; in that case, the replacement files must be
7443 inserted at the head of the file_chain. */
7445 static lang_input_statement_type
*
7446 find_replacements_insert_point (bfd_boolean
*before
)
7448 lang_input_statement_type
*claim1
, *lastobject
;
7449 lastobject
= (void *) input_file_chain
.head
;
7450 for (claim1
= (void *) file_chain
.head
;
7452 claim1
= claim1
->next
)
7454 if (claim1
->flags
.claimed
)
7456 *before
= claim1
->flags
.claim_archive
;
7457 return claim1
->flags
.claim_archive
? lastobject
: claim1
;
7459 /* Update lastobject if this is a real object file. */
7460 if (claim1
->the_bfd
!= NULL
&& claim1
->the_bfd
->my_archive
== NULL
)
7461 lastobject
= claim1
;
7463 /* No files were claimed by the plugin. Choose the last object
7464 file found on the list (maybe the first, dummy entry) as the
7470 /* Find where to insert ADD, an archive element or shared library
7471 added during a rescan. */
7473 static lang_input_statement_type
**
7474 find_rescan_insertion (lang_input_statement_type
*add
)
7476 bfd
*add_bfd
= add
->the_bfd
;
7477 lang_input_statement_type
*f
;
7478 lang_input_statement_type
*last_loaded
= NULL
;
7479 lang_input_statement_type
*before
= NULL
;
7480 lang_input_statement_type
**iter
= NULL
;
7482 if (add_bfd
->my_archive
!= NULL
)
7483 add_bfd
= add_bfd
->my_archive
;
7485 /* First look through the input file chain, to find an object file
7486 before the one we've rescanned. Normal object files always
7487 appear on both the input file chain and the file chain, so this
7488 lets us get quickly to somewhere near the correct place on the
7489 file chain if it is full of archive elements. Archives don't
7490 appear on the file chain, but if an element has been extracted
7491 then their input_statement->next points at it. */
7492 for (f
= (void *) input_file_chain
.head
;
7494 f
= f
->next_real_file
)
7496 if (f
->the_bfd
== add_bfd
)
7498 before
= last_loaded
;
7499 if (f
->next
!= NULL
)
7500 return &f
->next
->next
;
7502 if (f
->the_bfd
!= NULL
&& f
->next
!= NULL
)
7506 for (iter
= before
? &before
->next
: &file_chain
.head
->input_statement
.next
;
7508 iter
= &(*iter
)->next
)
7509 if (!(*iter
)->flags
.claim_archive
7510 && (*iter
)->the_bfd
->my_archive
== NULL
)
7516 /* Insert SRCLIST into DESTLIST after given element by chaining
7517 on FIELD as the next-pointer. (Counterintuitively does not need
7518 a pointer to the actual after-node itself, just its chain field.) */
7521 lang_list_insert_after (lang_statement_list_type
*destlist
,
7522 lang_statement_list_type
*srclist
,
7523 lang_statement_union_type
**field
)
7525 *(srclist
->tail
) = *field
;
7526 *field
= srclist
->head
;
7527 if (destlist
->tail
== field
)
7528 destlist
->tail
= srclist
->tail
;
7531 /* Detach new nodes added to DESTLIST since the time ORIGLIST
7532 was taken as a copy of it and leave them in ORIGLIST. */
7535 lang_list_remove_tail (lang_statement_list_type
*destlist
,
7536 lang_statement_list_type
*origlist
)
7538 union lang_statement_union
**savetail
;
7539 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
7540 ASSERT (origlist
->head
== destlist
->head
);
7541 savetail
= origlist
->tail
;
7542 origlist
->head
= *(savetail
);
7543 origlist
->tail
= destlist
->tail
;
7544 destlist
->tail
= savetail
;
7548 static lang_statement_union_type
**
7549 find_next_input_statement (lang_statement_union_type
**s
)
7551 for ( ; *s
; s
= &(*s
)->header
.next
)
7553 lang_statement_union_type
**t
;
7554 switch ((*s
)->header
.type
)
7556 case lang_input_statement_enum
:
7558 case lang_wild_statement_enum
:
7559 t
= &(*s
)->wild_statement
.children
.head
;
7561 case lang_group_statement_enum
:
7562 t
= &(*s
)->group_statement
.children
.head
;
7564 case lang_output_section_statement_enum
:
7565 t
= &(*s
)->output_section_statement
.children
.head
;
7570 t
= find_next_input_statement (t
);
7576 #endif /* ENABLE_PLUGINS */
7578 /* Add NAME to the list of garbage collection entry points. */
7581 lang_add_gc_name (const char *name
)
7583 struct bfd_sym_chain
*sym
;
7588 sym
= stat_alloc (sizeof (*sym
));
7590 sym
->next
= link_info
.gc_sym_list
;
7592 link_info
.gc_sym_list
= sym
;
7595 /* Check relocations. */
7598 lang_check_relocs (void)
7600 if (link_info
.check_relocs_after_open_input
)
7604 for (abfd
= link_info
.input_bfds
;
7605 abfd
!= (bfd
*) NULL
; abfd
= abfd
->link
.next
)
7606 if (!bfd_link_check_relocs (abfd
, &link_info
))
7608 /* No object output, fail return. */
7609 config
.make_executable
= FALSE
;
7610 /* Note: we do not abort the loop, but rather
7611 continue the scan in case there are other
7612 bad relocations to report. */
7617 /* Look through all output sections looking for places where we can
7618 propagate forward the lma region. */
7621 lang_propagate_lma_regions (void)
7623 lang_output_section_statement_type
*os
;
7625 for (os
= (void *) lang_os_list
.head
;
7629 if (os
->prev
!= NULL
7630 && os
->lma_region
== NULL
7631 && os
->load_base
== NULL
7632 && os
->addr_tree
== NULL
7633 && os
->region
== os
->prev
->region
)
7634 os
->lma_region
= os
->prev
->lma_region
;
7641 /* Finalize dynamic list. */
7642 if (link_info
.dynamic_list
)
7643 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
7645 current_target
= default_target
;
7647 /* Open the output file. */
7648 lang_for_each_statement (ldlang_open_output
);
7651 ldemul_create_output_section_statements ();
7653 /* Add to the hash table all undefineds on the command line. */
7654 lang_place_undefineds ();
7656 if (!bfd_section_already_linked_table_init ())
7657 einfo (_("%F%P: can not create hash table: %E\n"));
7659 /* Create a bfd for each input file. */
7660 current_target
= default_target
;
7661 lang_statement_iteration
++;
7662 open_input_bfds (statement_list
.head
, OPEN_BFD_NORMAL
);
7663 /* open_input_bfds also handles assignments, so we can give values
7664 to symbolic origin/length now. */
7665 lang_do_memory_regions ();
7667 #ifdef ENABLE_PLUGINS
7668 if (link_info
.lto_plugin_active
)
7670 lang_statement_list_type added
;
7671 lang_statement_list_type files
, inputfiles
;
7673 /* Now all files are read, let the plugin(s) decide if there
7674 are any more to be added to the link before we call the
7675 emulation's after_open hook. We create a private list of
7676 input statements for this purpose, which we will eventually
7677 insert into the global statement list after the first claimed
7680 /* We need to manipulate all three chains in synchrony. */
7682 inputfiles
= input_file_chain
;
7683 if (plugin_call_all_symbols_read ())
7684 einfo (_("%F%P: %s: plugin reported error after all symbols read\n"),
7685 plugin_error_plugin ());
7686 /* Open any newly added files, updating the file chains. */
7687 plugin_undefs
= link_info
.hash
->undefs_tail
;
7688 open_input_bfds (*added
.tail
, OPEN_BFD_NORMAL
);
7689 if (plugin_undefs
== link_info
.hash
->undefs_tail
)
7690 plugin_undefs
= NULL
;
7691 /* Restore the global list pointer now they have all been added. */
7692 lang_list_remove_tail (stat_ptr
, &added
);
7693 /* And detach the fresh ends of the file lists. */
7694 lang_list_remove_tail (&file_chain
, &files
);
7695 lang_list_remove_tail (&input_file_chain
, &inputfiles
);
7696 /* Were any new files added? */
7697 if (added
.head
!= NULL
)
7699 /* If so, we will insert them into the statement list immediately
7700 after the first input file that was claimed by the plugin,
7701 unless that file was an archive in which case it is inserted
7702 immediately before. */
7704 lang_statement_union_type
**prev
;
7705 plugin_insert
= find_replacements_insert_point (&before
);
7706 /* If a plugin adds input files without having claimed any, we
7707 don't really have a good idea where to place them. Just putting
7708 them at the start or end of the list is liable to leave them
7709 outside the crtbegin...crtend range. */
7710 ASSERT (plugin_insert
!= NULL
);
7711 /* Splice the new statement list into the old one. */
7712 prev
= &plugin_insert
->header
.next
;
7715 prev
= find_next_input_statement (prev
);
7716 if (*prev
!= (void *) plugin_insert
->next_real_file
)
7718 /* We didn't find the expected input statement.
7719 Fall back to adding after plugin_insert. */
7720 prev
= &plugin_insert
->header
.next
;
7723 lang_list_insert_after (stat_ptr
, &added
, prev
);
7724 /* Likewise for the file chains. */
7725 lang_list_insert_after (&input_file_chain
, &inputfiles
,
7726 (void *) &plugin_insert
->next_real_file
);
7727 /* We must be careful when relinking file_chain; we may need to
7728 insert the new files at the head of the list if the insert
7729 point chosen is the dummy first input file. */
7730 if (plugin_insert
->filename
)
7731 lang_list_insert_after (&file_chain
, &files
,
7732 (void *) &plugin_insert
->next
);
7734 lang_list_insert_after (&file_chain
, &files
, &file_chain
.head
);
7736 /* Rescan archives in case new undefined symbols have appeared. */
7738 lang_statement_iteration
++;
7739 open_input_bfds (statement_list
.head
, OPEN_BFD_RESCAN
);
7740 lang_list_remove_tail (&file_chain
, &files
);
7741 while (files
.head
!= NULL
)
7743 lang_input_statement_type
**insert
;
7744 lang_input_statement_type
**iter
, *temp
;
7747 insert
= find_rescan_insertion (&files
.head
->input_statement
);
7748 /* All elements from an archive can be added at once. */
7749 iter
= &files
.head
->input_statement
.next
;
7750 my_arch
= files
.head
->input_statement
.the_bfd
->my_archive
;
7751 if (my_arch
!= NULL
)
7752 for (; *iter
!= NULL
; iter
= &(*iter
)->next
)
7753 if ((*iter
)->the_bfd
->my_archive
!= my_arch
)
7756 *insert
= &files
.head
->input_statement
;
7757 files
.head
= (lang_statement_union_type
*) *iter
;
7759 if (my_arch
!= NULL
)
7761 lang_input_statement_type
*parent
= bfd_usrdata (my_arch
);
7763 parent
->next
= (lang_input_statement_type
*)
7765 - offsetof (lang_input_statement_type
, next
));
7770 #endif /* ENABLE_PLUGINS */
7772 /* Make sure that nobody has tried to add a symbol to this list
7774 ASSERT (link_info
.gc_sym_list
== NULL
);
7776 link_info
.gc_sym_list
= &entry_symbol
;
7778 if (entry_symbol
.name
== NULL
)
7780 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
7782 /* entry_symbol is normally initialied by a ENTRY definition in the
7783 linker script or the -e command line option. But if neither of
7784 these have been used, the target specific backend may still have
7785 provided an entry symbol via a call to lang_default_entry().
7786 Unfortunately this value will not be processed until lang_end()
7787 is called, long after this function has finished. So detect this
7788 case here and add the target's entry symbol to the list of starting
7789 points for garbage collection resolution. */
7790 lang_add_gc_name (entry_symbol_default
);
7793 lang_add_gc_name (link_info
.init_function
);
7794 lang_add_gc_name (link_info
.fini_function
);
7796 ldemul_after_open ();
7797 if (config
.map_file
!= NULL
)
7798 lang_print_asneeded ();
7802 bfd_section_already_linked_table_free ();
7804 /* Make sure that we're not mixing architectures. We call this
7805 after all the input files have been opened, but before we do any
7806 other processing, so that any operations merge_private_bfd_data
7807 does on the output file will be known during the rest of the
7811 /* Handle .exports instead of a version script if we're told to do so. */
7812 if (command_line
.version_exports_section
)
7813 lang_do_version_exports_section ();
7815 /* Build all sets based on the information gathered from the input
7817 ldctor_build_sets ();
7819 /* Give initial values for __start and __stop symbols, so that ELF
7820 gc_sections will keep sections referenced by these symbols. Must
7821 be done before lang_do_assignments below. */
7822 if (config
.build_constructors
)
7823 lang_init_start_stop ();
7825 /* PR 13683: We must rerun the assignments prior to running garbage
7826 collection in order to make sure that all symbol aliases are resolved. */
7827 lang_do_assignments (lang_mark_phase_enum
);
7828 expld
.phase
= lang_first_phase_enum
;
7830 /* Size up the common data. */
7833 /* Remove unreferenced sections if asked to. */
7834 lang_gc_sections ();
7836 /* Check relocations. */
7837 lang_check_relocs ();
7839 ldemul_after_check_relocs ();
7841 /* Update wild statements. */
7842 update_wild_statements (statement_list
.head
);
7844 /* Run through the contours of the script and attach input sections
7845 to the correct output sections. */
7846 lang_statement_iteration
++;
7847 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
7849 /* Start at the statement immediately after the special abs_section
7850 output statement, so that it isn't reordered. */
7851 process_insert_statements (&lang_os_list
.head
->header
.next
);
7853 ldemul_before_place_orphans ();
7855 /* Find any sections not attached explicitly and handle them. */
7856 lang_place_orphans ();
7858 if (!bfd_link_relocatable (&link_info
))
7862 /* Merge SEC_MERGE sections. This has to be done after GC of
7863 sections, so that GCed sections are not merged, but before
7864 assigning dynamic symbols, since removing whole input sections
7866 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
7868 /* Look for a text section and set the readonly attribute in it. */
7869 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
7873 if (config
.text_read_only
)
7874 found
->flags
|= SEC_READONLY
;
7876 found
->flags
&= ~SEC_READONLY
;
7880 /* Merge together CTF sections. After this, only the symtab-dependent
7881 function and data object sections need adjustment. */
7884 /* Emit the CTF, iff the emulation doesn't need to do late emission after
7885 examining things laid out late, like the strtab. */
7888 /* Copy forward lma regions for output sections in same lma region. */
7889 lang_propagate_lma_regions ();
7891 /* Defining __start/__stop symbols early for --gc-sections to work
7892 around a glibc build problem can result in these symbols being
7893 defined when they should not be. Fix them now. */
7894 if (config
.build_constructors
)
7895 lang_undef_start_stop ();
7897 /* Define .startof./.sizeof. symbols with preliminary values before
7898 dynamic symbols are created. */
7899 if (!bfd_link_relocatable (&link_info
))
7900 lang_init_startof_sizeof ();
7902 /* Do anything special before sizing sections. This is where ELF
7903 and other back-ends size dynamic sections. */
7904 ldemul_before_allocation ();
7906 /* We must record the program headers before we try to fix the
7907 section positions, since they will affect SIZEOF_HEADERS. */
7908 lang_record_phdrs ();
7910 /* Check relro sections. */
7911 if (link_info
.relro
&& !bfd_link_relocatable (&link_info
))
7912 lang_find_relro_sections ();
7914 /* Size up the sections. */
7915 lang_size_sections (NULL
, !RELAXATION_ENABLED
);
7917 /* See if anything special should be done now we know how big
7918 everything is. This is where relaxation is done. */
7919 ldemul_after_allocation ();
7921 /* Fix any __start, __stop, .startof. or .sizeof. symbols. */
7922 lang_finalize_start_stop ();
7924 /* Do all the assignments again, to report errors. Assignment
7925 statements are processed multiple times, updating symbols; In
7926 open_input_bfds, lang_do_assignments, and lang_size_sections.
7927 Since lang_relax_sections calls lang_do_assignments, symbols are
7928 also updated in ldemul_after_allocation. */
7929 lang_do_assignments (lang_final_phase_enum
);
7933 /* Convert absolute symbols to section relative. */
7934 ldexp_finalize_syms ();
7936 /* Make sure that the section addresses make sense. */
7937 if (command_line
.check_section_addresses
)
7938 lang_check_section_addresses ();
7940 /* Check any required symbols are known. */
7941 ldlang_check_require_defined_symbols ();
7946 /* EXPORTED TO YACC */
7949 lang_add_wild (struct wildcard_spec
*filespec
,
7950 struct wildcard_list
*section_list
,
7951 bfd_boolean keep_sections
)
7953 struct wildcard_list
*curr
, *next
;
7954 lang_wild_statement_type
*new_stmt
;
7956 /* Reverse the list as the parser puts it back to front. */
7957 for (curr
= section_list
, section_list
= NULL
;
7959 section_list
= curr
, curr
= next
)
7962 curr
->next
= section_list
;
7965 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
7967 if (strcmp (filespec
->name
, "*") == 0)
7968 filespec
->name
= NULL
;
7969 else if (!wildcardp (filespec
->name
))
7970 lang_has_input_file
= TRUE
;
7973 new_stmt
= new_stat (lang_wild_statement
, stat_ptr
);
7974 new_stmt
->filename
= NULL
;
7975 new_stmt
->filenames_sorted
= FALSE
;
7976 new_stmt
->section_flag_list
= NULL
;
7977 new_stmt
->exclude_name_list
= NULL
;
7978 if (filespec
!= NULL
)
7980 new_stmt
->filename
= filespec
->name
;
7981 new_stmt
->filenames_sorted
= filespec
->sorted
== by_name
;
7982 new_stmt
->section_flag_list
= filespec
->section_flag_list
;
7983 new_stmt
->exclude_name_list
= filespec
->exclude_name_list
;
7985 new_stmt
->section_list
= section_list
;
7986 new_stmt
->keep_sections
= keep_sections
;
7987 lang_list_init (&new_stmt
->children
);
7988 analyze_walk_wild_section_handler (new_stmt
);
7992 lang_section_start (const char *name
, etree_type
*address
,
7993 const segment_type
*segment
)
7995 lang_address_statement_type
*ad
;
7997 ad
= new_stat (lang_address_statement
, stat_ptr
);
7998 ad
->section_name
= name
;
7999 ad
->address
= address
;
8000 ad
->segment
= segment
;
8003 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
8004 because of a -e argument on the command line, or zero if this is
8005 called by ENTRY in a linker script. Command line arguments take
8009 lang_add_entry (const char *name
, bfd_boolean cmdline
)
8011 if (entry_symbol
.name
== NULL
8013 || !entry_from_cmdline
)
8015 entry_symbol
.name
= name
;
8016 entry_from_cmdline
= cmdline
;
8020 /* Set the default start symbol to NAME. .em files should use this,
8021 not lang_add_entry, to override the use of "start" if neither the
8022 linker script nor the command line specifies an entry point. NAME
8023 must be permanently allocated. */
8025 lang_default_entry (const char *name
)
8027 entry_symbol_default
= name
;
8031 lang_add_target (const char *name
)
8033 lang_target_statement_type
*new_stmt
;
8035 new_stmt
= new_stat (lang_target_statement
, stat_ptr
);
8036 new_stmt
->target
= name
;
8040 lang_add_map (const char *name
)
8047 map_option_f
= TRUE
;
8055 lang_add_fill (fill_type
*fill
)
8057 lang_fill_statement_type
*new_stmt
;
8059 new_stmt
= new_stat (lang_fill_statement
, stat_ptr
);
8060 new_stmt
->fill
= fill
;
8064 lang_add_data (int type
, union etree_union
*exp
)
8066 lang_data_statement_type
*new_stmt
;
8068 new_stmt
= new_stat (lang_data_statement
, stat_ptr
);
8069 new_stmt
->exp
= exp
;
8070 new_stmt
->type
= type
;
8073 /* Create a new reloc statement. RELOC is the BFD relocation type to
8074 generate. HOWTO is the corresponding howto structure (we could
8075 look this up, but the caller has already done so). SECTION is the
8076 section to generate a reloc against, or NAME is the name of the
8077 symbol to generate a reloc against. Exactly one of SECTION and
8078 NAME must be NULL. ADDEND is an expression for the addend. */
8081 lang_add_reloc (bfd_reloc_code_real_type reloc
,
8082 reloc_howto_type
*howto
,
8085 union etree_union
*addend
)
8087 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
8091 p
->section
= section
;
8093 p
->addend_exp
= addend
;
8095 p
->addend_value
= 0;
8096 p
->output_section
= NULL
;
8097 p
->output_offset
= 0;
8100 lang_assignment_statement_type
*
8101 lang_add_assignment (etree_type
*exp
)
8103 lang_assignment_statement_type
*new_stmt
;
8105 new_stmt
= new_stat (lang_assignment_statement
, stat_ptr
);
8106 new_stmt
->exp
= exp
;
8111 lang_add_attribute (enum statement_enum attribute
)
8113 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
8117 lang_startup (const char *name
)
8119 if (first_file
->filename
!= NULL
)
8121 einfo (_("%F%P: multiple STARTUP files\n"));
8123 first_file
->filename
= name
;
8124 first_file
->local_sym_name
= name
;
8125 first_file
->flags
.real
= TRUE
;
8129 lang_float (bfd_boolean maybe
)
8131 lang_float_flag
= maybe
;
8135 /* Work out the load- and run-time regions from a script statement, and
8136 store them in *LMA_REGION and *REGION respectively.
8138 MEMSPEC is the name of the run-time region, or the value of
8139 DEFAULT_MEMORY_REGION if the statement didn't specify one.
8140 LMA_MEMSPEC is the name of the load-time region, or null if the
8141 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
8142 had an explicit load address.
8144 It is an error to specify both a load region and a load address. */
8147 lang_get_regions (lang_memory_region_type
**region
,
8148 lang_memory_region_type
**lma_region
,
8149 const char *memspec
,
8150 const char *lma_memspec
,
8151 bfd_boolean have_lma
,
8152 bfd_boolean have_vma
)
8154 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
8156 /* If no runtime region or VMA has been specified, but the load region
8157 has been specified, then use the load region for the runtime region
8159 if (lma_memspec
!= NULL
8161 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
8162 *region
= *lma_region
;
8164 *region
= lang_memory_region_lookup (memspec
, FALSE
);
8166 if (have_lma
&& lma_memspec
!= 0)
8167 einfo (_("%X%P:%pS: section has both a load address and a load region\n"),
8172 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
8173 lang_output_section_phdr_list
*phdrs
,
8174 const char *lma_memspec
)
8176 lang_get_regions (¤t_section
->region
,
8177 ¤t_section
->lma_region
,
8178 memspec
, lma_memspec
,
8179 current_section
->load_base
!= NULL
,
8180 current_section
->addr_tree
!= NULL
);
8182 current_section
->fill
= fill
;
8183 current_section
->phdrs
= phdrs
;
8187 /* Set the output format type. -oformat overrides scripts. */
8190 lang_add_output_format (const char *format
,
8195 if (output_target
== NULL
|| !from_script
)
8197 if (command_line
.endian
== ENDIAN_BIG
8200 else if (command_line
.endian
== ENDIAN_LITTLE
8204 output_target
= format
;
8209 lang_add_insert (const char *where
, int is_before
)
8211 lang_insert_statement_type
*new_stmt
;
8213 new_stmt
= new_stat (lang_insert_statement
, stat_ptr
);
8214 new_stmt
->where
= where
;
8215 new_stmt
->is_before
= is_before
;
8216 saved_script_handle
= previous_script_handle
;
8219 /* Enter a group. This creates a new lang_group_statement, and sets
8220 stat_ptr to build new statements within the group. */
8223 lang_enter_group (void)
8225 lang_group_statement_type
*g
;
8227 g
= new_stat (lang_group_statement
, stat_ptr
);
8228 lang_list_init (&g
->children
);
8229 push_stat_ptr (&g
->children
);
8232 /* Leave a group. This just resets stat_ptr to start writing to the
8233 regular list of statements again. Note that this will not work if
8234 groups can occur inside anything else which can adjust stat_ptr,
8235 but currently they can't. */
8238 lang_leave_group (void)
8243 /* Add a new program header. This is called for each entry in a PHDRS
8244 command in a linker script. */
8247 lang_new_phdr (const char *name
,
8249 bfd_boolean filehdr
,
8254 struct lang_phdr
*n
, **pp
;
8257 n
= stat_alloc (sizeof (struct lang_phdr
));
8260 n
->type
= exp_get_vma (type
, 0, "program header type");
8261 n
->filehdr
= filehdr
;
8266 hdrs
= n
->type
== 1 && (phdrs
|| filehdr
);
8268 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
8271 && !((*pp
)->filehdr
|| (*pp
)->phdrs
))
8273 einfo (_("%X%P:%pS: PHDRS and FILEHDR are not supported"
8274 " when prior PT_LOAD headers lack them\n"), NULL
);
8281 /* Record the program header information in the output BFD. FIXME: We
8282 should not be calling an ELF specific function here. */
8285 lang_record_phdrs (void)
8289 lang_output_section_phdr_list
*last
;
8290 struct lang_phdr
*l
;
8291 lang_output_section_statement_type
*os
;
8294 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
8297 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
8304 for (os
= (void *) lang_os_list
.head
;
8308 lang_output_section_phdr_list
*pl
;
8310 if (os
->constraint
< 0)
8318 if (os
->sectype
== noload_section
8319 || os
->bfd_section
== NULL
8320 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
8323 /* Don't add orphans to PT_INTERP header. */
8329 lang_output_section_statement_type
*tmp_os
;
8331 /* If we have not run across a section with a program
8332 header assigned to it yet, then scan forwards to find
8333 one. This prevents inconsistencies in the linker's
8334 behaviour when a script has specified just a single
8335 header and there are sections in that script which are
8336 not assigned to it, and which occur before the first
8337 use of that header. See here for more details:
8338 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
8339 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
8342 last
= tmp_os
->phdrs
;
8346 einfo (_("%F%P: no sections assigned to phdrs\n"));
8351 if (os
->bfd_section
== NULL
)
8354 for (; pl
!= NULL
; pl
= pl
->next
)
8356 if (strcmp (pl
->name
, l
->name
) == 0)
8361 secs
= (asection
**) xrealloc (secs
,
8362 alc
* sizeof (asection
*));
8364 secs
[c
] = os
->bfd_section
;
8371 if (l
->flags
== NULL
)
8374 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
8379 at
= exp_get_vma (l
->at
, 0, "phdr load address");
8381 if (!bfd_record_phdr (link_info
.output_bfd
, l
->type
,
8382 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
8383 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
8384 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
8389 /* Make sure all the phdr assignments succeeded. */
8390 for (os
= (void *) lang_os_list
.head
;
8394 lang_output_section_phdr_list
*pl
;
8396 if (os
->constraint
< 0
8397 || os
->bfd_section
== NULL
)
8400 for (pl
= os
->phdrs
;
8403 if (!pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
8404 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
8405 os
->name
, pl
->name
);
8409 /* Record a list of sections which may not be cross referenced. */
8412 lang_add_nocrossref (lang_nocrossref_type
*l
)
8414 struct lang_nocrossrefs
*n
;
8416 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
8417 n
->next
= nocrossref_list
;
8419 n
->onlyfirst
= FALSE
;
8420 nocrossref_list
= n
;
8422 /* Set notice_all so that we get informed about all symbols. */
8423 link_info
.notice_all
= TRUE
;
8426 /* Record a section that cannot be referenced from a list of sections. */
8429 lang_add_nocrossref_to (lang_nocrossref_type
*l
)
8431 lang_add_nocrossref (l
);
8432 nocrossref_list
->onlyfirst
= TRUE
;
8435 /* Overlay handling. We handle overlays with some static variables. */
8437 /* The overlay virtual address. */
8438 static etree_type
*overlay_vma
;
8439 /* And subsection alignment. */
8440 static etree_type
*overlay_subalign
;
8442 /* An expression for the maximum section size seen so far. */
8443 static etree_type
*overlay_max
;
8445 /* A list of all the sections in this overlay. */
8447 struct overlay_list
{
8448 struct overlay_list
*next
;
8449 lang_output_section_statement_type
*os
;
8452 static struct overlay_list
*overlay_list
;
8454 /* Start handling an overlay. */
8457 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
8459 /* The grammar should prevent nested overlays from occurring. */
8460 ASSERT (overlay_vma
== NULL
8461 && overlay_subalign
== NULL
8462 && overlay_max
== NULL
);
8464 overlay_vma
= vma_expr
;
8465 overlay_subalign
= subalign
;
8468 /* Start a section in an overlay. We handle this by calling
8469 lang_enter_output_section_statement with the correct VMA.
8470 lang_leave_overlay sets up the LMA and memory regions. */
8473 lang_enter_overlay_section (const char *name
)
8475 struct overlay_list
*n
;
8478 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
8479 0, overlay_subalign
, 0, 0, 0);
8481 /* If this is the first section, then base the VMA of future
8482 sections on this one. This will work correctly even if `.' is
8483 used in the addresses. */
8484 if (overlay_list
== NULL
)
8485 overlay_vma
= exp_nameop (ADDR
, name
);
8487 /* Remember the section. */
8488 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
8489 n
->os
= current_section
;
8490 n
->next
= overlay_list
;
8493 size
= exp_nameop (SIZEOF
, name
);
8495 /* Arrange to work out the maximum section end address. */
8496 if (overlay_max
== NULL
)
8499 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
8502 /* Finish a section in an overlay. There isn't any special to do
8506 lang_leave_overlay_section (fill_type
*fill
,
8507 lang_output_section_phdr_list
*phdrs
)
8514 name
= current_section
->name
;
8516 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
8517 region and that no load-time region has been specified. It doesn't
8518 really matter what we say here, since lang_leave_overlay will
8520 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
8522 /* Define the magic symbols. */
8524 clean
= (char *) xmalloc (strlen (name
) + 1);
8526 for (s1
= name
; *s1
!= '\0'; s1
++)
8527 if (ISALNUM (*s1
) || *s1
== '_')
8531 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_start_");
8532 sprintf (buf
, "__load_start_%s", clean
);
8533 lang_add_assignment (exp_provide (buf
,
8534 exp_nameop (LOADADDR
, name
),
8537 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_stop_");
8538 sprintf (buf
, "__load_stop_%s", clean
);
8539 lang_add_assignment (exp_provide (buf
,
8541 exp_nameop (LOADADDR
, name
),
8542 exp_nameop (SIZEOF
, name
)),
8548 /* Finish an overlay. If there are any overlay wide settings, this
8549 looks through all the sections in the overlay and sets them. */
8552 lang_leave_overlay (etree_type
*lma_expr
,
8555 const char *memspec
,
8556 lang_output_section_phdr_list
*phdrs
,
8557 const char *lma_memspec
)
8559 lang_memory_region_type
*region
;
8560 lang_memory_region_type
*lma_region
;
8561 struct overlay_list
*l
;
8562 lang_nocrossref_type
*nocrossref
;
8564 lang_get_regions (®ion
, &lma_region
,
8565 memspec
, lma_memspec
,
8566 lma_expr
!= NULL
, FALSE
);
8570 /* After setting the size of the last section, set '.' to end of the
8572 if (overlay_list
!= NULL
)
8574 overlay_list
->os
->update_dot
= 1;
8575 overlay_list
->os
->update_dot_tree
8576 = exp_assign (".", exp_binop ('+', overlay_vma
, overlay_max
), FALSE
);
8582 struct overlay_list
*next
;
8584 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
8587 l
->os
->region
= region
;
8588 l
->os
->lma_region
= lma_region
;
8590 /* The first section has the load address specified in the
8591 OVERLAY statement. The rest are worked out from that.
8592 The base address is not needed (and should be null) if
8593 an LMA region was specified. */
8596 l
->os
->load_base
= lma_expr
;
8597 l
->os
->sectype
= first_overlay_section
;
8599 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
8600 l
->os
->phdrs
= phdrs
;
8604 lang_nocrossref_type
*nc
;
8606 nc
= (lang_nocrossref_type
*) xmalloc (sizeof *nc
);
8607 nc
->name
= l
->os
->name
;
8608 nc
->next
= nocrossref
;
8617 if (nocrossref
!= NULL
)
8618 lang_add_nocrossref (nocrossref
);
8621 overlay_list
= NULL
;
8623 overlay_subalign
= NULL
;
8626 /* Version handling. This is only useful for ELF. */
8628 /* If PREV is NULL, return first version pattern matching particular symbol.
8629 If PREV is non-NULL, return first version pattern matching particular
8630 symbol after PREV (previously returned by lang_vers_match). */
8632 static struct bfd_elf_version_expr
*
8633 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
8634 struct bfd_elf_version_expr
*prev
,
8638 const char *cxx_sym
= sym
;
8639 const char *java_sym
= sym
;
8640 struct bfd_elf_version_expr
*expr
= NULL
;
8641 enum demangling_styles curr_style
;
8643 curr_style
= CURRENT_DEMANGLING_STYLE
;
8644 cplus_demangle_set_style (no_demangling
);
8645 c_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_NO_OPTS
);
8648 cplus_demangle_set_style (curr_style
);
8650 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8652 cxx_sym
= bfd_demangle (link_info
.output_bfd
, sym
,
8653 DMGL_PARAMS
| DMGL_ANSI
);
8657 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8659 java_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_JAVA
);
8664 if (head
->htab
&& (prev
== NULL
|| prev
->literal
))
8666 struct bfd_elf_version_expr e
;
8668 switch (prev
? prev
->mask
: 0)
8671 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
8674 expr
= (struct bfd_elf_version_expr
*)
8675 htab_find ((htab_t
) head
->htab
, &e
);
8676 while (expr
&& strcmp (expr
->pattern
, c_sym
) == 0)
8677 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
8683 case BFD_ELF_VERSION_C_TYPE
:
8684 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8686 e
.pattern
= cxx_sym
;
8687 expr
= (struct bfd_elf_version_expr
*)
8688 htab_find ((htab_t
) head
->htab
, &e
);
8689 while (expr
&& strcmp (expr
->pattern
, cxx_sym
) == 0)
8690 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
8696 case BFD_ELF_VERSION_CXX_TYPE
:
8697 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8699 e
.pattern
= java_sym
;
8700 expr
= (struct bfd_elf_version_expr
*)
8701 htab_find ((htab_t
) head
->htab
, &e
);
8702 while (expr
&& strcmp (expr
->pattern
, java_sym
) == 0)
8703 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8714 /* Finally, try the wildcards. */
8715 if (prev
== NULL
|| prev
->literal
)
8716 expr
= head
->remaining
;
8719 for (; expr
; expr
= expr
->next
)
8726 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
8729 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8731 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
8735 if (fnmatch (expr
->pattern
, s
, 0) == 0)
8741 free ((char *) c_sym
);
8743 free ((char *) cxx_sym
);
8744 if (java_sym
!= sym
)
8745 free ((char *) java_sym
);
8749 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
8750 return a pointer to the symbol name with any backslash quotes removed. */
8753 realsymbol (const char *pattern
)
8756 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
8757 char *s
, *symbol
= (char *) xmalloc (strlen (pattern
) + 1);
8759 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
8761 /* It is a glob pattern only if there is no preceding
8765 /* Remove the preceding backslash. */
8772 if (*p
== '?' || *p
== '*' || *p
== '[')
8779 backslash
= *p
== '\\';
8795 /* This is called for each variable name or match expression. NEW_NAME is
8796 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
8797 pattern to be matched against symbol names. */
8799 struct bfd_elf_version_expr
*
8800 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
8801 const char *new_name
,
8803 bfd_boolean literal_p
)
8805 struct bfd_elf_version_expr
*ret
;
8807 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
8811 ret
->literal
= TRUE
;
8812 ret
->pattern
= literal_p
? new_name
: realsymbol (new_name
);
8813 if (ret
->pattern
== NULL
)
8815 ret
->pattern
= new_name
;
8816 ret
->literal
= FALSE
;
8819 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
8820 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
8821 else if (strcasecmp (lang
, "C++") == 0)
8822 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
8823 else if (strcasecmp (lang
, "Java") == 0)
8824 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
8827 einfo (_("%X%P: unknown language `%s' in version information\n"),
8829 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
8832 return ldemul_new_vers_pattern (ret
);
8835 /* This is called for each set of variable names and match
8838 struct bfd_elf_version_tree
*
8839 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
8840 struct bfd_elf_version_expr
*locals
)
8842 struct bfd_elf_version_tree
*ret
;
8844 ret
= (struct bfd_elf_version_tree
*) xcalloc (1, sizeof *ret
);
8845 ret
->globals
.list
= globals
;
8846 ret
->locals
.list
= locals
;
8847 ret
->match
= lang_vers_match
;
8848 ret
->name_indx
= (unsigned int) -1;
8852 /* This static variable keeps track of version indices. */
8854 static int version_index
;
8857 version_expr_head_hash (const void *p
)
8859 const struct bfd_elf_version_expr
*e
=
8860 (const struct bfd_elf_version_expr
*) p
;
8862 return htab_hash_string (e
->pattern
);
8866 version_expr_head_eq (const void *p1
, const void *p2
)
8868 const struct bfd_elf_version_expr
*e1
=
8869 (const struct bfd_elf_version_expr
*) p1
;
8870 const struct bfd_elf_version_expr
*e2
=
8871 (const struct bfd_elf_version_expr
*) p2
;
8873 return strcmp (e1
->pattern
, e2
->pattern
) == 0;
8877 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
8880 struct bfd_elf_version_expr
*e
, *next
;
8881 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
8883 for (e
= head
->list
; e
; e
= e
->next
)
8887 head
->mask
|= e
->mask
;
8892 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
8893 version_expr_head_eq
, NULL
);
8894 list_loc
= &head
->list
;
8895 remaining_loc
= &head
->remaining
;
8896 for (e
= head
->list
; e
; e
= next
)
8902 remaining_loc
= &e
->next
;
8906 void **loc
= htab_find_slot ((htab_t
) head
->htab
, e
, INSERT
);
8910 struct bfd_elf_version_expr
*e1
, *last
;
8912 e1
= (struct bfd_elf_version_expr
*) *loc
;
8916 if (e1
->mask
== e
->mask
)
8924 while (e1
&& strcmp (e1
->pattern
, e
->pattern
) == 0);
8928 /* This is a duplicate. */
8929 /* FIXME: Memory leak. Sometimes pattern is not
8930 xmalloced alone, but in larger chunk of memory. */
8931 /* free (e->pattern); */
8936 e
->next
= last
->next
;
8944 list_loc
= &e
->next
;
8948 *remaining_loc
= NULL
;
8949 *list_loc
= head
->remaining
;
8952 head
->remaining
= head
->list
;
8955 /* This is called when we know the name and dependencies of the
8959 lang_register_vers_node (const char *name
,
8960 struct bfd_elf_version_tree
*version
,
8961 struct bfd_elf_version_deps
*deps
)
8963 struct bfd_elf_version_tree
*t
, **pp
;
8964 struct bfd_elf_version_expr
*e1
;
8969 if (link_info
.version_info
!= NULL
8970 && (name
[0] == '\0' || link_info
.version_info
->name
[0] == '\0'))
8972 einfo (_("%X%P: anonymous version tag cannot be combined"
8973 " with other version tags\n"));
8978 /* Make sure this node has a unique name. */
8979 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8980 if (strcmp (t
->name
, name
) == 0)
8981 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
8983 lang_finalize_version_expr_head (&version
->globals
);
8984 lang_finalize_version_expr_head (&version
->locals
);
8986 /* Check the global and local match names, and make sure there
8987 aren't any duplicates. */
8989 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
8991 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8993 struct bfd_elf_version_expr
*e2
;
8995 if (t
->locals
.htab
&& e1
->literal
)
8997 e2
= (struct bfd_elf_version_expr
*)
8998 htab_find ((htab_t
) t
->locals
.htab
, e1
);
8999 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
9001 if (e1
->mask
== e2
->mask
)
9002 einfo (_("%X%P: duplicate expression `%s'"
9003 " in version information\n"), e1
->pattern
);
9007 else if (!e1
->literal
)
9008 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
9009 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
9010 && e1
->mask
== e2
->mask
)
9011 einfo (_("%X%P: duplicate expression `%s'"
9012 " in version information\n"), e1
->pattern
);
9016 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
9018 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9020 struct bfd_elf_version_expr
*e2
;
9022 if (t
->globals
.htab
&& e1
->literal
)
9024 e2
= (struct bfd_elf_version_expr
*)
9025 htab_find ((htab_t
) t
->globals
.htab
, e1
);
9026 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
9028 if (e1
->mask
== e2
->mask
)
9029 einfo (_("%X%P: duplicate expression `%s'"
9030 " in version information\n"),
9035 else if (!e1
->literal
)
9036 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
9037 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
9038 && e1
->mask
== e2
->mask
)
9039 einfo (_("%X%P: duplicate expression `%s'"
9040 " in version information\n"), e1
->pattern
);
9044 version
->deps
= deps
;
9045 version
->name
= name
;
9046 if (name
[0] != '\0')
9049 version
->vernum
= version_index
;
9052 version
->vernum
= 0;
9054 for (pp
= &link_info
.version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
9059 /* This is called when we see a version dependency. */
9061 struct bfd_elf_version_deps
*
9062 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
9064 struct bfd_elf_version_deps
*ret
;
9065 struct bfd_elf_version_tree
*t
;
9067 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
9070 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9072 if (strcmp (t
->name
, name
) == 0)
9074 ret
->version_needed
= t
;
9079 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
9081 ret
->version_needed
= NULL
;
9086 lang_do_version_exports_section (void)
9088 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
9090 LANG_FOR_EACH_INPUT_STATEMENT (is
)
9092 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
9100 contents
= (char *) xmalloc (len
);
9101 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
9102 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
9105 while (p
< contents
+ len
)
9107 greg
= lang_new_vers_pattern (greg
, p
, NULL
, FALSE
);
9108 p
= strchr (p
, '\0') + 1;
9111 /* Do not free the contents, as we used them creating the regex. */
9113 /* Do not include this section in the link. */
9114 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
9117 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, FALSE
);
9118 lang_register_vers_node (command_line
.version_exports_section
,
9119 lang_new_vers_node (greg
, lreg
), NULL
);
9122 /* Evaluate LENGTH and ORIGIN parts of MEMORY spec */
9125 lang_do_memory_regions (void)
9127 lang_memory_region_type
*r
= lang_memory_region_list
;
9129 for (; r
!= NULL
; r
= r
->next
)
9133 exp_fold_tree_no_dot (r
->origin_exp
);
9134 if (expld
.result
.valid_p
)
9136 r
->origin
= expld
.result
.value
;
9137 r
->current
= r
->origin
;
9140 einfo (_("%F%P: invalid origin for memory region %s\n"),
9145 exp_fold_tree_no_dot (r
->length_exp
);
9146 if (expld
.result
.valid_p
)
9147 r
->length
= expld
.result
.value
;
9149 einfo (_("%F%P: invalid length for memory region %s\n"),
9156 lang_add_unique (const char *name
)
9158 struct unique_sections
*ent
;
9160 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
9161 if (strcmp (ent
->name
, name
) == 0)
9164 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
9165 ent
->name
= xstrdup (name
);
9166 ent
->next
= unique_section_list
;
9167 unique_section_list
= ent
;
9170 /* Append the list of dynamic symbols to the existing one. */
9173 lang_append_dynamic_list (struct bfd_elf_version_expr
*dynamic
)
9175 if (link_info
.dynamic_list
)
9177 struct bfd_elf_version_expr
*tail
;
9178 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
9180 tail
->next
= link_info
.dynamic_list
->head
.list
;
9181 link_info
.dynamic_list
->head
.list
= dynamic
;
9185 struct bfd_elf_dynamic_list
*d
;
9187 d
= (struct bfd_elf_dynamic_list
*) xcalloc (1, sizeof *d
);
9188 d
->head
.list
= dynamic
;
9189 d
->match
= lang_vers_match
;
9190 link_info
.dynamic_list
= d
;
9194 /* Append the list of C++ typeinfo dynamic symbols to the existing
9198 lang_append_dynamic_list_cpp_typeinfo (void)
9200 const char *symbols
[] =
9202 "typeinfo name for*",
9205 struct bfd_elf_version_expr
*dynamic
= NULL
;
9208 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9209 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9212 lang_append_dynamic_list (dynamic
);
9215 /* Append the list of C++ operator new and delete dynamic symbols to the
9219 lang_append_dynamic_list_cpp_new (void)
9221 const char *symbols
[] =
9226 struct bfd_elf_version_expr
*dynamic
= NULL
;
9229 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9230 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9233 lang_append_dynamic_list (dynamic
);
9236 /* Scan a space and/or comma separated string of features. */
9239 lang_ld_feature (char *str
)
9247 while (*p
== ',' || ISSPACE (*p
))
9252 while (*q
&& *q
!= ',' && !ISSPACE (*q
))
9256 if (strcasecmp (p
, "SANE_EXPR") == 0)
9257 config
.sane_expr
= TRUE
;
9259 einfo (_("%X%P: unknown feature `%s'\n"), p
);
9265 /* Pretty print memory amount. */
9268 lang_print_memory_size (bfd_vma sz
)
9270 if ((sz
& 0x3fffffff) == 0)
9271 printf ("%10" BFD_VMA_FMT
"u GB", sz
>> 30);
9272 else if ((sz
& 0xfffff) == 0)
9273 printf ("%10" BFD_VMA_FMT
"u MB", sz
>> 20);
9274 else if ((sz
& 0x3ff) == 0)
9275 printf ("%10" BFD_VMA_FMT
"u KB", sz
>> 10);
9277 printf (" %10" BFD_VMA_FMT
"u B", sz
);
9280 /* Implement --print-memory-usage: disply per region memory usage. */
9283 lang_print_memory_usage (void)
9285 lang_memory_region_type
*r
;
9287 printf ("Memory region Used Size Region Size %%age Used\n");
9288 for (r
= lang_memory_region_list
; r
->next
!= NULL
; r
= r
->next
)
9290 bfd_vma used_length
= r
->current
- r
->origin
;
9292 printf ("%16s: ",r
->name_list
.name
);
9293 lang_print_memory_size (used_length
);
9294 lang_print_memory_size ((bfd_vma
) r
->length
);
9298 double percent
= used_length
* 100.0 / r
->length
;
9299 printf (" %6.2f%%", percent
);