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
;
2543 else if (link_info
.non_contiguous_regions_warnings
)
2544 einfo (_("%P:%pS: warning: --enable-non-contiguous-regions makes "
2545 "section `%pA' from '%pB' match /DISCARD/ clause.\n"),
2546 NULL
, section
, section
->owner
);
2555 keep
= bfd_lookup_section_flags (&link_info
, sflag_info
, section
);
2560 if (section
->output_section
!= NULL
)
2562 if (!link_info
.non_contiguous_regions
)
2565 /* SECTION has already been handled in a special way
2566 (eg. LINK_ONCE): skip it. */
2567 if (bfd_is_abs_section (section
->output_section
))
2570 /* Already assigned to the same output section, do not process
2571 it again, to avoid creating loops between duplicate sections
2573 if (section
->output_section
== output
->bfd_section
)
2576 if (link_info
.non_contiguous_regions_warnings
&& output
->bfd_section
)
2577 einfo (_("%P:%pS: warning: --enable-non-contiguous-regions may "
2578 "change behaviour for section `%pA' from '%pB' (assigned to "
2579 "%pA, but additional match: %pA)\n"),
2580 NULL
, section
, section
->owner
, section
->output_section
,
2581 output
->bfd_section
);
2583 /* SECTION has already been assigned to an output section, but
2584 the user allows it to be mapped to another one in case it
2585 overflows. We'll later update the actual output section in
2586 size_input_section as appropriate. */
2589 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2590 to an output section, because we want to be able to include a
2591 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2592 section (I don't know why we want to do this, but we do).
2593 build_link_order in ldwrite.c handles this case by turning
2594 the embedded SEC_NEVER_LOAD section into a fill. */
2595 flags
&= ~ SEC_NEVER_LOAD
;
2597 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2598 already been processed. One reason to do this is that on pe
2599 format targets, .text$foo sections go into .text and it's odd
2600 to see .text with SEC_LINK_ONCE set. */
2601 if ((flags
& (SEC_LINK_ONCE
| SEC_GROUP
)) == (SEC_LINK_ONCE
| SEC_GROUP
))
2603 if (link_info
.resolve_section_groups
)
2604 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2606 flags
&= ~(SEC_LINK_DUPLICATES
| SEC_RELOC
);
2608 else if (!bfd_link_relocatable (&link_info
))
2609 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2611 switch (output
->sectype
)
2613 case normal_section
:
2614 case overlay_section
:
2615 case first_overlay_section
:
2617 case noalloc_section
:
2618 flags
&= ~SEC_ALLOC
;
2620 case noload_section
:
2622 flags
|= SEC_NEVER_LOAD
;
2623 /* Unfortunately GNU ld has managed to evolve two different
2624 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2625 alloc, no contents section. All others get a noload, noalloc
2627 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
2628 flags
&= ~SEC_HAS_CONTENTS
;
2630 flags
&= ~SEC_ALLOC
;
2634 if (output
->bfd_section
== NULL
)
2635 init_os (output
, flags
);
2637 /* If SEC_READONLY is not set in the input section, then clear
2638 it from the output section. */
2639 output
->bfd_section
->flags
&= flags
| ~SEC_READONLY
;
2641 if (output
->bfd_section
->linker_has_input
)
2643 /* Only set SEC_READONLY flag on the first input section. */
2644 flags
&= ~ SEC_READONLY
;
2646 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2647 if ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2648 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2649 || ((flags
& SEC_MERGE
) != 0
2650 && output
->bfd_section
->entsize
!= section
->entsize
))
2652 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2653 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2656 output
->bfd_section
->flags
|= flags
;
2658 if (!output
->bfd_section
->linker_has_input
)
2660 output
->bfd_section
->linker_has_input
= 1;
2661 /* This must happen after flags have been updated. The output
2662 section may have been created before we saw its first input
2663 section, eg. for a data statement. */
2664 bfd_init_private_section_data (section
->owner
, section
,
2665 link_info
.output_bfd
,
2666 output
->bfd_section
,
2668 if ((flags
& SEC_MERGE
) != 0)
2669 output
->bfd_section
->entsize
= section
->entsize
;
2672 if ((flags
& SEC_TIC54X_BLOCK
) != 0
2673 && bfd_get_arch (section
->owner
) == bfd_arch_tic54x
)
2675 /* FIXME: This value should really be obtained from the bfd... */
2676 output
->block_value
= 128;
2679 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2680 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2682 section
->output_section
= output
->bfd_section
;
2684 if (!map_head_is_link_order
)
2686 asection
*s
= output
->bfd_section
->map_tail
.s
;
2687 output
->bfd_section
->map_tail
.s
= section
;
2688 section
->map_head
.s
= NULL
;
2689 section
->map_tail
.s
= s
;
2691 s
->map_head
.s
= section
;
2693 output
->bfd_section
->map_head
.s
= section
;
2696 /* Add a section reference to the list. */
2697 new_section
= new_stat (lang_input_section
, ptr
);
2698 new_section
->section
= section
;
2701 /* Handle wildcard sorting. This returns the lang_input_section which
2702 should follow the one we are going to create for SECTION and FILE,
2703 based on the sorting requirements of WILD. It returns NULL if the
2704 new section should just go at the end of the current list. */
2706 static lang_statement_union_type
*
2707 wild_sort (lang_wild_statement_type
*wild
,
2708 struct wildcard_list
*sec
,
2709 lang_input_statement_type
*file
,
2712 lang_statement_union_type
*l
;
2714 if (!wild
->filenames_sorted
2715 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
2718 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
2720 lang_input_section_type
*ls
;
2722 if (l
->header
.type
!= lang_input_section_enum
)
2724 ls
= &l
->input_section
;
2726 /* Sorting by filename takes precedence over sorting by section
2729 if (wild
->filenames_sorted
)
2731 const char *fn
, *ln
;
2735 /* The PE support for the .idata section as generated by
2736 dlltool assumes that files will be sorted by the name of
2737 the archive and then the name of the file within the
2740 if (file
->the_bfd
!= NULL
2741 && file
->the_bfd
->my_archive
!= NULL
)
2743 fn
= bfd_get_filename (file
->the_bfd
->my_archive
);
2748 fn
= file
->filename
;
2752 if (ls
->section
->owner
->my_archive
!= NULL
)
2754 ln
= bfd_get_filename (ls
->section
->owner
->my_archive
);
2759 ln
= ls
->section
->owner
->filename
;
2763 i
= filename_cmp (fn
, ln
);
2772 fn
= file
->filename
;
2774 ln
= ls
->section
->owner
->filename
;
2776 i
= filename_cmp (fn
, ln
);
2784 /* Here either the files are not sorted by name, or we are
2785 looking at the sections for this file. */
2788 && sec
->spec
.sorted
!= none
2789 && sec
->spec
.sorted
!= by_none
)
2790 if (compare_section (sec
->spec
.sorted
, section
, ls
->section
) < 0)
2797 /* Expand a wild statement for a particular FILE. SECTION may be
2798 NULL, in which case it is a wild card. */
2801 output_section_callback (lang_wild_statement_type
*ptr
,
2802 struct wildcard_list
*sec
,
2804 struct flag_info
*sflag_info
,
2805 lang_input_statement_type
*file
,
2808 lang_statement_union_type
*before
;
2809 lang_output_section_statement_type
*os
;
2811 os
= (lang_output_section_statement_type
*) output
;
2813 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2814 if (unique_section_p (section
, os
))
2817 before
= wild_sort (ptr
, sec
, file
, section
);
2819 /* Here BEFORE points to the lang_input_section which
2820 should follow the one we are about to add. If BEFORE
2821 is NULL, then the section should just go at the end
2822 of the current list. */
2825 lang_add_section (&ptr
->children
, section
, sflag_info
, os
);
2828 lang_statement_list_type list
;
2829 lang_statement_union_type
**pp
;
2831 lang_list_init (&list
);
2832 lang_add_section (&list
, section
, sflag_info
, os
);
2834 /* If we are discarding the section, LIST.HEAD will
2836 if (list
.head
!= NULL
)
2838 ASSERT (list
.head
->header
.next
== NULL
);
2840 for (pp
= &ptr
->children
.head
;
2842 pp
= &(*pp
)->header
.next
)
2843 ASSERT (*pp
!= NULL
);
2845 list
.head
->header
.next
= *pp
;
2851 /* Check if all sections in a wild statement for a particular FILE
2855 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2856 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2858 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
2859 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2862 lang_output_section_statement_type
*os
;
2864 os
= (lang_output_section_statement_type
*) output
;
2866 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2867 if (unique_section_p (section
, os
))
2870 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2871 os
->all_input_readonly
= FALSE
;
2874 /* This is passed a file name which must have been seen already and
2875 added to the statement tree. We will see if it has been opened
2876 already and had its symbols read. If not then we'll read it. */
2878 static lang_input_statement_type
*
2879 lookup_name (const char *name
)
2881 lang_input_statement_type
*search
;
2883 for (search
= (void *) input_file_chain
.head
;
2885 search
= search
->next_real_file
)
2887 /* Use the local_sym_name as the name of the file that has
2888 already been loaded as filename might have been transformed
2889 via the search directory lookup mechanism. */
2890 const char *filename
= search
->local_sym_name
;
2892 if (filename
!= NULL
2893 && filename_cmp (filename
, name
) == 0)
2899 /* Arrange to splice the input statement added by new_afile into
2900 statement_list after the current input_file_chain tail.
2901 We know input_file_chain is not an empty list, and that
2902 lookup_name was called via open_input_bfds. Later calls to
2903 lookup_name should always match an existing input_statement. */
2904 lang_statement_union_type
**tail
= stat_ptr
->tail
;
2905 lang_statement_union_type
**after
2906 = (void *) ((char *) input_file_chain
.tail
2907 - offsetof (lang_input_statement_type
, next_real_file
)
2908 + offsetof (lang_input_statement_type
, header
.next
));
2909 lang_statement_union_type
*rest
= *after
;
2910 stat_ptr
->tail
= after
;
2911 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2913 *stat_ptr
->tail
= rest
;
2915 stat_ptr
->tail
= tail
;
2918 /* If we have already added this file, or this file is not real
2919 don't add this file. */
2920 if (search
->flags
.loaded
|| !search
->flags
.real
)
2923 if (!load_symbols (search
, NULL
))
2929 /* Save LIST as a list of libraries whose symbols should not be exported. */
2934 struct excluded_lib
*next
;
2936 static struct excluded_lib
*excluded_libs
;
2939 add_excluded_libs (const char *list
)
2941 const char *p
= list
, *end
;
2945 struct excluded_lib
*entry
;
2946 end
= strpbrk (p
, ",:");
2948 end
= p
+ strlen (p
);
2949 entry
= (struct excluded_lib
*) xmalloc (sizeof (*entry
));
2950 entry
->next
= excluded_libs
;
2951 entry
->name
= (char *) xmalloc (end
- p
+ 1);
2952 memcpy (entry
->name
, p
, end
- p
);
2953 entry
->name
[end
- p
] = '\0';
2954 excluded_libs
= entry
;
2962 check_excluded_libs (bfd
*abfd
)
2964 struct excluded_lib
*lib
= excluded_libs
;
2968 int len
= strlen (lib
->name
);
2969 const char *filename
= lbasename (abfd
->filename
);
2971 if (strcmp (lib
->name
, "ALL") == 0)
2973 abfd
->no_export
= TRUE
;
2977 if (filename_ncmp (lib
->name
, filename
, len
) == 0
2978 && (filename
[len
] == '\0'
2979 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
2980 && filename
[len
+ 2] == '\0')))
2982 abfd
->no_export
= TRUE
;
2990 /* Get the symbols for an input file. */
2993 load_symbols (lang_input_statement_type
*entry
,
2994 lang_statement_list_type
*place
)
2998 if (entry
->flags
.loaded
)
3001 ldfile_open_file (entry
);
3003 /* Do not process further if the file was missing. */
3004 if (entry
->flags
.missing_file
)
3007 if (trace_files
|| verbose
)
3008 info_msg ("%pI\n", entry
);
3010 if (!bfd_check_format (entry
->the_bfd
, bfd_archive
)
3011 && !bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
3014 struct lang_input_statement_flags save_flags
;
3017 err
= bfd_get_error ();
3019 /* See if the emulation has some special knowledge. */
3020 if (ldemul_unrecognized_file (entry
))
3023 if (err
== bfd_error_file_ambiguously_recognized
)
3027 einfo (_("%P: %pB: file not recognized: %E;"
3028 " matching formats:"), entry
->the_bfd
);
3029 for (p
= matching
; *p
!= NULL
; p
++)
3033 else if (err
!= bfd_error_file_not_recognized
3035 einfo (_("%F%P: %pB: file not recognized: %E\n"), entry
->the_bfd
);
3037 bfd_close (entry
->the_bfd
);
3038 entry
->the_bfd
= NULL
;
3040 /* Try to interpret the file as a linker script. */
3041 save_flags
= input_flags
;
3042 ldfile_open_command_file (entry
->filename
);
3044 push_stat_ptr (place
);
3045 input_flags
.add_DT_NEEDED_for_regular
3046 = entry
->flags
.add_DT_NEEDED_for_regular
;
3047 input_flags
.add_DT_NEEDED_for_dynamic
3048 = entry
->flags
.add_DT_NEEDED_for_dynamic
;
3049 input_flags
.whole_archive
= entry
->flags
.whole_archive
;
3050 input_flags
.dynamic
= entry
->flags
.dynamic
;
3052 ldfile_assumed_script
= TRUE
;
3053 parser_input
= input_script
;
3055 ldfile_assumed_script
= FALSE
;
3057 /* missing_file is sticky. sysrooted will already have been
3058 restored when seeing EOF in yyparse, but no harm to restore
3060 save_flags
.missing_file
|= input_flags
.missing_file
;
3061 input_flags
= save_flags
;
3065 entry
->flags
.loaded
= TRUE
;
3070 if (ldemul_recognized_file (entry
))
3073 /* We don't call ldlang_add_file for an archive. Instead, the
3074 add_symbols entry point will call ldlang_add_file, via the
3075 add_archive_element callback, for each element of the archive
3077 switch (bfd_get_format (entry
->the_bfd
))
3083 if (!entry
->flags
.reload
)
3084 ldlang_add_file (entry
);
3088 check_excluded_libs (entry
->the_bfd
);
3090 bfd_set_usrdata (entry
->the_bfd
, entry
);
3091 if (entry
->flags
.whole_archive
)
3094 bfd_boolean loaded
= TRUE
;
3099 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
3104 if (!bfd_check_format (member
, bfd_object
))
3106 einfo (_("%F%P: %pB: member %pB in archive is not an object\n"),
3107 entry
->the_bfd
, member
);
3112 if (!(*link_info
.callbacks
3113 ->add_archive_element
) (&link_info
, member
,
3114 "--whole-archive", &subsbfd
))
3117 /* Potentially, the add_archive_element hook may have set a
3118 substitute BFD for us. */
3119 if (!bfd_link_add_symbols (subsbfd
, &link_info
))
3121 einfo (_("%F%P: %pB: error adding symbols: %E\n"), member
);
3126 entry
->flags
.loaded
= loaded
;
3132 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
3133 entry
->flags
.loaded
= TRUE
;
3135 einfo (_("%F%P: %pB: error adding symbols: %E\n"), entry
->the_bfd
);
3137 return entry
->flags
.loaded
;
3140 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
3141 may be NULL, indicating that it is a wildcard. Separate
3142 lang_input_section statements are created for each part of the
3143 expansion; they are added after the wild statement S. OUTPUT is
3144 the output section. */
3147 wild (lang_wild_statement_type
*s
,
3148 const char *target ATTRIBUTE_UNUSED
,
3149 lang_output_section_statement_type
*output
)
3151 struct wildcard_list
*sec
;
3153 if (s
->handler_data
[0]
3154 && s
->handler_data
[0]->spec
.sorted
== by_name
3155 && !s
->filenames_sorted
)
3157 lang_section_bst_type
*tree
;
3159 walk_wild (s
, output_section_callback_fast
, output
);
3164 output_section_callback_tree_to_list (s
, tree
, output
);
3169 walk_wild (s
, output_section_callback
, output
);
3171 if (default_common_section
== NULL
)
3172 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
3173 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
3175 /* Remember the section that common is going to in case we
3176 later get something which doesn't know where to put it. */
3177 default_common_section
= output
;
3182 /* Return TRUE iff target is the sought target. */
3185 get_target (const bfd_target
*target
, void *data
)
3187 const char *sought
= (const char *) data
;
3189 return strcmp (target
->name
, sought
) == 0;
3192 /* Like strcpy() but convert to lower case as well. */
3195 stricpy (char *dest
, const char *src
)
3199 while ((c
= *src
++) != 0)
3200 *dest
++ = TOLOWER (c
);
3205 /* Remove the first occurrence of needle (if any) in haystack
3209 strcut (char *haystack
, const char *needle
)
3211 haystack
= strstr (haystack
, needle
);
3217 for (src
= haystack
+ strlen (needle
); *src
;)
3218 *haystack
++ = *src
++;
3224 /* Compare two target format name strings.
3225 Return a value indicating how "similar" they are. */
3228 name_compare (const char *first
, const char *second
)
3234 copy1
= (char *) xmalloc (strlen (first
) + 1);
3235 copy2
= (char *) xmalloc (strlen (second
) + 1);
3237 /* Convert the names to lower case. */
3238 stricpy (copy1
, first
);
3239 stricpy (copy2
, second
);
3241 /* Remove size and endian strings from the name. */
3242 strcut (copy1
, "big");
3243 strcut (copy1
, "little");
3244 strcut (copy2
, "big");
3245 strcut (copy2
, "little");
3247 /* Return a value based on how many characters match,
3248 starting from the beginning. If both strings are
3249 the same then return 10 * their length. */
3250 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
3251 if (copy1
[result
] == 0)
3263 /* Set by closest_target_match() below. */
3264 static const bfd_target
*winner
;
3266 /* Scan all the valid bfd targets looking for one that has the endianness
3267 requirement that was specified on the command line, and is the nearest
3268 match to the original output target. */
3271 closest_target_match (const bfd_target
*target
, void *data
)
3273 const bfd_target
*original
= (const bfd_target
*) data
;
3275 if (command_line
.endian
== ENDIAN_BIG
3276 && target
->byteorder
!= BFD_ENDIAN_BIG
)
3279 if (command_line
.endian
== ENDIAN_LITTLE
3280 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
3283 /* Must be the same flavour. */
3284 if (target
->flavour
!= original
->flavour
)
3287 /* Ignore generic big and little endian elf vectors. */
3288 if (strcmp (target
->name
, "elf32-big") == 0
3289 || strcmp (target
->name
, "elf64-big") == 0
3290 || strcmp (target
->name
, "elf32-little") == 0
3291 || strcmp (target
->name
, "elf64-little") == 0)
3294 /* If we have not found a potential winner yet, then record this one. */
3301 /* Oh dear, we now have two potential candidates for a successful match.
3302 Compare their names and choose the better one. */
3303 if (name_compare (target
->name
, original
->name
)
3304 > name_compare (winner
->name
, original
->name
))
3307 /* Keep on searching until wqe have checked them all. */
3311 /* Return the BFD target format of the first input file. */
3314 get_first_input_target (void)
3316 const char *target
= NULL
;
3318 LANG_FOR_EACH_INPUT_STATEMENT (s
)
3320 if (s
->header
.type
== lang_input_statement_enum
3323 ldfile_open_file (s
);
3325 if (s
->the_bfd
!= NULL
3326 && bfd_check_format (s
->the_bfd
, bfd_object
))
3328 target
= bfd_get_target (s
->the_bfd
);
3340 lang_get_output_target (void)
3344 /* Has the user told us which output format to use? */
3345 if (output_target
!= NULL
)
3346 return output_target
;
3348 /* No - has the current target been set to something other than
3350 if (current_target
!= default_target
&& current_target
!= NULL
)
3351 return current_target
;
3353 /* No - can we determine the format of the first input file? */
3354 target
= get_first_input_target ();
3358 /* Failed - use the default output target. */
3359 return default_target
;
3362 /* Open the output file. */
3365 open_output (const char *name
)
3367 output_target
= lang_get_output_target ();
3369 /* Has the user requested a particular endianness on the command
3371 if (command_line
.endian
!= ENDIAN_UNSET
)
3373 /* Get the chosen target. */
3374 const bfd_target
*target
3375 = bfd_iterate_over_targets (get_target
, (void *) output_target
);
3377 /* If the target is not supported, we cannot do anything. */
3380 enum bfd_endian desired_endian
;
3382 if (command_line
.endian
== ENDIAN_BIG
)
3383 desired_endian
= BFD_ENDIAN_BIG
;
3385 desired_endian
= BFD_ENDIAN_LITTLE
;
3387 /* See if the target has the wrong endianness. This should
3388 not happen if the linker script has provided big and
3389 little endian alternatives, but some scrips don't do
3391 if (target
->byteorder
!= desired_endian
)
3393 /* If it does, then see if the target provides
3394 an alternative with the correct endianness. */
3395 if (target
->alternative_target
!= NULL
3396 && (target
->alternative_target
->byteorder
== desired_endian
))
3397 output_target
= target
->alternative_target
->name
;
3400 /* Try to find a target as similar as possible to
3401 the default target, but which has the desired
3402 endian characteristic. */
3403 bfd_iterate_over_targets (closest_target_match
,
3406 /* Oh dear - we could not find any targets that
3407 satisfy our requirements. */
3409 einfo (_("%P: warning: could not find any targets"
3410 " that match endianness requirement\n"));
3412 output_target
= winner
->name
;
3418 link_info
.output_bfd
= bfd_openw (name
, output_target
);
3420 if (link_info
.output_bfd
== NULL
)
3422 if (bfd_get_error () == bfd_error_invalid_target
)
3423 einfo (_("%F%P: target %s not found\n"), output_target
);
3425 einfo (_("%F%P: cannot open output file %s: %E\n"), name
);
3428 delete_output_file_on_failure
= TRUE
;
3430 if (!bfd_set_format (link_info
.output_bfd
, bfd_object
))
3431 einfo (_("%F%P: %s: can not make object file: %E\n"), name
);
3432 if (!bfd_set_arch_mach (link_info
.output_bfd
,
3433 ldfile_output_architecture
,
3434 ldfile_output_machine
))
3435 einfo (_("%F%P: %s: can not set architecture: %E\n"), name
);
3437 link_info
.hash
= bfd_link_hash_table_create (link_info
.output_bfd
);
3438 if (link_info
.hash
== NULL
)
3439 einfo (_("%F%P: can not create hash table: %E\n"));
3441 bfd_set_gp_size (link_info
.output_bfd
, g_switch_value
);
3445 ldlang_open_output (lang_statement_union_type
*statement
)
3447 switch (statement
->header
.type
)
3449 case lang_output_statement_enum
:
3450 ASSERT (link_info
.output_bfd
== NULL
);
3451 open_output (statement
->output_statement
.name
);
3452 ldemul_set_output_arch ();
3453 if (config
.magic_demand_paged
3454 && !bfd_link_relocatable (&link_info
))
3455 link_info
.output_bfd
->flags
|= D_PAGED
;
3457 link_info
.output_bfd
->flags
&= ~D_PAGED
;
3458 if (config
.text_read_only
)
3459 link_info
.output_bfd
->flags
|= WP_TEXT
;
3461 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
3462 if (link_info
.traditional_format
)
3463 link_info
.output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
3465 link_info
.output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
3468 case lang_target_statement_enum
:
3469 current_target
= statement
->target_statement
.target
;
3477 init_opb (asection
*s
)
3482 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
3484 && (s
->flags
& SEC_ELF_OCTETS
) != 0)
3487 x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3488 ldfile_output_machine
);
3490 while ((x
& 1) == 0)
3498 /* Open all the input files. */
3502 OPEN_BFD_NORMAL
= 0,
3506 #ifdef ENABLE_PLUGINS
3507 static lang_input_statement_type
*plugin_insert
= NULL
;
3508 static struct bfd_link_hash_entry
*plugin_undefs
= NULL
;
3512 open_input_bfds (lang_statement_union_type
*s
, enum open_bfd_mode mode
)
3514 for (; s
!= NULL
; s
= s
->header
.next
)
3516 switch (s
->header
.type
)
3518 case lang_constructors_statement_enum
:
3519 open_input_bfds (constructor_list
.head
, mode
);
3521 case lang_output_section_statement_enum
:
3522 open_input_bfds (s
->output_section_statement
.children
.head
, mode
);
3524 case lang_wild_statement_enum
:
3525 /* Maybe we should load the file's symbols. */
3526 if ((mode
& OPEN_BFD_RESCAN
) == 0
3527 && s
->wild_statement
.filename
3528 && !wildcardp (s
->wild_statement
.filename
)
3529 && !archive_path (s
->wild_statement
.filename
))
3530 lookup_name (s
->wild_statement
.filename
);
3531 open_input_bfds (s
->wild_statement
.children
.head
, mode
);
3533 case lang_group_statement_enum
:
3535 struct bfd_link_hash_entry
*undefs
;
3536 #ifdef ENABLE_PLUGINS
3537 lang_input_statement_type
*plugin_insert_save
;
3540 /* We must continually search the entries in the group
3541 until no new symbols are added to the list of undefined
3546 #ifdef ENABLE_PLUGINS
3547 plugin_insert_save
= plugin_insert
;
3549 undefs
= link_info
.hash
->undefs_tail
;
3550 open_input_bfds (s
->group_statement
.children
.head
,
3551 mode
| OPEN_BFD_FORCE
);
3553 while (undefs
!= link_info
.hash
->undefs_tail
3554 #ifdef ENABLE_PLUGINS
3555 /* Objects inserted by a plugin, which are loaded
3556 before we hit this loop, may have added new
3558 || (plugin_insert
!= plugin_insert_save
&& plugin_undefs
)
3563 case lang_target_statement_enum
:
3564 current_target
= s
->target_statement
.target
;
3566 case lang_input_statement_enum
:
3567 if (s
->input_statement
.flags
.real
)
3569 lang_statement_union_type
**os_tail
;
3570 lang_statement_list_type add
;
3573 s
->input_statement
.target
= current_target
;
3575 /* If we are being called from within a group, and this
3576 is an archive which has already been searched, then
3577 force it to be researched unless the whole archive
3578 has been loaded already. Do the same for a rescan.
3579 Likewise reload --as-needed shared libs. */
3580 if (mode
!= OPEN_BFD_NORMAL
3581 #ifdef ENABLE_PLUGINS
3582 && ((mode
& OPEN_BFD_RESCAN
) == 0
3583 || plugin_insert
== NULL
)
3585 && s
->input_statement
.flags
.loaded
3586 && (abfd
= s
->input_statement
.the_bfd
) != NULL
3587 && ((bfd_get_format (abfd
) == bfd_archive
3588 && !s
->input_statement
.flags
.whole_archive
)
3589 || (bfd_get_format (abfd
) == bfd_object
3590 && ((abfd
->flags
) & DYNAMIC
) != 0
3591 && s
->input_statement
.flags
.add_DT_NEEDED_for_regular
3592 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3593 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)))
3595 s
->input_statement
.flags
.loaded
= FALSE
;
3596 s
->input_statement
.flags
.reload
= TRUE
;
3599 os_tail
= lang_os_list
.tail
;
3600 lang_list_init (&add
);
3602 if (!load_symbols (&s
->input_statement
, &add
))
3603 config
.make_executable
= FALSE
;
3605 if (add
.head
!= NULL
)
3607 /* If this was a script with output sections then
3608 tack any added statements on to the end of the
3609 list. This avoids having to reorder the output
3610 section statement list. Very likely the user
3611 forgot -T, and whatever we do here will not meet
3612 naive user expectations. */
3613 if (os_tail
!= lang_os_list
.tail
)
3615 einfo (_("%P: warning: %s contains output sections;"
3616 " did you forget -T?\n"),
3617 s
->input_statement
.filename
);
3618 *stat_ptr
->tail
= add
.head
;
3619 stat_ptr
->tail
= add
.tail
;
3623 *add
.tail
= s
->header
.next
;
3624 s
->header
.next
= add
.head
;
3628 #ifdef ENABLE_PLUGINS
3629 /* If we have found the point at which a plugin added new
3630 files, clear plugin_insert to enable archive rescan. */
3631 if (&s
->input_statement
== plugin_insert
)
3632 plugin_insert
= NULL
;
3635 case lang_assignment_statement_enum
:
3636 if (s
->assignment_statement
.exp
->type
.node_class
!= etree_assert
)
3637 exp_fold_tree_no_dot (s
->assignment_statement
.exp
);
3644 /* Exit if any of the files were missing. */
3645 if (input_flags
.missing_file
)
3649 /* Open the CTF sections in the input files with libctf: if any were opened,
3650 create a fake input file that we'll write the merged CTF data to later
3654 ldlang_open_ctf (void)
3659 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3663 /* Incoming files from the compiler have a single ctf_file_t in them
3664 (which is presented to us by the libctf API in a ctf_archive_t
3665 wrapper): files derived from a previous relocatable link have a CTF
3666 archive containing possibly many CTF files. */
3668 if ((file
->the_ctf
= ctf_bfdopen (file
->the_bfd
, &err
)) == NULL
)
3670 if (err
!= ECTF_NOCTFDATA
)
3671 einfo (_("%P: warning: CTF section in `%pI' not loaded: "
3672 "its types will be discarded: `%s'\n"), file
,
3677 /* Prevent the contents of this section from being written, while
3678 requiring the section itself to be duplicated in the output. */
3679 /* This section must exist if ctf_bfdopen() succeeded. */
3680 sect
= bfd_get_section_by_name (file
->the_bfd
, ".ctf");
3682 sect
->flags
|= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
| SEC_LINKER_CREATED
;
3693 if ((ctf_output
= ctf_create (&err
)) != NULL
)
3696 einfo (_("%P: warning: CTF output not created: `%s'\n"),
3699 LANG_FOR_EACH_INPUT_STATEMENT (errfile
)
3700 ctf_close (errfile
->the_ctf
);
3703 /* Merge together CTF sections. After this, only the symtab-dependent
3704 function and data object sections need adjustment. */
3707 lang_merge_ctf (void)
3709 asection
*output_sect
;
3714 output_sect
= bfd_get_section_by_name (link_info
.output_bfd
, ".ctf");
3716 /* If the section was discarded, don't waste time merging. */
3717 if (output_sect
== NULL
)
3719 ctf_file_close (ctf_output
);
3722 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3724 ctf_close (file
->the_ctf
);
3725 file
->the_ctf
= NULL
;
3730 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3735 /* Takes ownership of file->u.the_ctfa. */
3736 if (ctf_link_add_ctf (ctf_output
, file
->the_ctf
, file
->filename
) < 0)
3738 einfo (_("%F%P: cannot link with CTF in %pB: %s\n"), file
->the_bfd
,
3739 ctf_errmsg (ctf_errno (ctf_output
)));
3740 ctf_close (file
->the_ctf
);
3741 file
->the_ctf
= NULL
;
3746 if (ctf_link (ctf_output
, CTF_LINK_SHARE_UNCONFLICTED
) < 0)
3748 einfo (_("%F%P: CTF linking failed; output will have no CTF section: %s\n"),
3749 ctf_errmsg (ctf_errno (ctf_output
)));
3752 output_sect
->size
= 0;
3753 output_sect
->flags
|= SEC_EXCLUDE
;
3758 /* Let the emulation examine the symbol table and strtab to help it optimize the
3759 CTF, if supported. */
3762 ldlang_ctf_apply_strsym (struct elf_sym_strtab
*syms
, bfd_size_type symcount
,
3763 struct elf_strtab_hash
*symstrtab
)
3765 ldemul_examine_strtab_for_ctf (ctf_output
, syms
, symcount
, symstrtab
);
3768 /* Write out the CTF section. Called early, if the emulation isn't going to
3769 need to dedup against the strtab and symtab, then possibly called from the
3770 target linker code if the dedup has happened. */
3772 lang_write_ctf (int late
)
3775 asection
*output_sect
;
3782 /* Emit CTF late if this emulation says it can do so. */
3783 if (ldemul_emit_ctf_early ())
3788 if (!ldemul_emit_ctf_early ())
3794 output_sect
= bfd_get_section_by_name (link_info
.output_bfd
, ".ctf");
3797 output_sect
->contents
= ctf_link_write (ctf_output
, &output_size
,
3798 CTF_COMPRESSION_THRESHOLD
);
3799 output_sect
->size
= output_size
;
3800 output_sect
->flags
|= SEC_IN_MEMORY
| SEC_KEEP
;
3802 if (!output_sect
->contents
)
3804 einfo (_("%F%P: CTF section emission failed; output will have no "
3805 "CTF section: %s\n"), ctf_errmsg (ctf_errno (ctf_output
)));
3806 output_sect
->size
= 0;
3807 output_sect
->flags
|= SEC_EXCLUDE
;
3811 /* This also closes every CTF input file used in the link. */
3812 ctf_file_close (ctf_output
);
3815 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3816 file
->the_ctf
= NULL
;
3819 /* Write out the CTF section late, if the emulation needs that. */
3822 ldlang_write_ctf_late (void)
3824 /* Trigger a "late call", if the emulation needs one. */
3829 /* Add the supplied name to the symbol table as an undefined reference.
3830 This is a two step process as the symbol table doesn't even exist at
3831 the time the ld command line is processed. First we put the name
3832 on a list, then, once the output file has been opened, transfer the
3833 name to the symbol table. */
3835 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3837 #define ldlang_undef_chain_list_head entry_symbol.next
3840 ldlang_add_undef (const char *const name
, bfd_boolean cmdline
)
3842 ldlang_undef_chain_list_type
*new_undef
;
3844 undef_from_cmdline
= undef_from_cmdline
|| cmdline
;
3845 new_undef
= stat_alloc (sizeof (*new_undef
));
3846 new_undef
->next
= ldlang_undef_chain_list_head
;
3847 ldlang_undef_chain_list_head
= new_undef
;
3849 new_undef
->name
= xstrdup (name
);
3851 if (link_info
.output_bfd
!= NULL
)
3852 insert_undefined (new_undef
->name
);
3855 /* Insert NAME as undefined in the symbol table. */
3858 insert_undefined (const char *name
)
3860 struct bfd_link_hash_entry
*h
;
3862 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
3864 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
3865 if (h
->type
== bfd_link_hash_new
)
3867 h
->type
= bfd_link_hash_undefined
;
3868 h
->u
.undef
.abfd
= NULL
;
3869 h
->non_ir_ref_regular
= TRUE
;
3870 if (is_elf_hash_table (link_info
.hash
))
3871 ((struct elf_link_hash_entry
*) h
)->mark
= 1;
3872 bfd_link_add_undef (link_info
.hash
, h
);
3876 /* Run through the list of undefineds created above and place them
3877 into the linker hash table as undefined symbols belonging to the
3881 lang_place_undefineds (void)
3883 ldlang_undef_chain_list_type
*ptr
;
3885 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3886 insert_undefined (ptr
->name
);
3889 /* Structure used to build the list of symbols that the user has required
3892 struct require_defined_symbol
3895 struct require_defined_symbol
*next
;
3898 /* The list of symbols that the user has required be defined. */
3900 static struct require_defined_symbol
*require_defined_symbol_list
;
3902 /* Add a new symbol NAME to the list of symbols that are required to be
3906 ldlang_add_require_defined (const char *const name
)
3908 struct require_defined_symbol
*ptr
;
3910 ldlang_add_undef (name
, TRUE
);
3911 ptr
= stat_alloc (sizeof (*ptr
));
3912 ptr
->next
= require_defined_symbol_list
;
3913 ptr
->name
= strdup (name
);
3914 require_defined_symbol_list
= ptr
;
3917 /* Check that all symbols the user required to be defined, are defined,
3918 raise an error if we find a symbol that is not defined. */
3921 ldlang_check_require_defined_symbols (void)
3923 struct require_defined_symbol
*ptr
;
3925 for (ptr
= require_defined_symbol_list
; ptr
!= NULL
; ptr
= ptr
->next
)
3927 struct bfd_link_hash_entry
*h
;
3929 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
,
3930 FALSE
, FALSE
, TRUE
);
3932 || (h
->type
!= bfd_link_hash_defined
3933 && h
->type
!= bfd_link_hash_defweak
))
3934 einfo(_("%X%P: required symbol `%s' not defined\n"), ptr
->name
);
3938 /* Check for all readonly or some readwrite sections. */
3941 check_input_sections
3942 (lang_statement_union_type
*s
,
3943 lang_output_section_statement_type
*output_section_statement
)
3945 for (; s
!= NULL
; s
= s
->header
.next
)
3947 switch (s
->header
.type
)
3949 case lang_wild_statement_enum
:
3950 walk_wild (&s
->wild_statement
, check_section_callback
,
3951 output_section_statement
);
3952 if (!output_section_statement
->all_input_readonly
)
3955 case lang_constructors_statement_enum
:
3956 check_input_sections (constructor_list
.head
,
3957 output_section_statement
);
3958 if (!output_section_statement
->all_input_readonly
)
3961 case lang_group_statement_enum
:
3962 check_input_sections (s
->group_statement
.children
.head
,
3963 output_section_statement
);
3964 if (!output_section_statement
->all_input_readonly
)
3973 /* Update wildcard statements if needed. */
3976 update_wild_statements (lang_statement_union_type
*s
)
3978 struct wildcard_list
*sec
;
3980 switch (sort_section
)
3990 for (; s
!= NULL
; s
= s
->header
.next
)
3992 switch (s
->header
.type
)
3997 case lang_wild_statement_enum
:
3998 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
4000 /* Don't sort .init/.fini sections. */
4001 if (strcmp (sec
->spec
.name
, ".init") != 0
4002 && strcmp (sec
->spec
.name
, ".fini") != 0)
4003 switch (sec
->spec
.sorted
)
4006 sec
->spec
.sorted
= sort_section
;
4009 if (sort_section
== by_alignment
)
4010 sec
->spec
.sorted
= by_name_alignment
;
4013 if (sort_section
== by_name
)
4014 sec
->spec
.sorted
= by_alignment_name
;
4021 case lang_constructors_statement_enum
:
4022 update_wild_statements (constructor_list
.head
);
4025 case lang_output_section_statement_enum
:
4026 update_wild_statements
4027 (s
->output_section_statement
.children
.head
);
4030 case lang_group_statement_enum
:
4031 update_wild_statements (s
->group_statement
.children
.head
);
4039 /* Open input files and attach to output sections. */
4042 map_input_to_output_sections
4043 (lang_statement_union_type
*s
, const char *target
,
4044 lang_output_section_statement_type
*os
)
4046 for (; s
!= NULL
; s
= s
->header
.next
)
4048 lang_output_section_statement_type
*tos
;
4051 switch (s
->header
.type
)
4053 case lang_wild_statement_enum
:
4054 wild (&s
->wild_statement
, target
, os
);
4056 case lang_constructors_statement_enum
:
4057 map_input_to_output_sections (constructor_list
.head
,
4061 case lang_output_section_statement_enum
:
4062 tos
= &s
->output_section_statement
;
4063 if (tos
->constraint
!= 0)
4065 if (tos
->constraint
!= ONLY_IF_RW
4066 && tos
->constraint
!= ONLY_IF_RO
)
4068 tos
->all_input_readonly
= TRUE
;
4069 check_input_sections (tos
->children
.head
, tos
);
4070 if (tos
->all_input_readonly
!= (tos
->constraint
== ONLY_IF_RO
))
4072 tos
->constraint
= -1;
4076 map_input_to_output_sections (tos
->children
.head
,
4080 case lang_output_statement_enum
:
4082 case lang_target_statement_enum
:
4083 target
= s
->target_statement
.target
;
4085 case lang_group_statement_enum
:
4086 map_input_to_output_sections (s
->group_statement
.children
.head
,
4090 case lang_data_statement_enum
:
4091 /* Make sure that any sections mentioned in the expression
4093 exp_init_os (s
->data_statement
.exp
);
4094 /* The output section gets CONTENTS, ALLOC and LOAD, but
4095 these may be overridden by the script. */
4096 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
;
4097 switch (os
->sectype
)
4099 case normal_section
:
4100 case overlay_section
:
4101 case first_overlay_section
:
4103 case noalloc_section
:
4104 flags
= SEC_HAS_CONTENTS
;
4106 case noload_section
:
4107 if (bfd_get_flavour (link_info
.output_bfd
)
4108 == bfd_target_elf_flavour
)
4109 flags
= SEC_NEVER_LOAD
| SEC_ALLOC
;
4111 flags
= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
;
4114 if (os
->bfd_section
== NULL
)
4115 init_os (os
, flags
);
4117 os
->bfd_section
->flags
|= flags
;
4119 case lang_input_section_enum
:
4121 case lang_fill_statement_enum
:
4122 case lang_object_symbols_statement_enum
:
4123 case lang_reloc_statement_enum
:
4124 case lang_padding_statement_enum
:
4125 case lang_input_statement_enum
:
4126 if (os
!= NULL
&& os
->bfd_section
== NULL
)
4129 case lang_assignment_statement_enum
:
4130 if (os
!= NULL
&& os
->bfd_section
== NULL
)
4133 /* Make sure that any sections mentioned in the assignment
4135 exp_init_os (s
->assignment_statement
.exp
);
4137 case lang_address_statement_enum
:
4138 /* Mark the specified section with the supplied address.
4139 If this section was actually a segment marker, then the
4140 directive is ignored if the linker script explicitly
4141 processed the segment marker. Originally, the linker
4142 treated segment directives (like -Ttext on the
4143 command-line) as section directives. We honor the
4144 section directive semantics for backwards compatibility;
4145 linker scripts that do not specifically check for
4146 SEGMENT_START automatically get the old semantics. */
4147 if (!s
->address_statement
.segment
4148 || !s
->address_statement
.segment
->used
)
4150 const char *name
= s
->address_statement
.section_name
;
4152 /* Create the output section statement here so that
4153 orphans with a set address will be placed after other
4154 script sections. If we let the orphan placement code
4155 place them in amongst other sections then the address
4156 will affect following script sections, which is
4157 likely to surprise naive users. */
4158 tos
= lang_output_section_statement_lookup (name
, 0, TRUE
);
4159 tos
->addr_tree
= s
->address_statement
.address
;
4160 if (tos
->bfd_section
== NULL
)
4164 case lang_insert_statement_enum
:
4170 /* An insert statement snips out all the linker statements from the
4171 start of the list and places them after the output section
4172 statement specified by the insert. This operation is complicated
4173 by the fact that we keep a doubly linked list of output section
4174 statements as well as the singly linked list of all statements.
4175 FIXME someday: Twiddling with the list not only moves statements
4176 from the user's script but also input and group statements that are
4177 built from command line object files and --start-group. We only
4178 get away with this because the list pointers used by file_chain
4179 and input_file_chain are not reordered, and processing via
4180 statement_list after this point mostly ignores input statements.
4181 One exception is the map file, where LOAD and START GROUP/END GROUP
4182 can end up looking odd. */
4185 process_insert_statements (lang_statement_union_type
**start
)
4187 lang_statement_union_type
**s
;
4188 lang_output_section_statement_type
*first_os
= NULL
;
4189 lang_output_section_statement_type
*last_os
= NULL
;
4190 lang_output_section_statement_type
*os
;
4195 if ((*s
)->header
.type
== lang_output_section_statement_enum
)
4197 /* Keep pointers to the first and last output section
4198 statement in the sequence we may be about to move. */
4199 os
= &(*s
)->output_section_statement
;
4201 ASSERT (last_os
== NULL
|| last_os
->next
== os
);
4204 /* Set constraint negative so that lang_output_section_find
4205 won't match this output section statement. At this
4206 stage in linking constraint has values in the range
4207 [-1, ONLY_IN_RW]. */
4208 last_os
->constraint
= -2 - last_os
->constraint
;
4209 if (first_os
== NULL
)
4212 else if ((*s
)->header
.type
== lang_group_statement_enum
)
4214 /* A user might put -T between --start-group and
4215 --end-group. One way this odd construct might arise is
4216 from a wrapper around ld to change library search
4217 behaviour. For example:
4219 exec real_ld --start-group "$@" --end-group
4220 This isn't completely unreasonable so go looking inside a
4221 group statement for insert statements. */
4222 process_insert_statements (&(*s
)->group_statement
.children
.head
);
4224 else if ((*s
)->header
.type
== lang_insert_statement_enum
)
4226 lang_insert_statement_type
*i
= &(*s
)->insert_statement
;
4227 lang_output_section_statement_type
*where
;
4228 lang_statement_union_type
**ptr
;
4229 lang_statement_union_type
*first
;
4231 if (link_info
.non_contiguous_regions
)
4233 einfo (_("warning: INSERT statement in linker script is "
4234 "incompatible with --enable-non-contiguous-regions.\n"));
4237 where
= lang_output_section_find (i
->where
);
4238 if (where
!= NULL
&& i
->is_before
)
4241 where
= where
->prev
;
4242 while (where
!= NULL
&& where
->constraint
< 0);
4246 einfo (_("%F%P: %s not found for insert\n"), i
->where
);
4250 /* Deal with reordering the output section statement list. */
4251 if (last_os
!= NULL
)
4253 asection
*first_sec
, *last_sec
;
4254 struct lang_output_section_statement_struct
**next
;
4256 /* Snip out the output sections we are moving. */
4257 first_os
->prev
->next
= last_os
->next
;
4258 if (last_os
->next
== NULL
)
4260 next
= &first_os
->prev
->next
;
4261 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4264 last_os
->next
->prev
= first_os
->prev
;
4265 /* Add them in at the new position. */
4266 last_os
->next
= where
->next
;
4267 if (where
->next
== NULL
)
4269 next
= &last_os
->next
;
4270 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4273 where
->next
->prev
= last_os
;
4274 first_os
->prev
= where
;
4275 where
->next
= first_os
;
4277 /* Move the bfd sections in the same way. */
4280 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4282 os
->constraint
= -2 - os
->constraint
;
4283 if (os
->bfd_section
!= NULL
4284 && os
->bfd_section
->owner
!= NULL
)
4286 last_sec
= os
->bfd_section
;
4287 if (first_sec
== NULL
)
4288 first_sec
= last_sec
;
4293 if (last_sec
!= NULL
)
4295 asection
*sec
= where
->bfd_section
;
4297 sec
= output_prev_sec_find (where
);
4299 /* The place we want to insert must come after the
4300 sections we are moving. So if we find no
4301 section or if the section is the same as our
4302 last section, then no move is needed. */
4303 if (sec
!= NULL
&& sec
!= last_sec
)
4305 /* Trim them off. */
4306 if (first_sec
->prev
!= NULL
)
4307 first_sec
->prev
->next
= last_sec
->next
;
4309 link_info
.output_bfd
->sections
= last_sec
->next
;
4310 if (last_sec
->next
!= NULL
)
4311 last_sec
->next
->prev
= first_sec
->prev
;
4313 link_info
.output_bfd
->section_last
= first_sec
->prev
;
4315 last_sec
->next
= sec
->next
;
4316 if (sec
->next
!= NULL
)
4317 sec
->next
->prev
= last_sec
;
4319 link_info
.output_bfd
->section_last
= last_sec
;
4320 first_sec
->prev
= sec
;
4321 sec
->next
= first_sec
;
4329 ptr
= insert_os_after (where
);
4330 /* Snip everything from the start of the list, up to and
4331 including the insert statement we are currently processing. */
4333 *start
= (*s
)->header
.next
;
4334 /* Add them back where they belong, minus the insert. */
4337 statement_list
.tail
= s
;
4342 s
= &(*s
)->header
.next
;
4345 /* Undo constraint twiddling. */
4346 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4348 os
->constraint
= -2 - os
->constraint
;
4354 /* An output section might have been removed after its statement was
4355 added. For example, ldemul_before_allocation can remove dynamic
4356 sections if they turn out to be not needed. Clean them up here. */
4359 strip_excluded_output_sections (void)
4361 lang_output_section_statement_type
*os
;
4363 /* Run lang_size_sections (if not already done). */
4364 if (expld
.phase
!= lang_mark_phase_enum
)
4366 expld
.phase
= lang_mark_phase_enum
;
4367 expld
.dataseg
.phase
= exp_seg_none
;
4368 one_lang_size_sections_pass (NULL
, FALSE
);
4369 lang_reset_memory_regions ();
4372 for (os
= (void *) lang_os_list
.head
;
4376 asection
*output_section
;
4377 bfd_boolean exclude
;
4379 if (os
->constraint
< 0)
4382 output_section
= os
->bfd_section
;
4383 if (output_section
== NULL
)
4386 exclude
= (output_section
->rawsize
== 0
4387 && (output_section
->flags
& SEC_KEEP
) == 0
4388 && !bfd_section_removed_from_list (link_info
.output_bfd
,
4391 /* Some sections have not yet been sized, notably .gnu.version,
4392 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
4393 input sections, so don't drop output sections that have such
4394 input sections unless they are also marked SEC_EXCLUDE. */
4395 if (exclude
&& output_section
->map_head
.s
!= NULL
)
4399 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
4400 if ((s
->flags
& SEC_EXCLUDE
) == 0
4401 && ((s
->flags
& SEC_LINKER_CREATED
) != 0
4402 || link_info
.emitrelocations
))
4411 /* We don't set bfd_section to NULL since bfd_section of the
4412 removed output section statement may still be used. */
4413 if (!os
->update_dot
)
4415 output_section
->flags
|= SEC_EXCLUDE
;
4416 bfd_section_list_remove (link_info
.output_bfd
, output_section
);
4417 link_info
.output_bfd
->section_count
--;
4422 /* Called from ldwrite to clear out asection.map_head and
4423 asection.map_tail for use as link_orders in ldwrite. */
4426 lang_clear_os_map (void)
4428 lang_output_section_statement_type
*os
;
4430 if (map_head_is_link_order
)
4433 for (os
= (void *) lang_os_list
.head
;
4437 asection
*output_section
;
4439 if (os
->constraint
< 0)
4442 output_section
= os
->bfd_section
;
4443 if (output_section
== NULL
)
4446 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
4447 output_section
->map_head
.link_order
= NULL
;
4448 output_section
->map_tail
.link_order
= NULL
;
4451 /* Stop future calls to lang_add_section from messing with map_head
4452 and map_tail link_order fields. */
4453 map_head_is_link_order
= TRUE
;
4457 print_output_section_statement
4458 (lang_output_section_statement_type
*output_section_statement
)
4460 asection
*section
= output_section_statement
->bfd_section
;
4463 if (output_section_statement
!= abs_output_section
)
4465 minfo ("\n%s", output_section_statement
->name
);
4467 if (section
!= NULL
)
4469 print_dot
= section
->vma
;
4471 len
= strlen (output_section_statement
->name
);
4472 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4477 while (len
< SECTION_NAME_MAP_LENGTH
)
4483 minfo ("0x%V %W", section
->vma
, TO_ADDR (section
->size
));
4485 if (section
->vma
!= section
->lma
)
4486 minfo (_(" load address 0x%V"), section
->lma
);
4488 if (output_section_statement
->update_dot_tree
!= NULL
)
4489 exp_fold_tree (output_section_statement
->update_dot_tree
,
4490 bfd_abs_section_ptr
, &print_dot
);
4496 print_statement_list (output_section_statement
->children
.head
,
4497 output_section_statement
);
4501 print_assignment (lang_assignment_statement_type
*assignment
,
4502 lang_output_section_statement_type
*output_section
)
4509 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4512 if (assignment
->exp
->type
.node_class
== etree_assert
)
4515 tree
= assignment
->exp
->assert_s
.child
;
4519 const char *dst
= assignment
->exp
->assign
.dst
;
4521 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
4522 tree
= assignment
->exp
;
4525 osec
= output_section
->bfd_section
;
4527 osec
= bfd_abs_section_ptr
;
4529 if (assignment
->exp
->type
.node_class
!= etree_provide
)
4530 exp_fold_tree (tree
, osec
, &print_dot
);
4532 expld
.result
.valid_p
= FALSE
;
4534 if (expld
.result
.valid_p
)
4538 if (assignment
->exp
->type
.node_class
== etree_assert
4540 || expld
.assign_name
!= NULL
)
4542 value
= expld
.result
.value
;
4544 if (expld
.result
.section
!= NULL
)
4545 value
+= expld
.result
.section
->vma
;
4547 minfo ("0x%V", value
);
4553 struct bfd_link_hash_entry
*h
;
4555 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
4556 FALSE
, FALSE
, TRUE
);
4558 && (h
->type
== bfd_link_hash_defined
4559 || h
->type
== bfd_link_hash_defweak
))
4561 value
= h
->u
.def
.value
;
4562 value
+= h
->u
.def
.section
->output_section
->vma
;
4563 value
+= h
->u
.def
.section
->output_offset
;
4565 minfo ("[0x%V]", value
);
4568 minfo ("[unresolved]");
4573 if (assignment
->exp
->type
.node_class
== etree_provide
)
4574 minfo ("[!provide]");
4581 expld
.assign_name
= NULL
;
4584 exp_print_tree (assignment
->exp
);
4589 print_input_statement (lang_input_statement_type
*statm
)
4591 if (statm
->filename
!= NULL
)
4592 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
4595 /* Print all symbols defined in a particular section. This is called
4596 via bfd_link_hash_traverse, or by print_all_symbols. */
4599 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
4601 asection
*sec
= (asection
*) ptr
;
4603 if ((hash_entry
->type
== bfd_link_hash_defined
4604 || hash_entry
->type
== bfd_link_hash_defweak
)
4605 && sec
== hash_entry
->u
.def
.section
)
4609 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4612 (hash_entry
->u
.def
.value
4613 + hash_entry
->u
.def
.section
->output_offset
4614 + hash_entry
->u
.def
.section
->output_section
->vma
));
4616 minfo (" %pT\n", hash_entry
->root
.string
);
4623 hash_entry_addr_cmp (const void *a
, const void *b
)
4625 const struct bfd_link_hash_entry
*l
= *(const struct bfd_link_hash_entry
**)a
;
4626 const struct bfd_link_hash_entry
*r
= *(const struct bfd_link_hash_entry
**)b
;
4628 if (l
->u
.def
.value
< r
->u
.def
.value
)
4630 else if (l
->u
.def
.value
> r
->u
.def
.value
)
4637 print_all_symbols (asection
*sec
)
4639 input_section_userdata_type
*ud
= bfd_section_userdata (sec
);
4640 struct map_symbol_def
*def
;
4641 struct bfd_link_hash_entry
**entries
;
4647 *ud
->map_symbol_def_tail
= 0;
4649 /* Sort the symbols by address. */
4650 entries
= (struct bfd_link_hash_entry
**)
4651 obstack_alloc (&map_obstack
,
4652 ud
->map_symbol_def_count
* sizeof (*entries
));
4654 for (i
= 0, def
= ud
->map_symbol_def_head
; def
; def
= def
->next
, i
++)
4655 entries
[i
] = def
->entry
;
4657 qsort (entries
, ud
->map_symbol_def_count
, sizeof (*entries
),
4658 hash_entry_addr_cmp
);
4660 /* Print the symbols. */
4661 for (i
= 0; i
< ud
->map_symbol_def_count
; i
++)
4662 print_one_symbol (entries
[i
], sec
);
4664 obstack_free (&map_obstack
, entries
);
4667 /* Print information about an input section to the map file. */
4670 print_input_section (asection
*i
, bfd_boolean is_discarded
)
4672 bfd_size_type size
= i
->size
;
4679 minfo ("%s", i
->name
);
4681 len
= 1 + strlen (i
->name
);
4682 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4687 while (len
< SECTION_NAME_MAP_LENGTH
)
4693 if (i
->output_section
!= NULL
4694 && i
->output_section
->owner
== link_info
.output_bfd
)
4695 addr
= i
->output_section
->vma
+ i
->output_offset
;
4703 minfo ("0x%V %W %pB\n", addr
, TO_ADDR (size
), i
->owner
);
4705 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
4707 len
= SECTION_NAME_MAP_LENGTH
+ 3;
4719 minfo (_("%W (size before relaxing)\n"), TO_ADDR (i
->rawsize
));
4722 if (i
->output_section
!= NULL
4723 && i
->output_section
->owner
== link_info
.output_bfd
)
4725 if (link_info
.reduce_memory_overheads
)
4726 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, i
);
4728 print_all_symbols (i
);
4730 /* Update print_dot, but make sure that we do not move it
4731 backwards - this could happen if we have overlays and a
4732 later overlay is shorter than an earier one. */
4733 if (addr
+ TO_ADDR (size
) > print_dot
)
4734 print_dot
= addr
+ TO_ADDR (size
);
4739 print_fill_statement (lang_fill_statement_type
*fill
)
4743 fputs (" FILL mask 0x", config
.map_file
);
4744 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
4745 fprintf (config
.map_file
, "%02x", *p
);
4746 fputs ("\n", config
.map_file
);
4750 print_data_statement (lang_data_statement_type
*data
)
4757 init_opb (data
->output_section
);
4758 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4761 addr
= data
->output_offset
;
4762 if (data
->output_section
!= NULL
)
4763 addr
+= data
->output_section
->vma
;
4791 if (size
< TO_SIZE ((unsigned) 1))
4792 size
= TO_SIZE ((unsigned) 1);
4793 minfo ("0x%V %W %s 0x%v", addr
, TO_ADDR (size
), name
, data
->value
);
4795 if (data
->exp
->type
.node_class
!= etree_value
)
4798 exp_print_tree (data
->exp
);
4803 print_dot
= addr
+ TO_ADDR (size
);
4806 /* Print an address statement. These are generated by options like
4810 print_address_statement (lang_address_statement_type
*address
)
4812 minfo (_("Address of section %s set to "), address
->section_name
);
4813 exp_print_tree (address
->address
);
4817 /* Print a reloc statement. */
4820 print_reloc_statement (lang_reloc_statement_type
*reloc
)
4826 init_opb (reloc
->output_section
);
4827 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4830 addr
= reloc
->output_offset
;
4831 if (reloc
->output_section
!= NULL
)
4832 addr
+= reloc
->output_section
->vma
;
4834 size
= bfd_get_reloc_size (reloc
->howto
);
4836 minfo ("0x%V %W RELOC %s ", addr
, TO_ADDR (size
), reloc
->howto
->name
);
4838 if (reloc
->name
!= NULL
)
4839 minfo ("%s+", reloc
->name
);
4841 minfo ("%s+", reloc
->section
->name
);
4843 exp_print_tree (reloc
->addend_exp
);
4847 print_dot
= addr
+ TO_ADDR (size
);
4851 print_padding_statement (lang_padding_statement_type
*s
)
4856 init_opb (s
->output_section
);
4859 len
= sizeof " *fill*" - 1;
4860 while (len
< SECTION_NAME_MAP_LENGTH
)
4866 addr
= s
->output_offset
;
4867 if (s
->output_section
!= NULL
)
4868 addr
+= s
->output_section
->vma
;
4869 minfo ("0x%V %W ", addr
, TO_ADDR (s
->size
));
4871 if (s
->fill
->size
!= 0)
4875 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
4876 fprintf (config
.map_file
, "%02x", *p
);
4881 print_dot
= addr
+ TO_ADDR (s
->size
);
4885 print_wild_statement (lang_wild_statement_type
*w
,
4886 lang_output_section_statement_type
*os
)
4888 struct wildcard_list
*sec
;
4892 if (w
->exclude_name_list
)
4895 minfo ("EXCLUDE_FILE(%s", w
->exclude_name_list
->name
);
4896 for (tmp
= w
->exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4897 minfo (" %s", tmp
->name
);
4901 if (w
->filenames_sorted
)
4902 minfo ("SORT_BY_NAME(");
4903 if (w
->filename
!= NULL
)
4904 minfo ("%s", w
->filename
);
4907 if (w
->filenames_sorted
)
4911 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
4913 int closing_paren
= 0;
4915 switch (sec
->spec
.sorted
)
4921 minfo ("SORT_BY_NAME(");
4926 minfo ("SORT_BY_ALIGNMENT(");
4930 case by_name_alignment
:
4931 minfo ("SORT_BY_NAME(SORT_BY_ALIGNMENT(");
4935 case by_alignment_name
:
4936 minfo ("SORT_BY_ALIGNMENT(SORT_BY_NAME(");
4941 minfo ("SORT_NONE(");
4945 case by_init_priority
:
4946 minfo ("SORT_BY_INIT_PRIORITY(");
4951 if (sec
->spec
.exclude_name_list
!= NULL
)
4954 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
4955 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4956 minfo (" %s", tmp
->name
);
4959 if (sec
->spec
.name
!= NULL
)
4960 minfo ("%s", sec
->spec
.name
);
4963 for (;closing_paren
> 0; closing_paren
--)
4972 print_statement_list (w
->children
.head
, os
);
4975 /* Print a group statement. */
4978 print_group (lang_group_statement_type
*s
,
4979 lang_output_section_statement_type
*os
)
4981 fprintf (config
.map_file
, "START GROUP\n");
4982 print_statement_list (s
->children
.head
, os
);
4983 fprintf (config
.map_file
, "END GROUP\n");
4986 /* Print the list of statements in S.
4987 This can be called for any statement type. */
4990 print_statement_list (lang_statement_union_type
*s
,
4991 lang_output_section_statement_type
*os
)
4995 print_statement (s
, os
);
5000 /* Print the first statement in statement list S.
5001 This can be called for any statement type. */
5004 print_statement (lang_statement_union_type
*s
,
5005 lang_output_section_statement_type
*os
)
5007 switch (s
->header
.type
)
5010 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
5013 case lang_constructors_statement_enum
:
5014 if (constructor_list
.head
!= NULL
)
5016 if (constructors_sorted
)
5017 minfo (" SORT (CONSTRUCTORS)\n");
5019 minfo (" CONSTRUCTORS\n");
5020 print_statement_list (constructor_list
.head
, os
);
5023 case lang_wild_statement_enum
:
5024 print_wild_statement (&s
->wild_statement
, os
);
5026 case lang_address_statement_enum
:
5027 print_address_statement (&s
->address_statement
);
5029 case lang_object_symbols_statement_enum
:
5030 minfo (" CREATE_OBJECT_SYMBOLS\n");
5032 case lang_fill_statement_enum
:
5033 print_fill_statement (&s
->fill_statement
);
5035 case lang_data_statement_enum
:
5036 print_data_statement (&s
->data_statement
);
5038 case lang_reloc_statement_enum
:
5039 print_reloc_statement (&s
->reloc_statement
);
5041 case lang_input_section_enum
:
5042 print_input_section (s
->input_section
.section
, FALSE
);
5044 case lang_padding_statement_enum
:
5045 print_padding_statement (&s
->padding_statement
);
5047 case lang_output_section_statement_enum
:
5048 print_output_section_statement (&s
->output_section_statement
);
5050 case lang_assignment_statement_enum
:
5051 print_assignment (&s
->assignment_statement
, os
);
5053 case lang_target_statement_enum
:
5054 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
5056 case lang_output_statement_enum
:
5057 minfo ("OUTPUT(%s", s
->output_statement
.name
);
5058 if (output_target
!= NULL
)
5059 minfo (" %s", output_target
);
5062 case lang_input_statement_enum
:
5063 print_input_statement (&s
->input_statement
);
5065 case lang_group_statement_enum
:
5066 print_group (&s
->group_statement
, os
);
5068 case lang_insert_statement_enum
:
5069 minfo ("INSERT %s %s\n",
5070 s
->insert_statement
.is_before
? "BEFORE" : "AFTER",
5071 s
->insert_statement
.where
);
5077 print_statements (void)
5079 print_statement_list (statement_list
.head
, abs_output_section
);
5082 /* Print the first N statements in statement list S to STDERR.
5083 If N == 0, nothing is printed.
5084 If N < 0, the entire list is printed.
5085 Intended to be called from GDB. */
5088 dprint_statement (lang_statement_union_type
*s
, int n
)
5090 FILE *map_save
= config
.map_file
;
5092 config
.map_file
= stderr
;
5095 print_statement_list (s
, abs_output_section
);
5098 while (s
&& --n
>= 0)
5100 print_statement (s
, abs_output_section
);
5105 config
.map_file
= map_save
;
5109 insert_pad (lang_statement_union_type
**ptr
,
5111 bfd_size_type alignment_needed
,
5112 asection
*output_section
,
5115 static fill_type zero_fill
;
5116 lang_statement_union_type
*pad
= NULL
;
5118 if (ptr
!= &statement_list
.head
)
5119 pad
= ((lang_statement_union_type
*)
5120 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
5122 && pad
->header
.type
== lang_padding_statement_enum
5123 && pad
->padding_statement
.output_section
== output_section
)
5125 /* Use the existing pad statement. */
5127 else if ((pad
= *ptr
) != NULL
5128 && pad
->header
.type
== lang_padding_statement_enum
5129 && pad
->padding_statement
.output_section
== output_section
)
5131 /* Use the existing pad statement. */
5135 /* Make a new padding statement, linked into existing chain. */
5136 pad
= stat_alloc (sizeof (lang_padding_statement_type
));
5137 pad
->header
.next
= *ptr
;
5139 pad
->header
.type
= lang_padding_statement_enum
;
5140 pad
->padding_statement
.output_section
= output_section
;
5143 pad
->padding_statement
.fill
= fill
;
5145 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
5146 pad
->padding_statement
.size
= alignment_needed
;
5147 if (!(output_section
->flags
& SEC_FIXED_SIZE
))
5148 output_section
->size
= TO_SIZE (dot
+ TO_ADDR (alignment_needed
)
5149 - output_section
->vma
);
5152 /* Work out how much this section will move the dot point. */
5156 (lang_statement_union_type
**this_ptr
,
5157 lang_output_section_statement_type
*output_section_statement
,
5159 bfd_boolean
*removed
,
5162 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
5163 asection
*i
= is
->section
;
5164 asection
*o
= output_section_statement
->bfd_section
;
5167 if (link_info
.non_contiguous_regions
)
5169 /* If the input section I has already been successfully assigned
5170 to an output section other than O, don't bother with it and
5171 let the caller remove it from the list. Keep processing in
5172 case we have already handled O, because the repeated passes
5173 have reinitialized its size. */
5174 if (i
->already_assigned
&& i
->already_assigned
!= o
)
5181 if (i
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
5182 i
->output_offset
= i
->vma
- o
->vma
;
5183 else if (((i
->flags
& SEC_EXCLUDE
) != 0)
5184 || output_section_statement
->ignored
)
5185 i
->output_offset
= dot
- o
->vma
;
5188 bfd_size_type alignment_needed
;
5190 /* Align this section first to the input sections requirement,
5191 then to the output section's requirement. If this alignment
5192 is greater than any seen before, then record it too. Perform
5193 the alignment by inserting a magic 'padding' statement. */
5195 if (output_section_statement
->subsection_alignment
!= NULL
)
5197 = exp_get_power (output_section_statement
->subsection_alignment
,
5198 "subsection alignment");
5200 if (o
->alignment_power
< i
->alignment_power
)
5201 o
->alignment_power
= i
->alignment_power
;
5203 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
5205 if (alignment_needed
!= 0)
5207 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
5208 dot
+= alignment_needed
;
5211 if (link_info
.non_contiguous_regions
)
5213 /* If I would overflow O, let the caller remove I from the
5215 if (output_section_statement
->region
)
5217 bfd_vma end
= output_section_statement
->region
->origin
5218 + output_section_statement
->region
->length
;
5220 if (dot
+ TO_ADDR (i
->size
) > end
)
5222 if (i
->flags
& SEC_LINKER_CREATED
)
5223 einfo (_("%F%P: Output section '%s' not large enough for the "
5224 "linker-created stubs section '%s'.\n"),
5225 i
->output_section
->name
, i
->name
);
5227 if (i
->rawsize
&& i
->rawsize
!= i
->size
)
5228 einfo (_("%F%P: Relaxation not supported with "
5229 "--enable-non-contiguous-regions (section '%s' "
5230 "would overflow '%s' after it changed size).\n"),
5231 i
->name
, i
->output_section
->name
);
5235 i
->output_section
= NULL
;
5241 /* Remember where in the output section this input section goes. */
5242 i
->output_offset
= dot
- o
->vma
;
5244 /* Mark how big the output section must be to contain this now. */
5245 dot
+= TO_ADDR (i
->size
);
5246 if (!(o
->flags
& SEC_FIXED_SIZE
))
5247 o
->size
= TO_SIZE (dot
- o
->vma
);
5249 if (link_info
.non_contiguous_regions
)
5251 /* Record that I was successfully assigned to O, and update
5252 its actual output section too. */
5253 i
->already_assigned
= o
;
5254 i
->output_section
= o
;
5268 sort_sections_by_lma (const void *arg1
, const void *arg2
)
5270 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
5271 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
5273 if (sec1
->lma
< sec2
->lma
)
5275 else if (sec1
->lma
> sec2
->lma
)
5277 else if (sec1
->id
< sec2
->id
)
5279 else if (sec1
->id
> sec2
->id
)
5286 sort_sections_by_vma (const void *arg1
, const void *arg2
)
5288 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
5289 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
5291 if (sec1
->vma
< sec2
->vma
)
5293 else if (sec1
->vma
> sec2
->vma
)
5295 else if (sec1
->id
< sec2
->id
)
5297 else if (sec1
->id
> sec2
->id
)
5303 #define IS_TBSS(s) \
5304 ((s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == SEC_THREAD_LOCAL)
5306 #define IGNORE_SECTION(s) \
5307 ((s->flags & SEC_ALLOC) == 0 || IS_TBSS (s))
5309 /* Check to see if any allocated sections overlap with other allocated
5310 sections. This can happen if a linker script specifies the output
5311 section addresses of the two sections. Also check whether any memory
5312 region has overflowed. */
5315 lang_check_section_addresses (void)
5318 struct check_sec
*sections
;
5323 bfd_vma p_start
= 0;
5325 lang_memory_region_type
*m
;
5326 bfd_boolean overlays
;
5328 /* Detect address space overflow on allocated sections. */
5329 addr_mask
= ((bfd_vma
) 1 <<
5330 (bfd_arch_bits_per_address (link_info
.output_bfd
) - 1)) - 1;
5331 addr_mask
= (addr_mask
<< 1) + 1;
5332 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5333 if ((s
->flags
& SEC_ALLOC
) != 0)
5335 s_end
= (s
->vma
+ s
->size
) & addr_mask
;
5336 if (s_end
!= 0 && s_end
< (s
->vma
& addr_mask
))
5337 einfo (_("%X%P: section %s VMA wraps around address space\n"),
5341 s_end
= (s
->lma
+ s
->size
) & addr_mask
;
5342 if (s_end
!= 0 && s_end
< (s
->lma
& addr_mask
))
5343 einfo (_("%X%P: section %s LMA wraps around address space\n"),
5348 if (bfd_count_sections (link_info
.output_bfd
) <= 1)
5351 count
= bfd_count_sections (link_info
.output_bfd
);
5352 sections
= XNEWVEC (struct check_sec
, count
);
5354 /* Scan all sections in the output list. */
5356 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5358 if (IGNORE_SECTION (s
)
5362 sections
[count
].sec
= s
;
5363 sections
[count
].warned
= FALSE
;
5373 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_lma
);
5375 /* First check section LMAs. There should be no overlap of LMAs on
5376 loadable sections, even with overlays. */
5377 for (p
= NULL
, i
= 0; i
< count
; i
++)
5379 s
= sections
[i
].sec
;
5381 if ((s
->flags
& SEC_LOAD
) != 0)
5384 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5386 /* Look for an overlap. We have sorted sections by lma, so
5387 we know that s_start >= p_start. Besides the obvious
5388 case of overlap when the current section starts before
5389 the previous one ends, we also must have overlap if the
5390 previous section wraps around the address space. */
5392 && (s_start
<= p_end
5393 || p_end
< p_start
))
5395 einfo (_("%X%P: section %s LMA [%V,%V]"
5396 " overlaps section %s LMA [%V,%V]\n"),
5397 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5398 sections
[i
].warned
= TRUE
;
5406 /* If any non-zero size allocated section (excluding tbss) starts at
5407 exactly the same VMA as another such section, then we have
5408 overlays. Overlays generated by the OVERLAY keyword will have
5409 this property. It is possible to intentionally generate overlays
5410 that fail this test, but it would be unusual. */
5411 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_vma
);
5413 p_start
= sections
[0].sec
->vma
;
5414 for (i
= 1; i
< count
; i
++)
5416 s_start
= sections
[i
].sec
->vma
;
5417 if (p_start
== s_start
)
5425 /* Now check section VMAs if no overlays were detected. */
5428 for (p
= NULL
, i
= 0; i
< count
; i
++)
5430 s
= sections
[i
].sec
;
5433 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5436 && !sections
[i
].warned
5437 && (s_start
<= p_end
5438 || p_end
< p_start
))
5439 einfo (_("%X%P: section %s VMA [%V,%V]"
5440 " overlaps section %s VMA [%V,%V]\n"),
5441 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5450 /* If any memory region has overflowed, report by how much.
5451 We do not issue this diagnostic for regions that had sections
5452 explicitly placed outside their bounds; os_region_check's
5453 diagnostics are adequate for that case.
5455 FIXME: It is conceivable that m->current - (m->origin + m->length)
5456 might overflow a 32-bit integer. There is, alas, no way to print
5457 a bfd_vma quantity in decimal. */
5458 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
5459 if (m
->had_full_message
)
5461 unsigned long over
= m
->current
- (m
->origin
+ m
->length
);
5462 einfo (ngettext ("%X%P: region `%s' overflowed by %lu byte\n",
5463 "%X%P: region `%s' overflowed by %lu bytes\n",
5465 m
->name_list
.name
, over
);
5469 /* Make sure the new address is within the region. We explicitly permit the
5470 current address to be at the exact end of the region when the address is
5471 non-zero, in case the region is at the end of addressable memory and the
5472 calculation wraps around. */
5475 os_region_check (lang_output_section_statement_type
*os
,
5476 lang_memory_region_type
*region
,
5480 if ((region
->current
< region
->origin
5481 || (region
->current
- region
->origin
> region
->length
))
5482 && ((region
->current
!= region
->origin
+ region
->length
)
5487 einfo (_("%X%P: address 0x%v of %pB section `%s'"
5488 " is not within region `%s'\n"),
5490 os
->bfd_section
->owner
,
5491 os
->bfd_section
->name
,
5492 region
->name_list
.name
);
5494 else if (!region
->had_full_message
)
5496 region
->had_full_message
= TRUE
;
5498 einfo (_("%X%P: %pB section `%s' will not fit in region `%s'\n"),
5499 os
->bfd_section
->owner
,
5500 os
->bfd_section
->name
,
5501 region
->name_list
.name
);
5507 ldlang_check_relro_region (lang_statement_union_type
*s
,
5508 seg_align_type
*seg
)
5510 if (seg
->relro
== exp_seg_relro_start
)
5512 if (!seg
->relro_start_stat
)
5513 seg
->relro_start_stat
= s
;
5516 ASSERT (seg
->relro_start_stat
== s
);
5519 else if (seg
->relro
== exp_seg_relro_end
)
5521 if (!seg
->relro_end_stat
)
5522 seg
->relro_end_stat
= s
;
5525 ASSERT (seg
->relro_end_stat
== s
);
5530 /* Set the sizes for all the output sections. */
5533 lang_size_sections_1
5534 (lang_statement_union_type
**prev
,
5535 lang_output_section_statement_type
*output_section_statement
,
5539 bfd_boolean check_regions
)
5541 lang_statement_union_type
*s
;
5542 lang_statement_union_type
*prev_s
= NULL
;
5543 bfd_boolean removed_prev_s
= FALSE
;
5545 /* Size up the sections from their constituent parts. */
5546 for (s
= *prev
; s
!= NULL
; prev_s
= s
, s
= s
->header
.next
)
5548 bfd_boolean removed
=FALSE
;
5550 switch (s
->header
.type
)
5552 case lang_output_section_statement_enum
:
5554 bfd_vma newdot
, after
, dotdelta
;
5555 lang_output_section_statement_type
*os
;
5556 lang_memory_region_type
*r
;
5557 int section_alignment
= 0;
5559 os
= &s
->output_section_statement
;
5560 init_opb (os
->bfd_section
);
5561 if (os
->constraint
== -1)
5564 /* FIXME: We shouldn't need to zero section vmas for ld -r
5565 here, in lang_insert_orphan, or in the default linker scripts.
5566 This is covering for coff backend linker bugs. See PR6945. */
5567 if (os
->addr_tree
== NULL
5568 && bfd_link_relocatable (&link_info
)
5569 && (bfd_get_flavour (link_info
.output_bfd
)
5570 == bfd_target_coff_flavour
))
5571 os
->addr_tree
= exp_intop (0);
5572 if (os
->addr_tree
!= NULL
)
5574 os
->processed_vma
= FALSE
;
5575 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
5577 if (expld
.result
.valid_p
)
5579 dot
= expld
.result
.value
;
5580 if (expld
.result
.section
!= NULL
)
5581 dot
+= expld
.result
.section
->vma
;
5583 else if (expld
.phase
!= lang_mark_phase_enum
)
5584 einfo (_("%F%P:%pS: non constant or forward reference"
5585 " address expression for section %s\n"),
5586 os
->addr_tree
, os
->name
);
5589 if (os
->bfd_section
== NULL
)
5590 /* This section was removed or never actually created. */
5593 /* If this is a COFF shared library section, use the size and
5594 address from the input section. FIXME: This is COFF
5595 specific; it would be cleaner if there were some other way
5596 to do this, but nothing simple comes to mind. */
5597 if (((bfd_get_flavour (link_info
.output_bfd
)
5598 == bfd_target_ecoff_flavour
)
5599 || (bfd_get_flavour (link_info
.output_bfd
)
5600 == bfd_target_coff_flavour
))
5601 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
5605 if (os
->children
.head
== NULL
5606 || os
->children
.head
->header
.next
!= NULL
5607 || (os
->children
.head
->header
.type
5608 != lang_input_section_enum
))
5609 einfo (_("%X%P: internal error on COFF shared library"
5610 " section %s\n"), os
->name
);
5612 input
= os
->children
.head
->input_section
.section
;
5613 bfd_set_section_vma (os
->bfd_section
,
5614 bfd_section_vma (input
));
5615 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5616 os
->bfd_section
->size
= input
->size
;
5622 if (bfd_is_abs_section (os
->bfd_section
))
5624 /* No matter what happens, an abs section starts at zero. */
5625 ASSERT (os
->bfd_section
->vma
== 0);
5629 if (os
->addr_tree
== NULL
)
5631 /* No address specified for this section, get one
5632 from the region specification. */
5633 if (os
->region
== NULL
5634 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
5635 && os
->region
->name_list
.name
[0] == '*'
5636 && strcmp (os
->region
->name_list
.name
,
5637 DEFAULT_MEMORY_REGION
) == 0))
5639 os
->region
= lang_memory_default (os
->bfd_section
);
5642 /* If a loadable section is using the default memory
5643 region, and some non default memory regions were
5644 defined, issue an error message. */
5646 && !IGNORE_SECTION (os
->bfd_section
)
5647 && !bfd_link_relocatable (&link_info
)
5649 && strcmp (os
->region
->name_list
.name
,
5650 DEFAULT_MEMORY_REGION
) == 0
5651 && lang_memory_region_list
!= NULL
5652 && (strcmp (lang_memory_region_list
->name_list
.name
,
5653 DEFAULT_MEMORY_REGION
) != 0
5654 || lang_memory_region_list
->next
!= NULL
)
5655 && lang_sizing_iteration
== 1)
5657 /* By default this is an error rather than just a
5658 warning because if we allocate the section to the
5659 default memory region we can end up creating an
5660 excessively large binary, or even seg faulting when
5661 attempting to perform a negative seek. See
5662 sources.redhat.com/ml/binutils/2003-04/msg00423.html
5663 for an example of this. This behaviour can be
5664 overridden by the using the --no-check-sections
5666 if (command_line
.check_section_addresses
)
5667 einfo (_("%F%P: error: no memory region specified"
5668 " for loadable section `%s'\n"),
5669 bfd_section_name (os
->bfd_section
));
5671 einfo (_("%P: warning: no memory region specified"
5672 " for loadable section `%s'\n"),
5673 bfd_section_name (os
->bfd_section
));
5676 newdot
= os
->region
->current
;
5677 section_alignment
= os
->bfd_section
->alignment_power
;
5680 section_alignment
= exp_get_power (os
->section_alignment
,
5681 "section alignment");
5683 /* Align to what the section needs. */
5684 if (section_alignment
> 0)
5686 bfd_vma savedot
= newdot
;
5689 newdot
= align_power (newdot
, section_alignment
);
5690 dotdelta
= newdot
- savedot
;
5692 if (lang_sizing_iteration
== 1)
5694 else if (lang_sizing_iteration
> 1)
5696 /* Only report adjustments that would change
5697 alignment from what we have already reported. */
5698 diff
= newdot
- os
->bfd_section
->vma
;
5699 if (!(diff
& (((bfd_vma
) 1 << section_alignment
) - 1)))
5703 && (config
.warn_section_align
5704 || os
->addr_tree
!= NULL
))
5705 einfo (_("%P: warning: "
5706 "start of section %s changed by %ld\n"),
5707 os
->name
, (long) diff
);
5710 bfd_set_section_vma (os
->bfd_section
, newdot
);
5712 os
->bfd_section
->output_offset
= 0;
5715 lang_size_sections_1 (&os
->children
.head
, os
,
5716 os
->fill
, newdot
, relax
, check_regions
);
5718 os
->processed_vma
= TRUE
;
5720 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5721 /* Except for some special linker created sections,
5722 no output section should change from zero size
5723 after strip_excluded_output_sections. A non-zero
5724 size on an ignored section indicates that some
5725 input section was not sized early enough. */
5726 ASSERT (os
->bfd_section
->size
== 0);
5729 dot
= os
->bfd_section
->vma
;
5731 /* Put the section within the requested block size, or
5732 align at the block boundary. */
5734 + TO_ADDR (os
->bfd_section
->size
)
5735 + os
->block_value
- 1)
5736 & - (bfd_vma
) os
->block_value
);
5738 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5739 os
->bfd_section
->size
= TO_SIZE (after
5740 - os
->bfd_section
->vma
);
5743 /* Set section lma. */
5746 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
5750 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
5751 os
->bfd_section
->lma
= lma
;
5753 else if (os
->lma_region
!= NULL
)
5755 bfd_vma lma
= os
->lma_region
->current
;
5757 if (os
->align_lma_with_input
)
5761 /* When LMA_REGION is the same as REGION, align the LMA
5762 as we did for the VMA, possibly including alignment
5763 from the bfd section. If a different region, then
5764 only align according to the value in the output
5766 if (os
->lma_region
!= os
->region
)
5767 section_alignment
= exp_get_power (os
->section_alignment
,
5768 "section alignment");
5769 if (section_alignment
> 0)
5770 lma
= align_power (lma
, section_alignment
);
5772 os
->bfd_section
->lma
= lma
;
5774 else if (r
->last_os
!= NULL
5775 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5780 last
= r
->last_os
->output_section_statement
.bfd_section
;
5782 /* A backwards move of dot should be accompanied by
5783 an explicit assignment to the section LMA (ie.
5784 os->load_base set) because backwards moves can
5785 create overlapping LMAs. */
5787 && os
->bfd_section
->size
!= 0
5788 && dot
+ TO_ADDR (os
->bfd_section
->size
) <= last
->vma
)
5790 /* If dot moved backwards then leave lma equal to
5791 vma. This is the old default lma, which might
5792 just happen to work when the backwards move is
5793 sufficiently large. Nag if this changes anything,
5794 so people can fix their linker scripts. */
5796 if (last
->vma
!= last
->lma
)
5797 einfo (_("%P: warning: dot moved backwards "
5798 "before `%s'\n"), os
->name
);
5802 /* If this is an overlay, set the current lma to that
5803 at the end of the previous section. */
5804 if (os
->sectype
== overlay_section
)
5805 lma
= last
->lma
+ TO_ADDR (last
->size
);
5807 /* Otherwise, keep the same lma to vma relationship
5808 as the previous section. */
5810 lma
= os
->bfd_section
->vma
+ last
->lma
- last
->vma
;
5812 if (section_alignment
> 0)
5813 lma
= align_power (lma
, section_alignment
);
5814 os
->bfd_section
->lma
= lma
;
5817 os
->processed_lma
= TRUE
;
5819 /* Keep track of normal sections using the default
5820 lma region. We use this to set the lma for
5821 following sections. Overlays or other linker
5822 script assignment to lma might mean that the
5823 default lma == vma is incorrect.
5824 To avoid warnings about dot moving backwards when using
5825 -Ttext, don't start tracking sections until we find one
5826 of non-zero size or with lma set differently to vma.
5827 Do this tracking before we short-cut the loop so that we
5828 track changes for the case where the section size is zero,
5829 but the lma is set differently to the vma. This is
5830 important, if an orphan section is placed after an
5831 otherwise empty output section that has an explicit lma
5832 set, we want that lma reflected in the orphans lma. */
5833 if (((!IGNORE_SECTION (os
->bfd_section
)
5834 && (os
->bfd_section
->size
!= 0
5835 || (r
->last_os
== NULL
5836 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
5837 || (r
->last_os
!= NULL
5838 && dot
>= (r
->last_os
->output_section_statement
5839 .bfd_section
->vma
))))
5840 || os
->sectype
== first_overlay_section
)
5841 && os
->lma_region
== NULL
5842 && !bfd_link_relocatable (&link_info
))
5845 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5848 /* .tbss sections effectively have zero size. */
5849 if (!IS_TBSS (os
->bfd_section
)
5850 || bfd_link_relocatable (&link_info
))
5851 dotdelta
= TO_ADDR (os
->bfd_section
->size
);
5856 if (os
->update_dot_tree
!= 0)
5857 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5859 /* Update dot in the region ?
5860 We only do this if the section is going to be allocated,
5861 since unallocated sections do not contribute to the region's
5862 overall size in memory. */
5863 if (os
->region
!= NULL
5864 && (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)))
5866 os
->region
->current
= dot
;
5869 /* Make sure the new address is within the region. */
5870 os_region_check (os
, os
->region
, os
->addr_tree
,
5871 os
->bfd_section
->vma
);
5873 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
5874 && ((os
->bfd_section
->flags
& SEC_LOAD
)
5875 || os
->align_lma_with_input
))
5877 os
->lma_region
->current
= os
->bfd_section
->lma
+ dotdelta
;
5880 os_region_check (os
, os
->lma_region
, NULL
,
5881 os
->bfd_section
->lma
);
5887 case lang_constructors_statement_enum
:
5888 dot
= lang_size_sections_1 (&constructor_list
.head
,
5889 output_section_statement
,
5890 fill
, dot
, relax
, check_regions
);
5893 case lang_data_statement_enum
:
5895 unsigned int size
= 0;
5897 s
->data_statement
.output_offset
=
5898 dot
- output_section_statement
->bfd_section
->vma
;
5899 s
->data_statement
.output_section
=
5900 output_section_statement
->bfd_section
;
5902 /* We might refer to provided symbols in the expression, and
5903 need to mark them as needed. */
5904 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5906 switch (s
->data_statement
.type
)
5924 if (size
< TO_SIZE ((unsigned) 1))
5925 size
= TO_SIZE ((unsigned) 1);
5926 dot
+= TO_ADDR (size
);
5927 if (!(output_section_statement
->bfd_section
->flags
5929 output_section_statement
->bfd_section
->size
5930 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5935 case lang_reloc_statement_enum
:
5939 s
->reloc_statement
.output_offset
=
5940 dot
- output_section_statement
->bfd_section
->vma
;
5941 s
->reloc_statement
.output_section
=
5942 output_section_statement
->bfd_section
;
5943 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
5944 dot
+= TO_ADDR (size
);
5945 if (!(output_section_statement
->bfd_section
->flags
5947 output_section_statement
->bfd_section
->size
5948 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5952 case lang_wild_statement_enum
:
5953 dot
= lang_size_sections_1 (&s
->wild_statement
.children
.head
,
5954 output_section_statement
,
5955 fill
, dot
, relax
, check_regions
);
5958 case lang_object_symbols_statement_enum
:
5959 link_info
.create_object_symbols_section
5960 = output_section_statement
->bfd_section
;
5961 output_section_statement
->bfd_section
->flags
|= SEC_KEEP
;
5964 case lang_output_statement_enum
:
5965 case lang_target_statement_enum
:
5968 case lang_input_section_enum
:
5972 i
= s
->input_section
.section
;
5977 if (!bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
5978 einfo (_("%F%P: can't relax section: %E\n"));
5982 dot
= size_input_section (prev
, output_section_statement
,
5983 fill
, &removed
, dot
);
5987 case lang_input_statement_enum
:
5990 case lang_fill_statement_enum
:
5991 s
->fill_statement
.output_section
=
5992 output_section_statement
->bfd_section
;
5994 fill
= s
->fill_statement
.fill
;
5997 case lang_assignment_statement_enum
:
5999 bfd_vma newdot
= dot
;
6000 etree_type
*tree
= s
->assignment_statement
.exp
;
6002 expld
.dataseg
.relro
= exp_seg_relro_none
;
6004 exp_fold_tree (tree
,
6005 output_section_statement
->bfd_section
,
6008 ldlang_check_relro_region (s
, &expld
.dataseg
);
6010 expld
.dataseg
.relro
= exp_seg_relro_none
;
6012 /* This symbol may be relative to this section. */
6013 if ((tree
->type
.node_class
== etree_provided
6014 || tree
->type
.node_class
== etree_assign
)
6015 && (tree
->assign
.dst
[0] != '.'
6016 || tree
->assign
.dst
[1] != '\0'))
6017 output_section_statement
->update_dot
= 1;
6019 if (!output_section_statement
->ignored
)
6021 if (output_section_statement
== abs_output_section
)
6023 /* If we don't have an output section, then just adjust
6024 the default memory address. */
6025 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
6026 FALSE
)->current
= newdot
;
6028 else if (newdot
!= dot
)
6030 /* Insert a pad after this statement. We can't
6031 put the pad before when relaxing, in case the
6032 assignment references dot. */
6033 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
6034 output_section_statement
->bfd_section
, dot
);
6036 /* Don't neuter the pad below when relaxing. */
6039 /* If dot is advanced, this implies that the section
6040 should have space allocated to it, unless the
6041 user has explicitly stated that the section
6042 should not be allocated. */
6043 if (output_section_statement
->sectype
!= noalloc_section
6044 && (output_section_statement
->sectype
!= noload_section
6045 || (bfd_get_flavour (link_info
.output_bfd
)
6046 == bfd_target_elf_flavour
)))
6047 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
6054 case lang_padding_statement_enum
:
6055 /* If this is the first time lang_size_sections is called,
6056 we won't have any padding statements. If this is the
6057 second or later passes when relaxing, we should allow
6058 padding to shrink. If padding is needed on this pass, it
6059 will be added back in. */
6060 s
->padding_statement
.size
= 0;
6062 /* Make sure output_offset is valid. If relaxation shrinks
6063 the section and this pad isn't needed, it's possible to
6064 have output_offset larger than the final size of the
6065 section. bfd_set_section_contents will complain even for
6066 a pad size of zero. */
6067 s
->padding_statement
.output_offset
6068 = dot
- output_section_statement
->bfd_section
->vma
;
6071 case lang_group_statement_enum
:
6072 dot
= lang_size_sections_1 (&s
->group_statement
.children
.head
,
6073 output_section_statement
,
6074 fill
, dot
, relax
, check_regions
);
6077 case lang_insert_statement_enum
:
6080 /* We can only get here when relaxing is turned on. */
6081 case lang_address_statement_enum
:
6089 /* If an input section doesn't fit in the current output
6090 section, remove it from the list. Handle the case where we
6091 have to remove an input_section statement here: there is a
6092 special case to remove the first element of the list. */
6093 if (link_info
.non_contiguous_regions
&& removed
)
6095 /* If we removed the first element during the previous
6096 iteration, override the loop assignment of prev_s. */
6102 /* If there was a real previous input section, just skip
6104 prev_s
->header
.next
=s
->header
.next
;
6106 removed_prev_s
= FALSE
;
6110 /* Remove the first input section of the list. */
6111 *prev
= s
->header
.next
;
6112 removed_prev_s
= TRUE
;
6115 /* Move to next element, unless we removed the head of the
6117 if (!removed_prev_s
)
6118 prev
= &s
->header
.next
;
6122 prev
= &s
->header
.next
;
6123 removed_prev_s
= FALSE
;
6129 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
6130 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
6131 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
6132 segments. We are allowed an opportunity to override this decision. */
6135 ldlang_override_segment_assignment (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
6136 bfd
*abfd ATTRIBUTE_UNUSED
,
6137 asection
*current_section
,
6138 asection
*previous_section
,
6139 bfd_boolean new_segment
)
6141 lang_output_section_statement_type
*cur
;
6142 lang_output_section_statement_type
*prev
;
6144 /* The checks below are only necessary when the BFD library has decided
6145 that the two sections ought to be placed into the same segment. */
6149 /* Paranoia checks. */
6150 if (current_section
== NULL
|| previous_section
== NULL
)
6153 /* If this flag is set, the target never wants code and non-code
6154 sections comingled in the same segment. */
6155 if (config
.separate_code
6156 && ((current_section
->flags
^ previous_section
->flags
) & SEC_CODE
))
6159 /* Find the memory regions associated with the two sections.
6160 We call lang_output_section_find() here rather than scanning the list
6161 of output sections looking for a matching section pointer because if
6162 we have a large number of sections then a hash lookup is faster. */
6163 cur
= lang_output_section_find (current_section
->name
);
6164 prev
= lang_output_section_find (previous_section
->name
);
6166 /* More paranoia. */
6167 if (cur
== NULL
|| prev
== NULL
)
6170 /* If the regions are different then force the sections to live in
6171 different segments. See the email thread starting at the following
6172 URL for the reasons why this is necessary:
6173 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
6174 return cur
->region
!= prev
->region
;
6178 one_lang_size_sections_pass (bfd_boolean
*relax
, bfd_boolean check_regions
)
6180 lang_statement_iteration
++;
6181 if (expld
.phase
!= lang_mark_phase_enum
)
6182 lang_sizing_iteration
++;
6183 lang_size_sections_1 (&statement_list
.head
, abs_output_section
,
6184 0, 0, relax
, check_regions
);
6188 lang_size_segment (seg_align_type
*seg
)
6190 /* If XXX_SEGMENT_ALIGN XXX_SEGMENT_END pair was seen, check whether
6191 a page could be saved in the data segment. */
6192 bfd_vma first
, last
;
6194 first
= -seg
->base
& (seg
->pagesize
- 1);
6195 last
= seg
->end
& (seg
->pagesize
- 1);
6197 && ((seg
->base
& ~(seg
->pagesize
- 1))
6198 != (seg
->end
& ~(seg
->pagesize
- 1)))
6199 && first
+ last
<= seg
->pagesize
)
6201 seg
->phase
= exp_seg_adjust
;
6205 seg
->phase
= exp_seg_done
;
6210 lang_size_relro_segment_1 (seg_align_type
*seg
)
6212 bfd_vma relro_end
, desired_end
;
6215 /* Compute the expected PT_GNU_RELRO/PT_LOAD segment end. */
6216 relro_end
= ((seg
->relro_end
+ seg
->pagesize
- 1)
6217 & ~(seg
->pagesize
- 1));
6219 /* Adjust by the offset arg of XXX_SEGMENT_RELRO_END. */
6220 desired_end
= relro_end
- seg
->relro_offset
;
6222 /* For sections in the relro segment.. */
6223 for (sec
= link_info
.output_bfd
->section_last
; sec
; sec
= sec
->prev
)
6224 if ((sec
->flags
& SEC_ALLOC
) != 0
6225 && sec
->vma
>= seg
->base
6226 && sec
->vma
< seg
->relro_end
- seg
->relro_offset
)
6228 /* Where do we want to put this section so that it ends as
6230 bfd_vma start
, end
, bump
;
6232 end
= start
= sec
->vma
;
6234 end
+= TO_ADDR (sec
->size
);
6235 bump
= desired_end
- end
;
6236 /* We'd like to increase START by BUMP, but we must heed
6237 alignment so the increase might be less than optimum. */
6239 start
&= ~(((bfd_vma
) 1 << sec
->alignment_power
) - 1);
6240 /* This is now the desired end for the previous section. */
6241 desired_end
= start
;
6244 seg
->phase
= exp_seg_relro_adjust
;
6245 ASSERT (desired_end
>= seg
->base
);
6246 seg
->base
= desired_end
;
6251 lang_size_relro_segment (bfd_boolean
*relax
, bfd_boolean check_regions
)
6253 bfd_boolean do_reset
= FALSE
;
6254 bfd_boolean do_data_relro
;
6255 bfd_vma data_initial_base
, data_relro_end
;
6257 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
6259 do_data_relro
= TRUE
;
6260 data_initial_base
= expld
.dataseg
.base
;
6261 data_relro_end
= lang_size_relro_segment_1 (&expld
.dataseg
);
6265 do_data_relro
= FALSE
;
6266 data_initial_base
= data_relro_end
= 0;
6271 lang_reset_memory_regions ();
6272 one_lang_size_sections_pass (relax
, check_regions
);
6274 /* Assignments to dot, or to output section address in a user
6275 script have increased padding over the original. Revert. */
6276 if (do_data_relro
&& expld
.dataseg
.relro_end
> data_relro_end
)
6278 expld
.dataseg
.base
= data_initial_base
;;
6283 if (!do_data_relro
&& lang_size_segment (&expld
.dataseg
))
6290 lang_size_sections (bfd_boolean
*relax
, bfd_boolean check_regions
)
6292 expld
.phase
= lang_allocating_phase_enum
;
6293 expld
.dataseg
.phase
= exp_seg_none
;
6295 one_lang_size_sections_pass (relax
, check_regions
);
6297 if (expld
.dataseg
.phase
!= exp_seg_end_seen
)
6298 expld
.dataseg
.phase
= exp_seg_done
;
6300 if (expld
.dataseg
.phase
== exp_seg_end_seen
)
6302 bfd_boolean do_reset
6303 = lang_size_relro_segment (relax
, check_regions
);
6307 lang_reset_memory_regions ();
6308 one_lang_size_sections_pass (relax
, check_regions
);
6311 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
6313 link_info
.relro_start
= expld
.dataseg
.base
;
6314 link_info
.relro_end
= expld
.dataseg
.relro_end
;
6319 static lang_output_section_statement_type
*current_section
;
6320 static lang_assignment_statement_type
*current_assign
;
6321 static bfd_boolean prefer_next_section
;
6323 /* Worker function for lang_do_assignments. Recursiveness goes here. */
6326 lang_do_assignments_1 (lang_statement_union_type
*s
,
6327 lang_output_section_statement_type
*current_os
,
6330 bfd_boolean
*found_end
)
6332 for (; s
!= NULL
; s
= s
->header
.next
)
6334 switch (s
->header
.type
)
6336 case lang_constructors_statement_enum
:
6337 dot
= lang_do_assignments_1 (constructor_list
.head
,
6338 current_os
, fill
, dot
, found_end
);
6341 case lang_output_section_statement_enum
:
6343 lang_output_section_statement_type
*os
;
6346 os
= &(s
->output_section_statement
);
6347 os
->after_end
= *found_end
;
6348 init_opb (os
->bfd_section
);
6349 if (os
->bfd_section
!= NULL
&& !os
->ignored
)
6351 if ((os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
6353 current_section
= os
;
6354 prefer_next_section
= FALSE
;
6356 dot
= os
->bfd_section
->vma
;
6358 newdot
= lang_do_assignments_1 (os
->children
.head
,
6359 os
, os
->fill
, dot
, found_end
);
6362 if (os
->bfd_section
!= NULL
)
6364 /* .tbss sections effectively have zero size. */
6365 if (!IS_TBSS (os
->bfd_section
)
6366 || bfd_link_relocatable (&link_info
))
6367 dot
+= TO_ADDR (os
->bfd_section
->size
);
6369 if (os
->update_dot_tree
!= NULL
)
6370 exp_fold_tree (os
->update_dot_tree
,
6371 bfd_abs_section_ptr
, &dot
);
6379 case lang_wild_statement_enum
:
6381 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
6382 current_os
, fill
, dot
, found_end
);
6385 case lang_object_symbols_statement_enum
:
6386 case lang_output_statement_enum
:
6387 case lang_target_statement_enum
:
6390 case lang_data_statement_enum
:
6391 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
6392 if (expld
.result
.valid_p
)
6394 s
->data_statement
.value
= expld
.result
.value
;
6395 if (expld
.result
.section
!= NULL
)
6396 s
->data_statement
.value
+= expld
.result
.section
->vma
;
6398 else if (expld
.phase
== lang_final_phase_enum
)
6399 einfo (_("%F%P: invalid data statement\n"));
6402 switch (s
->data_statement
.type
)
6420 if (size
< TO_SIZE ((unsigned) 1))
6421 size
= TO_SIZE ((unsigned) 1);
6422 dot
+= TO_ADDR (size
);
6426 case lang_reloc_statement_enum
:
6427 exp_fold_tree (s
->reloc_statement
.addend_exp
,
6428 bfd_abs_section_ptr
, &dot
);
6429 if (expld
.result
.valid_p
)
6430 s
->reloc_statement
.addend_value
= expld
.result
.value
;
6431 else if (expld
.phase
== lang_final_phase_enum
)
6432 einfo (_("%F%P: invalid reloc statement\n"));
6433 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
6436 case lang_input_section_enum
:
6438 asection
*in
= s
->input_section
.section
;
6440 if ((in
->flags
& SEC_EXCLUDE
) == 0)
6441 dot
+= TO_ADDR (in
->size
);
6445 case lang_input_statement_enum
:
6448 case lang_fill_statement_enum
:
6449 fill
= s
->fill_statement
.fill
;
6452 case lang_assignment_statement_enum
:
6453 current_assign
= &s
->assignment_statement
;
6454 if (current_assign
->exp
->type
.node_class
!= etree_assert
)
6456 const char *p
= current_assign
->exp
->assign
.dst
;
6458 if (current_os
== abs_output_section
&& p
[0] == '.' && p
[1] == 0)
6459 prefer_next_section
= TRUE
;
6463 if (strcmp (p
, "end") == 0)
6466 exp_fold_tree (s
->assignment_statement
.exp
,
6467 (current_os
->bfd_section
!= NULL
6468 ? current_os
->bfd_section
: bfd_und_section_ptr
),
6472 case lang_padding_statement_enum
:
6473 dot
+= TO_ADDR (s
->padding_statement
.size
);
6476 case lang_group_statement_enum
:
6477 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
6478 current_os
, fill
, dot
, found_end
);
6481 case lang_insert_statement_enum
:
6484 case lang_address_statement_enum
:
6496 lang_do_assignments (lang_phase_type phase
)
6498 bfd_boolean found_end
= FALSE
;
6500 current_section
= NULL
;
6501 prefer_next_section
= FALSE
;
6502 expld
.phase
= phase
;
6503 lang_statement_iteration
++;
6504 lang_do_assignments_1 (statement_list
.head
,
6505 abs_output_section
, NULL
, 0, &found_end
);
6508 /* For an assignment statement outside of an output section statement,
6509 choose the best of neighbouring output sections to use for values
6513 section_for_dot (void)
6517 /* Assignments belong to the previous output section, unless there
6518 has been an assignment to "dot", in which case following
6519 assignments belong to the next output section. (The assumption
6520 is that an assignment to "dot" is setting up the address for the
6521 next output section.) Except that past the assignment to "_end"
6522 we always associate with the previous section. This exception is
6523 for targets like SH that define an alloc .stack or other
6524 weirdness after non-alloc sections. */
6525 if (current_section
== NULL
|| prefer_next_section
)
6527 lang_statement_union_type
*stmt
;
6528 lang_output_section_statement_type
*os
;
6530 for (stmt
= (lang_statement_union_type
*) current_assign
;
6532 stmt
= stmt
->header
.next
)
6533 if (stmt
->header
.type
== lang_output_section_statement_enum
)
6536 os
= &stmt
->output_section_statement
;
6539 && (os
->bfd_section
== NULL
6540 || (os
->bfd_section
->flags
& SEC_EXCLUDE
) != 0
6541 || bfd_section_removed_from_list (link_info
.output_bfd
,
6545 if (current_section
== NULL
|| os
== NULL
|| !os
->after_end
)
6548 s
= os
->bfd_section
;
6550 s
= link_info
.output_bfd
->section_last
;
6552 && ((s
->flags
& SEC_ALLOC
) == 0
6553 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6558 return bfd_abs_section_ptr
;
6562 s
= current_section
->bfd_section
;
6564 /* The section may have been stripped. */
6566 && ((s
->flags
& SEC_EXCLUDE
) != 0
6567 || (s
->flags
& SEC_ALLOC
) == 0
6568 || (s
->flags
& SEC_THREAD_LOCAL
) != 0
6569 || bfd_section_removed_from_list (link_info
.output_bfd
, s
)))
6572 s
= link_info
.output_bfd
->sections
;
6574 && ((s
->flags
& SEC_ALLOC
) == 0
6575 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6580 return bfd_abs_section_ptr
;
6583 /* Array of __start/__stop/.startof./.sizeof/ symbols. */
6585 static struct bfd_link_hash_entry
**start_stop_syms
;
6586 static size_t start_stop_count
= 0;
6587 static size_t start_stop_alloc
= 0;
6589 /* Give start/stop SYMBOL for SEC a preliminary definition, and add it
6590 to start_stop_syms. */
6593 lang_define_start_stop (const char *symbol
, asection
*sec
)
6595 struct bfd_link_hash_entry
*h
;
6597 h
= bfd_define_start_stop (link_info
.output_bfd
, &link_info
, symbol
, sec
);
6600 if (start_stop_count
== start_stop_alloc
)
6602 start_stop_alloc
= 2 * start_stop_alloc
+ 10;
6604 = xrealloc (start_stop_syms
,
6605 start_stop_alloc
* sizeof (*start_stop_syms
));
6607 start_stop_syms
[start_stop_count
++] = h
;
6611 /* Check for input sections whose names match references to
6612 __start_SECNAME or __stop_SECNAME symbols. Give the symbols
6613 preliminary definitions. */
6616 lang_init_start_stop (void)
6620 char leading_char
= bfd_get_symbol_leading_char (link_info
.output_bfd
);
6622 for (abfd
= link_info
.input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6623 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6626 const char *secname
= s
->name
;
6628 for (ps
= secname
; *ps
!= '\0'; ps
++)
6629 if (!ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
6633 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6635 symbol
[0] = leading_char
;
6636 sprintf (symbol
+ (leading_char
!= 0), "__start_%s", secname
);
6637 lang_define_start_stop (symbol
, s
);
6639 symbol
[1] = leading_char
;
6640 memcpy (symbol
+ 1 + (leading_char
!= 0), "__stop", 6);
6641 lang_define_start_stop (symbol
+ 1, s
);
6648 /* Iterate over start_stop_syms. */
6651 foreach_start_stop (void (*func
) (struct bfd_link_hash_entry
*))
6655 for (i
= 0; i
< start_stop_count
; ++i
)
6656 func (start_stop_syms
[i
]);
6659 /* __start and __stop symbols are only supposed to be defined by the
6660 linker for orphan sections, but we now extend that to sections that
6661 map to an output section of the same name. The symbols were
6662 defined early for --gc-sections, before we mapped input to output
6663 sections, so undo those that don't satisfy this rule. */
6666 undef_start_stop (struct bfd_link_hash_entry
*h
)
6668 if (h
->ldscript_def
)
6671 if (h
->u
.def
.section
->output_section
== NULL
6672 || h
->u
.def
.section
->output_section
->owner
!= link_info
.output_bfd
6673 || strcmp (h
->u
.def
.section
->name
,
6674 h
->u
.def
.section
->output_section
->name
) != 0)
6676 asection
*sec
= bfd_get_section_by_name (link_info
.output_bfd
,
6677 h
->u
.def
.section
->name
);
6680 /* When there are more than one input sections with the same
6681 section name, SECNAME, linker picks the first one to define
6682 __start_SECNAME and __stop_SECNAME symbols. When the first
6683 input section is removed by comdat group, we need to check
6684 if there is still an output section with section name
6687 for (i
= sec
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
6688 if (strcmp (h
->u
.def
.section
->name
, i
->name
) == 0)
6690 h
->u
.def
.section
= i
;
6694 h
->type
= bfd_link_hash_undefined
;
6695 h
->u
.undef
.abfd
= NULL
;
6700 lang_undef_start_stop (void)
6702 foreach_start_stop (undef_start_stop
);
6705 /* Check for output sections whose names match references to
6706 .startof.SECNAME or .sizeof.SECNAME symbols. Give the symbols
6707 preliminary definitions. */
6710 lang_init_startof_sizeof (void)
6714 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6716 const char *secname
= s
->name
;
6717 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6719 sprintf (symbol
, ".startof.%s", secname
);
6720 lang_define_start_stop (symbol
, s
);
6722 memcpy (symbol
+ 1, ".size", 5);
6723 lang_define_start_stop (symbol
+ 1, s
);
6728 /* Set .startof., .sizeof., __start and __stop symbols final values. */
6731 set_start_stop (struct bfd_link_hash_entry
*h
)
6734 || h
->type
!= bfd_link_hash_defined
)
6737 if (h
->root
.string
[0] == '.')
6739 /* .startof. or .sizeof. symbol.
6740 .startof. already has final value. */
6741 if (h
->root
.string
[2] == 'i')
6744 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6745 h
->u
.def
.section
= bfd_abs_section_ptr
;
6750 /* __start or __stop symbol. */
6751 int has_lead
= bfd_get_symbol_leading_char (link_info
.output_bfd
) != 0;
6753 h
->u
.def
.section
= h
->u
.def
.section
->output_section
;
6754 if (h
->root
.string
[4 + has_lead
] == 'o')
6757 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6763 lang_finalize_start_stop (void)
6765 foreach_start_stop (set_start_stop
);
6771 struct bfd_link_hash_entry
*h
;
6774 if ((bfd_link_relocatable (&link_info
) && !link_info
.gc_sections
)
6775 || bfd_link_dll (&link_info
))
6776 warn
= entry_from_cmdline
;
6780 /* Force the user to specify a root when generating a relocatable with
6781 --gc-sections, unless --gc-keep-exported was also given. */
6782 if (bfd_link_relocatable (&link_info
)
6783 && link_info
.gc_sections
6784 && !link_info
.gc_keep_exported
6785 && !(entry_from_cmdline
|| undef_from_cmdline
))
6786 einfo (_("%F%P: gc-sections requires either an entry or "
6787 "an undefined symbol\n"));
6789 if (entry_symbol
.name
== NULL
)
6791 /* No entry has been specified. Look for the default entry, but
6792 don't warn if we don't find it. */
6793 entry_symbol
.name
= entry_symbol_default
;
6797 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
6798 FALSE
, FALSE
, TRUE
);
6800 && (h
->type
== bfd_link_hash_defined
6801 || h
->type
== bfd_link_hash_defweak
)
6802 && h
->u
.def
.section
->output_section
!= NULL
)
6806 val
= (h
->u
.def
.value
6807 + bfd_section_vma (h
->u
.def
.section
->output_section
)
6808 + h
->u
.def
.section
->output_offset
);
6809 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6810 einfo (_("%F%P: %s: can't set start address\n"), entry_symbol
.name
);
6817 /* We couldn't find the entry symbol. Try parsing it as a
6819 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
6822 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6823 einfo (_("%F%P: can't set start address\n"));
6829 /* Can't find the entry symbol, and it's not a number. Use
6830 the first address in the text section. */
6831 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
6835 einfo (_("%P: warning: cannot find entry symbol %s;"
6836 " defaulting to %V\n"),
6838 bfd_section_vma (ts
));
6839 if (!bfd_set_start_address (link_info
.output_bfd
,
6840 bfd_section_vma (ts
)))
6841 einfo (_("%F%P: can't set start address\n"));
6846 einfo (_("%P: warning: cannot find entry symbol %s;"
6847 " not setting start address\n"),
6854 /* This is a small function used when we want to ignore errors from
6858 ignore_bfd_errors (const char *fmt ATTRIBUTE_UNUSED
,
6859 va_list ap ATTRIBUTE_UNUSED
)
6861 /* Don't do anything. */
6864 /* Check that the architecture of all the input files is compatible
6865 with the output file. Also call the backend to let it do any
6866 other checking that is needed. */
6871 lang_input_statement_type
*file
;
6873 const bfd_arch_info_type
*compatible
;
6875 for (file
= (void *) file_chain
.head
;
6879 #ifdef ENABLE_PLUGINS
6880 /* Don't check format of files claimed by plugin. */
6881 if (file
->flags
.claimed
)
6883 #endif /* ENABLE_PLUGINS */
6884 input_bfd
= file
->the_bfd
;
6886 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
6887 command_line
.accept_unknown_input_arch
);
6889 /* In general it is not possible to perform a relocatable
6890 link between differing object formats when the input
6891 file has relocations, because the relocations in the
6892 input format may not have equivalent representations in
6893 the output format (and besides BFD does not translate
6894 relocs for other link purposes than a final link). */
6895 if ((bfd_link_relocatable (&link_info
)
6896 || link_info
.emitrelocations
)
6897 && (compatible
== NULL
6898 || (bfd_get_flavour (input_bfd
)
6899 != bfd_get_flavour (link_info
.output_bfd
)))
6900 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
6902 einfo (_("%F%P: relocatable linking with relocations from"
6903 " format %s (%pB) to format %s (%pB) is not supported\n"),
6904 bfd_get_target (input_bfd
), input_bfd
,
6905 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
6906 /* einfo with %F exits. */
6909 if (compatible
== NULL
)
6911 if (command_line
.warn_mismatch
)
6912 einfo (_("%X%P: %s architecture of input file `%pB'"
6913 " is incompatible with %s output\n"),
6914 bfd_printable_name (input_bfd
), input_bfd
,
6915 bfd_printable_name (link_info
.output_bfd
));
6917 else if (bfd_count_sections (input_bfd
))
6919 /* If the input bfd has no contents, it shouldn't set the
6920 private data of the output bfd. */
6922 bfd_error_handler_type pfn
= NULL
;
6924 /* If we aren't supposed to warn about mismatched input
6925 files, temporarily set the BFD error handler to a
6926 function which will do nothing. We still want to call
6927 bfd_merge_private_bfd_data, since it may set up
6928 information which is needed in the output file. */
6929 if (!command_line
.warn_mismatch
)
6930 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
6931 if (!bfd_merge_private_bfd_data (input_bfd
, &link_info
))
6933 if (command_line
.warn_mismatch
)
6934 einfo (_("%X%P: failed to merge target specific data"
6935 " of file %pB\n"), input_bfd
);
6937 if (!command_line
.warn_mismatch
)
6938 bfd_set_error_handler (pfn
);
6943 /* Look through all the global common symbols and attach them to the
6944 correct section. The -sort-common command line switch may be used
6945 to roughly sort the entries by alignment. */
6950 if (link_info
.inhibit_common_definition
)
6952 if (bfd_link_relocatable (&link_info
)
6953 && !command_line
.force_common_definition
)
6956 if (!config
.sort_common
)
6957 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
6962 if (config
.sort_common
== sort_descending
)
6964 for (power
= 4; power
> 0; power
--)
6965 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6968 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6972 for (power
= 0; power
<= 4; power
++)
6973 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6975 power
= (unsigned int) -1;
6976 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6981 /* Place one common symbol in the correct section. */
6984 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
6986 unsigned int power_of_two
;
6990 if (h
->type
!= bfd_link_hash_common
)
6994 power_of_two
= h
->u
.c
.p
->alignment_power
;
6996 if (config
.sort_common
== sort_descending
6997 && power_of_two
< *(unsigned int *) info
)
6999 else if (config
.sort_common
== sort_ascending
7000 && power_of_two
> *(unsigned int *) info
)
7003 section
= h
->u
.c
.p
->section
;
7004 if (!bfd_define_common_symbol (link_info
.output_bfd
, &link_info
, h
))
7005 einfo (_("%F%P: could not define common symbol `%pT': %E\n"),
7008 if (config
.map_file
!= NULL
)
7010 static bfd_boolean header_printed
;
7015 if (!header_printed
)
7017 minfo (_("\nAllocating common symbols\n"));
7018 minfo (_("Common symbol size file\n\n"));
7019 header_printed
= TRUE
;
7022 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
7023 DMGL_ANSI
| DMGL_PARAMS
);
7026 minfo ("%s", h
->root
.string
);
7027 len
= strlen (h
->root
.string
);
7032 len
= strlen (name
);
7048 if (size
<= 0xffffffff)
7049 sprintf (buf
, "%lx", (unsigned long) size
);
7051 sprintf_vma (buf
, size
);
7061 minfo ("%pB\n", section
->owner
);
7067 /* Handle a single orphan section S, placing the orphan into an appropriate
7068 output section. The effects of the --orphan-handling command line
7069 option are handled here. */
7072 ldlang_place_orphan (asection
*s
)
7074 if (config
.orphan_handling
== orphan_handling_discard
)
7076 lang_output_section_statement_type
*os
;
7077 os
= lang_output_section_statement_lookup (DISCARD_SECTION_NAME
, 0,
7079 if (os
->addr_tree
== NULL
7080 && (bfd_link_relocatable (&link_info
)
7081 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
7082 os
->addr_tree
= exp_intop (0);
7083 lang_add_section (&os
->children
, s
, NULL
, os
);
7087 lang_output_section_statement_type
*os
;
7088 const char *name
= s
->name
;
7091 if (config
.orphan_handling
== orphan_handling_error
)
7092 einfo (_("%X%P: error: unplaced orphan section `%pA' from `%pB'\n"),
7095 if (config
.unique_orphan_sections
|| unique_section_p (s
, NULL
))
7096 constraint
= SPECIAL
;
7098 os
= ldemul_place_orphan (s
, name
, constraint
);
7101 os
= lang_output_section_statement_lookup (name
, constraint
, TRUE
);
7102 if (os
->addr_tree
== NULL
7103 && (bfd_link_relocatable (&link_info
)
7104 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
7105 os
->addr_tree
= exp_intop (0);
7106 lang_add_section (&os
->children
, s
, NULL
, os
);
7109 if (config
.orphan_handling
== orphan_handling_warn
)
7110 einfo (_("%P: warning: orphan section `%pA' from `%pB' being "
7111 "placed in section `%s'\n"),
7112 s
, s
->owner
, os
->name
);
7116 /* Run through the input files and ensure that every input section has
7117 somewhere to go. If one is found without a destination then create
7118 an input request and place it into the statement tree. */
7121 lang_place_orphans (void)
7123 LANG_FOR_EACH_INPUT_STATEMENT (file
)
7127 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
7129 if (s
->output_section
== NULL
)
7131 /* This section of the file is not attached, root
7132 around for a sensible place for it to go. */
7134 if (file
->flags
.just_syms
)
7135 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
7136 else if (lang_discard_section_p (s
))
7137 s
->output_section
= bfd_abs_section_ptr
;
7138 else if (strcmp (s
->name
, "COMMON") == 0)
7140 /* This is a lonely common section which must have
7141 come from an archive. We attach to the section
7142 with the wildcard. */
7143 if (!bfd_link_relocatable (&link_info
)
7144 || command_line
.force_common_definition
)
7146 if (default_common_section
== NULL
)
7147 default_common_section
7148 = lang_output_section_statement_lookup (".bss", 0,
7150 lang_add_section (&default_common_section
->children
, s
,
7151 NULL
, default_common_section
);
7155 ldlang_place_orphan (s
);
7162 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
7164 flagword
*ptr_flags
;
7166 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
7172 /* PR 17900: An exclamation mark in the attributes reverses
7173 the sense of any of the attributes that follow. */
7176 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
7180 *ptr_flags
|= SEC_ALLOC
;
7184 *ptr_flags
|= SEC_READONLY
;
7188 *ptr_flags
|= SEC_DATA
;
7192 *ptr_flags
|= SEC_CODE
;
7197 *ptr_flags
|= SEC_LOAD
;
7201 einfo (_("%F%P: invalid character %c (%d) in flags\n"),
7209 /* Call a function on each real input file. This function will be
7210 called on an archive, but not on the elements. */
7213 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
7215 lang_input_statement_type
*f
;
7217 for (f
= (void *) input_file_chain
.head
;
7219 f
= f
->next_real_file
)
7224 /* Call a function on each real file. The function will be called on
7225 all the elements of an archive which are included in the link, but
7226 will not be called on the archive file itself. */
7229 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
7231 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7239 ldlang_add_file (lang_input_statement_type
*entry
)
7241 lang_statement_append (&file_chain
, entry
, &entry
->next
);
7243 /* The BFD linker needs to have a list of all input BFDs involved in
7245 ASSERT (entry
->the_bfd
->link
.next
== NULL
);
7246 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
7248 *link_info
.input_bfds_tail
= entry
->the_bfd
;
7249 link_info
.input_bfds_tail
= &entry
->the_bfd
->link
.next
;
7250 bfd_set_usrdata (entry
->the_bfd
, entry
);
7251 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
7253 /* Look through the sections and check for any which should not be
7254 included in the link. We need to do this now, so that we can
7255 notice when the backend linker tries to report multiple
7256 definition errors for symbols which are in sections we aren't
7257 going to link. FIXME: It might be better to entirely ignore
7258 symbols which are defined in sections which are going to be
7259 discarded. This would require modifying the backend linker for
7260 each backend which might set the SEC_LINK_ONCE flag. If we do
7261 this, we should probably handle SEC_EXCLUDE in the same way. */
7263 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
7267 lang_add_output (const char *name
, int from_script
)
7269 /* Make -o on command line override OUTPUT in script. */
7270 if (!had_output_filename
|| !from_script
)
7272 output_filename
= name
;
7273 had_output_filename
= TRUE
;
7277 lang_output_section_statement_type
*
7278 lang_enter_output_section_statement (const char *output_section_statement_name
,
7279 etree_type
*address_exp
,
7280 enum section_type sectype
,
7282 etree_type
*subalign
,
7285 int align_with_input
)
7287 lang_output_section_statement_type
*os
;
7289 os
= lang_output_section_statement_lookup (output_section_statement_name
,
7291 current_section
= os
;
7293 if (os
->addr_tree
== NULL
)
7295 os
->addr_tree
= address_exp
;
7297 os
->sectype
= sectype
;
7298 if (sectype
!= noload_section
)
7299 os
->flags
= SEC_NO_FLAGS
;
7301 os
->flags
= SEC_NEVER_LOAD
;
7302 os
->block_value
= 1;
7304 /* Make next things chain into subchain of this. */
7305 push_stat_ptr (&os
->children
);
7307 os
->align_lma_with_input
= align_with_input
== ALIGN_WITH_INPUT
;
7308 if (os
->align_lma_with_input
&& align
!= NULL
)
7309 einfo (_("%F%P:%pS: error: align with input and explicit align specified\n"),
7312 os
->subsection_alignment
= subalign
;
7313 os
->section_alignment
= align
;
7315 os
->load_base
= ebase
;
7322 lang_output_statement_type
*new_stmt
;
7324 new_stmt
= new_stat (lang_output_statement
, stat_ptr
);
7325 new_stmt
->name
= output_filename
;
7328 /* Reset the current counters in the regions. */
7331 lang_reset_memory_regions (void)
7333 lang_memory_region_type
*p
= lang_memory_region_list
;
7335 lang_output_section_statement_type
*os
;
7337 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
7339 p
->current
= p
->origin
;
7343 for (os
= (void *) lang_os_list
.head
;
7347 os
->processed_vma
= FALSE
;
7348 os
->processed_lma
= FALSE
;
7351 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
7353 /* Save the last size for possible use by bfd_relax_section. */
7354 o
->rawsize
= o
->size
;
7355 if (!(o
->flags
& SEC_FIXED_SIZE
))
7360 /* Worker for lang_gc_sections_1. */
7363 gc_section_callback (lang_wild_statement_type
*ptr
,
7364 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7366 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
7367 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7368 void *data ATTRIBUTE_UNUSED
)
7370 /* If the wild pattern was marked KEEP, the member sections
7371 should be as well. */
7372 if (ptr
->keep_sections
)
7373 section
->flags
|= SEC_KEEP
;
7376 /* Iterate over sections marking them against GC. */
7379 lang_gc_sections_1 (lang_statement_union_type
*s
)
7381 for (; s
!= NULL
; s
= s
->header
.next
)
7383 switch (s
->header
.type
)
7385 case lang_wild_statement_enum
:
7386 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
7388 case lang_constructors_statement_enum
:
7389 lang_gc_sections_1 (constructor_list
.head
);
7391 case lang_output_section_statement_enum
:
7392 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
7394 case lang_group_statement_enum
:
7395 lang_gc_sections_1 (s
->group_statement
.children
.head
);
7404 lang_gc_sections (void)
7406 /* Keep all sections so marked in the link script. */
7407 lang_gc_sections_1 (statement_list
.head
);
7409 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
7410 the special case of debug info. (See bfd/stabs.c)
7411 Twiddle the flag here, to simplify later linker code. */
7412 if (bfd_link_relocatable (&link_info
))
7414 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7417 #ifdef ENABLE_PLUGINS
7418 if (f
->flags
.claimed
)
7421 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7422 if ((sec
->flags
& SEC_DEBUGGING
) == 0)
7423 sec
->flags
&= ~SEC_EXCLUDE
;
7427 if (link_info
.gc_sections
)
7428 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
7431 /* Worker for lang_find_relro_sections_1. */
7434 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
7435 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7437 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
7438 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7441 /* Discarded, excluded and ignored sections effectively have zero
7443 if (section
->output_section
!= NULL
7444 && section
->output_section
->owner
== link_info
.output_bfd
7445 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
7446 && !IGNORE_SECTION (section
)
7447 && section
->size
!= 0)
7449 bfd_boolean
*has_relro_section
= (bfd_boolean
*) data
;
7450 *has_relro_section
= TRUE
;
7454 /* Iterate over sections for relro sections. */
7457 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
7458 seg_align_type
*seg
,
7459 bfd_boolean
*has_relro_section
)
7461 if (*has_relro_section
)
7464 for (; s
!= NULL
; s
= s
->header
.next
)
7466 if (s
== seg
->relro_end_stat
)
7469 switch (s
->header
.type
)
7471 case lang_wild_statement_enum
:
7472 walk_wild (&s
->wild_statement
,
7473 find_relro_section_callback
,
7476 case lang_constructors_statement_enum
:
7477 lang_find_relro_sections_1 (constructor_list
.head
,
7478 seg
, has_relro_section
);
7480 case lang_output_section_statement_enum
:
7481 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
7482 seg
, has_relro_section
);
7484 case lang_group_statement_enum
:
7485 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
7486 seg
, has_relro_section
);
7495 lang_find_relro_sections (void)
7497 bfd_boolean has_relro_section
= FALSE
;
7499 /* Check all sections in the link script. */
7501 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
7502 &expld
.dataseg
, &has_relro_section
);
7504 if (!has_relro_section
)
7505 link_info
.relro
= FALSE
;
7508 /* Relax all sections until bfd_relax_section gives up. */
7511 lang_relax_sections (bfd_boolean need_layout
)
7513 if (RELAXATION_ENABLED
)
7515 /* We may need more than one relaxation pass. */
7516 int i
= link_info
.relax_pass
;
7518 /* The backend can use it to determine the current pass. */
7519 link_info
.relax_pass
= 0;
7523 /* Keep relaxing until bfd_relax_section gives up. */
7524 bfd_boolean relax_again
;
7526 link_info
.relax_trip
= -1;
7529 link_info
.relax_trip
++;
7531 /* Note: pe-dll.c does something like this also. If you find
7532 you need to change this code, you probably need to change
7533 pe-dll.c also. DJ */
7535 /* Do all the assignments with our current guesses as to
7537 lang_do_assignments (lang_assigning_phase_enum
);
7539 /* We must do this after lang_do_assignments, because it uses
7541 lang_reset_memory_regions ();
7543 /* Perform another relax pass - this time we know where the
7544 globals are, so can make a better guess. */
7545 relax_again
= FALSE
;
7546 lang_size_sections (&relax_again
, FALSE
);
7548 while (relax_again
);
7550 link_info
.relax_pass
++;
7557 /* Final extra sizing to report errors. */
7558 lang_do_assignments (lang_assigning_phase_enum
);
7559 lang_reset_memory_regions ();
7560 lang_size_sections (NULL
, TRUE
);
7564 #ifdef ENABLE_PLUGINS
7565 /* Find the insert point for the plugin's replacement files. We
7566 place them after the first claimed real object file, or if the
7567 first claimed object is an archive member, after the last real
7568 object file immediately preceding the archive. In the event
7569 no objects have been claimed at all, we return the first dummy
7570 object file on the list as the insert point; that works, but
7571 the callee must be careful when relinking the file_chain as it
7572 is not actually on that chain, only the statement_list and the
7573 input_file list; in that case, the replacement files must be
7574 inserted at the head of the file_chain. */
7576 static lang_input_statement_type
*
7577 find_replacements_insert_point (bfd_boolean
*before
)
7579 lang_input_statement_type
*claim1
, *lastobject
;
7580 lastobject
= (void *) input_file_chain
.head
;
7581 for (claim1
= (void *) file_chain
.head
;
7583 claim1
= claim1
->next
)
7585 if (claim1
->flags
.claimed
)
7587 *before
= claim1
->flags
.claim_archive
;
7588 return claim1
->flags
.claim_archive
? lastobject
: claim1
;
7590 /* Update lastobject if this is a real object file. */
7591 if (claim1
->the_bfd
!= NULL
&& claim1
->the_bfd
->my_archive
== NULL
)
7592 lastobject
= claim1
;
7594 /* No files were claimed by the plugin. Choose the last object
7595 file found on the list (maybe the first, dummy entry) as the
7601 /* Find where to insert ADD, an archive element or shared library
7602 added during a rescan. */
7604 static lang_input_statement_type
**
7605 find_rescan_insertion (lang_input_statement_type
*add
)
7607 bfd
*add_bfd
= add
->the_bfd
;
7608 lang_input_statement_type
*f
;
7609 lang_input_statement_type
*last_loaded
= NULL
;
7610 lang_input_statement_type
*before
= NULL
;
7611 lang_input_statement_type
**iter
= NULL
;
7613 if (add_bfd
->my_archive
!= NULL
)
7614 add_bfd
= add_bfd
->my_archive
;
7616 /* First look through the input file chain, to find an object file
7617 before the one we've rescanned. Normal object files always
7618 appear on both the input file chain and the file chain, so this
7619 lets us get quickly to somewhere near the correct place on the
7620 file chain if it is full of archive elements. Archives don't
7621 appear on the file chain, but if an element has been extracted
7622 then their input_statement->next points at it. */
7623 for (f
= (void *) input_file_chain
.head
;
7625 f
= f
->next_real_file
)
7627 if (f
->the_bfd
== add_bfd
)
7629 before
= last_loaded
;
7630 if (f
->next
!= NULL
)
7631 return &f
->next
->next
;
7633 if (f
->the_bfd
!= NULL
&& f
->next
!= NULL
)
7637 for (iter
= before
? &before
->next
: &file_chain
.head
->input_statement
.next
;
7639 iter
= &(*iter
)->next
)
7640 if (!(*iter
)->flags
.claim_archive
7641 && (*iter
)->the_bfd
->my_archive
== NULL
)
7647 /* Insert SRCLIST into DESTLIST after given element by chaining
7648 on FIELD as the next-pointer. (Counterintuitively does not need
7649 a pointer to the actual after-node itself, just its chain field.) */
7652 lang_list_insert_after (lang_statement_list_type
*destlist
,
7653 lang_statement_list_type
*srclist
,
7654 lang_statement_union_type
**field
)
7656 *(srclist
->tail
) = *field
;
7657 *field
= srclist
->head
;
7658 if (destlist
->tail
== field
)
7659 destlist
->tail
= srclist
->tail
;
7662 /* Detach new nodes added to DESTLIST since the time ORIGLIST
7663 was taken as a copy of it and leave them in ORIGLIST. */
7666 lang_list_remove_tail (lang_statement_list_type
*destlist
,
7667 lang_statement_list_type
*origlist
)
7669 union lang_statement_union
**savetail
;
7670 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
7671 ASSERT (origlist
->head
== destlist
->head
);
7672 savetail
= origlist
->tail
;
7673 origlist
->head
= *(savetail
);
7674 origlist
->tail
= destlist
->tail
;
7675 destlist
->tail
= savetail
;
7679 static lang_statement_union_type
**
7680 find_next_input_statement (lang_statement_union_type
**s
)
7682 for ( ; *s
; s
= &(*s
)->header
.next
)
7684 lang_statement_union_type
**t
;
7685 switch ((*s
)->header
.type
)
7687 case lang_input_statement_enum
:
7689 case lang_wild_statement_enum
:
7690 t
= &(*s
)->wild_statement
.children
.head
;
7692 case lang_group_statement_enum
:
7693 t
= &(*s
)->group_statement
.children
.head
;
7695 case lang_output_section_statement_enum
:
7696 t
= &(*s
)->output_section_statement
.children
.head
;
7701 t
= find_next_input_statement (t
);
7707 #endif /* ENABLE_PLUGINS */
7709 /* Add NAME to the list of garbage collection entry points. */
7712 lang_add_gc_name (const char *name
)
7714 struct bfd_sym_chain
*sym
;
7719 sym
= stat_alloc (sizeof (*sym
));
7721 sym
->next
= link_info
.gc_sym_list
;
7723 link_info
.gc_sym_list
= sym
;
7726 /* Check relocations. */
7729 lang_check_relocs (void)
7731 if (link_info
.check_relocs_after_open_input
)
7735 for (abfd
= link_info
.input_bfds
;
7736 abfd
!= (bfd
*) NULL
; abfd
= abfd
->link
.next
)
7737 if (!bfd_link_check_relocs (abfd
, &link_info
))
7739 /* No object output, fail return. */
7740 config
.make_executable
= FALSE
;
7741 /* Note: we do not abort the loop, but rather
7742 continue the scan in case there are other
7743 bad relocations to report. */
7748 /* Look through all output sections looking for places where we can
7749 propagate forward the lma region. */
7752 lang_propagate_lma_regions (void)
7754 lang_output_section_statement_type
*os
;
7756 for (os
= (void *) lang_os_list
.head
;
7760 if (os
->prev
!= NULL
7761 && os
->lma_region
== NULL
7762 && os
->load_base
== NULL
7763 && os
->addr_tree
== NULL
7764 && os
->region
== os
->prev
->region
)
7765 os
->lma_region
= os
->prev
->lma_region
;
7772 /* Finalize dynamic list. */
7773 if (link_info
.dynamic_list
)
7774 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
7776 current_target
= default_target
;
7778 /* Open the output file. */
7779 lang_for_each_statement (ldlang_open_output
);
7782 ldemul_create_output_section_statements ();
7784 /* Add to the hash table all undefineds on the command line. */
7785 lang_place_undefineds ();
7787 if (!bfd_section_already_linked_table_init ())
7788 einfo (_("%F%P: can not create hash table: %E\n"));
7790 /* Create a bfd for each input file. */
7791 current_target
= default_target
;
7792 lang_statement_iteration
++;
7793 open_input_bfds (statement_list
.head
, OPEN_BFD_NORMAL
);
7794 /* open_input_bfds also handles assignments, so we can give values
7795 to symbolic origin/length now. */
7796 lang_do_memory_regions ();
7798 #ifdef ENABLE_PLUGINS
7799 if (link_info
.lto_plugin_active
)
7801 lang_statement_list_type added
;
7802 lang_statement_list_type files
, inputfiles
;
7804 /* Now all files are read, let the plugin(s) decide if there
7805 are any more to be added to the link before we call the
7806 emulation's after_open hook. We create a private list of
7807 input statements for this purpose, which we will eventually
7808 insert into the global statement list after the first claimed
7811 /* We need to manipulate all three chains in synchrony. */
7813 inputfiles
= input_file_chain
;
7814 if (plugin_call_all_symbols_read ())
7815 einfo (_("%F%P: %s: plugin reported error after all symbols read\n"),
7816 plugin_error_plugin ());
7817 /* Open any newly added files, updating the file chains. */
7818 plugin_undefs
= link_info
.hash
->undefs_tail
;
7819 open_input_bfds (*added
.tail
, OPEN_BFD_NORMAL
);
7820 if (plugin_undefs
== link_info
.hash
->undefs_tail
)
7821 plugin_undefs
= NULL
;
7822 /* Restore the global list pointer now they have all been added. */
7823 lang_list_remove_tail (stat_ptr
, &added
);
7824 /* And detach the fresh ends of the file lists. */
7825 lang_list_remove_tail (&file_chain
, &files
);
7826 lang_list_remove_tail (&input_file_chain
, &inputfiles
);
7827 /* Were any new files added? */
7828 if (added
.head
!= NULL
)
7830 /* If so, we will insert them into the statement list immediately
7831 after the first input file that was claimed by the plugin,
7832 unless that file was an archive in which case it is inserted
7833 immediately before. */
7835 lang_statement_union_type
**prev
;
7836 plugin_insert
= find_replacements_insert_point (&before
);
7837 /* If a plugin adds input files without having claimed any, we
7838 don't really have a good idea where to place them. Just putting
7839 them at the start or end of the list is liable to leave them
7840 outside the crtbegin...crtend range. */
7841 ASSERT (plugin_insert
!= NULL
);
7842 /* Splice the new statement list into the old one. */
7843 prev
= &plugin_insert
->header
.next
;
7846 prev
= find_next_input_statement (prev
);
7847 if (*prev
!= (void *) plugin_insert
->next_real_file
)
7849 /* We didn't find the expected input statement.
7850 Fall back to adding after plugin_insert. */
7851 prev
= &plugin_insert
->header
.next
;
7854 lang_list_insert_after (stat_ptr
, &added
, prev
);
7855 /* Likewise for the file chains. */
7856 lang_list_insert_after (&input_file_chain
, &inputfiles
,
7857 (void *) &plugin_insert
->next_real_file
);
7858 /* We must be careful when relinking file_chain; we may need to
7859 insert the new files at the head of the list if the insert
7860 point chosen is the dummy first input file. */
7861 if (plugin_insert
->filename
)
7862 lang_list_insert_after (&file_chain
, &files
,
7863 (void *) &plugin_insert
->next
);
7865 lang_list_insert_after (&file_chain
, &files
, &file_chain
.head
);
7867 /* Rescan archives in case new undefined symbols have appeared. */
7869 lang_statement_iteration
++;
7870 open_input_bfds (statement_list
.head
, OPEN_BFD_RESCAN
);
7871 lang_list_remove_tail (&file_chain
, &files
);
7872 while (files
.head
!= NULL
)
7874 lang_input_statement_type
**insert
;
7875 lang_input_statement_type
**iter
, *temp
;
7878 insert
= find_rescan_insertion (&files
.head
->input_statement
);
7879 /* All elements from an archive can be added at once. */
7880 iter
= &files
.head
->input_statement
.next
;
7881 my_arch
= files
.head
->input_statement
.the_bfd
->my_archive
;
7882 if (my_arch
!= NULL
)
7883 for (; *iter
!= NULL
; iter
= &(*iter
)->next
)
7884 if ((*iter
)->the_bfd
->my_archive
!= my_arch
)
7887 *insert
= &files
.head
->input_statement
;
7888 files
.head
= (lang_statement_union_type
*) *iter
;
7890 if (my_arch
!= NULL
)
7892 lang_input_statement_type
*parent
= bfd_usrdata (my_arch
);
7894 parent
->next
= (lang_input_statement_type
*)
7896 - offsetof (lang_input_statement_type
, next
));
7901 #endif /* ENABLE_PLUGINS */
7903 /* Make sure that nobody has tried to add a symbol to this list
7905 ASSERT (link_info
.gc_sym_list
== NULL
);
7907 link_info
.gc_sym_list
= &entry_symbol
;
7909 if (entry_symbol
.name
== NULL
)
7911 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
7913 /* entry_symbol is normally initialied by a ENTRY definition in the
7914 linker script or the -e command line option. But if neither of
7915 these have been used, the target specific backend may still have
7916 provided an entry symbol via a call to lang_default_entry().
7917 Unfortunately this value will not be processed until lang_end()
7918 is called, long after this function has finished. So detect this
7919 case here and add the target's entry symbol to the list of starting
7920 points for garbage collection resolution. */
7921 lang_add_gc_name (entry_symbol_default
);
7924 lang_add_gc_name (link_info
.init_function
);
7925 lang_add_gc_name (link_info
.fini_function
);
7927 ldemul_after_open ();
7928 if (config
.map_file
!= NULL
)
7929 lang_print_asneeded ();
7933 bfd_section_already_linked_table_free ();
7935 /* Make sure that we're not mixing architectures. We call this
7936 after all the input files have been opened, but before we do any
7937 other processing, so that any operations merge_private_bfd_data
7938 does on the output file will be known during the rest of the
7942 /* Handle .exports instead of a version script if we're told to do so. */
7943 if (command_line
.version_exports_section
)
7944 lang_do_version_exports_section ();
7946 /* Build all sets based on the information gathered from the input
7948 ldctor_build_sets ();
7950 /* Give initial values for __start and __stop symbols, so that ELF
7951 gc_sections will keep sections referenced by these symbols. Must
7952 be done before lang_do_assignments below. */
7953 if (config
.build_constructors
)
7954 lang_init_start_stop ();
7956 /* PR 13683: We must rerun the assignments prior to running garbage
7957 collection in order to make sure that all symbol aliases are resolved. */
7958 lang_do_assignments (lang_mark_phase_enum
);
7959 expld
.phase
= lang_first_phase_enum
;
7961 /* Size up the common data. */
7964 /* Remove unreferenced sections if asked to. */
7965 lang_gc_sections ();
7967 /* Check relocations. */
7968 lang_check_relocs ();
7970 ldemul_after_check_relocs ();
7972 /* Update wild statements. */
7973 update_wild_statements (statement_list
.head
);
7975 /* Run through the contours of the script and attach input sections
7976 to the correct output sections. */
7977 lang_statement_iteration
++;
7978 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
7980 /* Start at the statement immediately after the special abs_section
7981 output statement, so that it isn't reordered. */
7982 process_insert_statements (&lang_os_list
.head
->header
.next
);
7984 ldemul_before_place_orphans ();
7986 /* Find any sections not attached explicitly and handle them. */
7987 lang_place_orphans ();
7989 if (!bfd_link_relocatable (&link_info
))
7993 /* Merge SEC_MERGE sections. This has to be done after GC of
7994 sections, so that GCed sections are not merged, but before
7995 assigning dynamic symbols, since removing whole input sections
7997 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
7999 /* Look for a text section and set the readonly attribute in it. */
8000 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
8004 if (config
.text_read_only
)
8005 found
->flags
|= SEC_READONLY
;
8007 found
->flags
&= ~SEC_READONLY
;
8011 /* Merge together CTF sections. After this, only the symtab-dependent
8012 function and data object sections need adjustment. */
8015 /* Emit the CTF, iff the emulation doesn't need to do late emission after
8016 examining things laid out late, like the strtab. */
8019 /* Copy forward lma regions for output sections in same lma region. */
8020 lang_propagate_lma_regions ();
8022 /* Defining __start/__stop symbols early for --gc-sections to work
8023 around a glibc build problem can result in these symbols being
8024 defined when they should not be. Fix them now. */
8025 if (config
.build_constructors
)
8026 lang_undef_start_stop ();
8028 /* Define .startof./.sizeof. symbols with preliminary values before
8029 dynamic symbols are created. */
8030 if (!bfd_link_relocatable (&link_info
))
8031 lang_init_startof_sizeof ();
8033 /* Do anything special before sizing sections. This is where ELF
8034 and other back-ends size dynamic sections. */
8035 ldemul_before_allocation ();
8037 /* We must record the program headers before we try to fix the
8038 section positions, since they will affect SIZEOF_HEADERS. */
8039 lang_record_phdrs ();
8041 /* Check relro sections. */
8042 if (link_info
.relro
&& !bfd_link_relocatable (&link_info
))
8043 lang_find_relro_sections ();
8045 /* Size up the sections. */
8046 lang_size_sections (NULL
, !RELAXATION_ENABLED
);
8048 /* See if anything special should be done now we know how big
8049 everything is. This is where relaxation is done. */
8050 ldemul_after_allocation ();
8052 /* Fix any __start, __stop, .startof. or .sizeof. symbols. */
8053 lang_finalize_start_stop ();
8055 /* Do all the assignments again, to report errors. Assignment
8056 statements are processed multiple times, updating symbols; In
8057 open_input_bfds, lang_do_assignments, and lang_size_sections.
8058 Since lang_relax_sections calls lang_do_assignments, symbols are
8059 also updated in ldemul_after_allocation. */
8060 lang_do_assignments (lang_final_phase_enum
);
8064 /* Convert absolute symbols to section relative. */
8065 ldexp_finalize_syms ();
8067 /* Make sure that the section addresses make sense. */
8068 if (command_line
.check_section_addresses
)
8069 lang_check_section_addresses ();
8071 /* Check any required symbols are known. */
8072 ldlang_check_require_defined_symbols ();
8077 /* EXPORTED TO YACC */
8080 lang_add_wild (struct wildcard_spec
*filespec
,
8081 struct wildcard_list
*section_list
,
8082 bfd_boolean keep_sections
)
8084 struct wildcard_list
*curr
, *next
;
8085 lang_wild_statement_type
*new_stmt
;
8087 /* Reverse the list as the parser puts it back to front. */
8088 for (curr
= section_list
, section_list
= NULL
;
8090 section_list
= curr
, curr
= next
)
8093 curr
->next
= section_list
;
8096 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
8098 if (strcmp (filespec
->name
, "*") == 0)
8099 filespec
->name
= NULL
;
8100 else if (!wildcardp (filespec
->name
))
8101 lang_has_input_file
= TRUE
;
8104 new_stmt
= new_stat (lang_wild_statement
, stat_ptr
);
8105 new_stmt
->filename
= NULL
;
8106 new_stmt
->filenames_sorted
= FALSE
;
8107 new_stmt
->section_flag_list
= NULL
;
8108 new_stmt
->exclude_name_list
= NULL
;
8109 if (filespec
!= NULL
)
8111 new_stmt
->filename
= filespec
->name
;
8112 new_stmt
->filenames_sorted
= filespec
->sorted
== by_name
;
8113 new_stmt
->section_flag_list
= filespec
->section_flag_list
;
8114 new_stmt
->exclude_name_list
= filespec
->exclude_name_list
;
8116 new_stmt
->section_list
= section_list
;
8117 new_stmt
->keep_sections
= keep_sections
;
8118 lang_list_init (&new_stmt
->children
);
8119 analyze_walk_wild_section_handler (new_stmt
);
8123 lang_section_start (const char *name
, etree_type
*address
,
8124 const segment_type
*segment
)
8126 lang_address_statement_type
*ad
;
8128 ad
= new_stat (lang_address_statement
, stat_ptr
);
8129 ad
->section_name
= name
;
8130 ad
->address
= address
;
8131 ad
->segment
= segment
;
8134 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
8135 because of a -e argument on the command line, or zero if this is
8136 called by ENTRY in a linker script. Command line arguments take
8140 lang_add_entry (const char *name
, bfd_boolean cmdline
)
8142 if (entry_symbol
.name
== NULL
8144 || !entry_from_cmdline
)
8146 entry_symbol
.name
= name
;
8147 entry_from_cmdline
= cmdline
;
8151 /* Set the default start symbol to NAME. .em files should use this,
8152 not lang_add_entry, to override the use of "start" if neither the
8153 linker script nor the command line specifies an entry point. NAME
8154 must be permanently allocated. */
8156 lang_default_entry (const char *name
)
8158 entry_symbol_default
= name
;
8162 lang_add_target (const char *name
)
8164 lang_target_statement_type
*new_stmt
;
8166 new_stmt
= new_stat (lang_target_statement
, stat_ptr
);
8167 new_stmt
->target
= name
;
8171 lang_add_map (const char *name
)
8178 map_option_f
= TRUE
;
8186 lang_add_fill (fill_type
*fill
)
8188 lang_fill_statement_type
*new_stmt
;
8190 new_stmt
= new_stat (lang_fill_statement
, stat_ptr
);
8191 new_stmt
->fill
= fill
;
8195 lang_add_data (int type
, union etree_union
*exp
)
8197 lang_data_statement_type
*new_stmt
;
8199 new_stmt
= new_stat (lang_data_statement
, stat_ptr
);
8200 new_stmt
->exp
= exp
;
8201 new_stmt
->type
= type
;
8204 /* Create a new reloc statement. RELOC is the BFD relocation type to
8205 generate. HOWTO is the corresponding howto structure (we could
8206 look this up, but the caller has already done so). SECTION is the
8207 section to generate a reloc against, or NAME is the name of the
8208 symbol to generate a reloc against. Exactly one of SECTION and
8209 NAME must be NULL. ADDEND is an expression for the addend. */
8212 lang_add_reloc (bfd_reloc_code_real_type reloc
,
8213 reloc_howto_type
*howto
,
8216 union etree_union
*addend
)
8218 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
8222 p
->section
= section
;
8224 p
->addend_exp
= addend
;
8226 p
->addend_value
= 0;
8227 p
->output_section
= NULL
;
8228 p
->output_offset
= 0;
8231 lang_assignment_statement_type
*
8232 lang_add_assignment (etree_type
*exp
)
8234 lang_assignment_statement_type
*new_stmt
;
8236 new_stmt
= new_stat (lang_assignment_statement
, stat_ptr
);
8237 new_stmt
->exp
= exp
;
8242 lang_add_attribute (enum statement_enum attribute
)
8244 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
8248 lang_startup (const char *name
)
8250 if (first_file
->filename
!= NULL
)
8252 einfo (_("%F%P: multiple STARTUP files\n"));
8254 first_file
->filename
= name
;
8255 first_file
->local_sym_name
= name
;
8256 first_file
->flags
.real
= TRUE
;
8260 lang_float (bfd_boolean maybe
)
8262 lang_float_flag
= maybe
;
8266 /* Work out the load- and run-time regions from a script statement, and
8267 store them in *LMA_REGION and *REGION respectively.
8269 MEMSPEC is the name of the run-time region, or the value of
8270 DEFAULT_MEMORY_REGION if the statement didn't specify one.
8271 LMA_MEMSPEC is the name of the load-time region, or null if the
8272 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
8273 had an explicit load address.
8275 It is an error to specify both a load region and a load address. */
8278 lang_get_regions (lang_memory_region_type
**region
,
8279 lang_memory_region_type
**lma_region
,
8280 const char *memspec
,
8281 const char *lma_memspec
,
8282 bfd_boolean have_lma
,
8283 bfd_boolean have_vma
)
8285 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
8287 /* If no runtime region or VMA has been specified, but the load region
8288 has been specified, then use the load region for the runtime region
8290 if (lma_memspec
!= NULL
8292 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
8293 *region
= *lma_region
;
8295 *region
= lang_memory_region_lookup (memspec
, FALSE
);
8297 if (have_lma
&& lma_memspec
!= 0)
8298 einfo (_("%X%P:%pS: section has both a load address and a load region\n"),
8303 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
8304 lang_output_section_phdr_list
*phdrs
,
8305 const char *lma_memspec
)
8307 lang_get_regions (¤t_section
->region
,
8308 ¤t_section
->lma_region
,
8309 memspec
, lma_memspec
,
8310 current_section
->load_base
!= NULL
,
8311 current_section
->addr_tree
!= NULL
);
8313 current_section
->fill
= fill
;
8314 current_section
->phdrs
= phdrs
;
8318 /* Set the output format type. -oformat overrides scripts. */
8321 lang_add_output_format (const char *format
,
8326 if (output_target
== NULL
|| !from_script
)
8328 if (command_line
.endian
== ENDIAN_BIG
8331 else if (command_line
.endian
== ENDIAN_LITTLE
8335 output_target
= format
;
8340 lang_add_insert (const char *where
, int is_before
)
8342 lang_insert_statement_type
*new_stmt
;
8344 new_stmt
= new_stat (lang_insert_statement
, stat_ptr
);
8345 new_stmt
->where
= where
;
8346 new_stmt
->is_before
= is_before
;
8347 saved_script_handle
= previous_script_handle
;
8350 /* Enter a group. This creates a new lang_group_statement, and sets
8351 stat_ptr to build new statements within the group. */
8354 lang_enter_group (void)
8356 lang_group_statement_type
*g
;
8358 g
= new_stat (lang_group_statement
, stat_ptr
);
8359 lang_list_init (&g
->children
);
8360 push_stat_ptr (&g
->children
);
8363 /* Leave a group. This just resets stat_ptr to start writing to the
8364 regular list of statements again. Note that this will not work if
8365 groups can occur inside anything else which can adjust stat_ptr,
8366 but currently they can't. */
8369 lang_leave_group (void)
8374 /* Add a new program header. This is called for each entry in a PHDRS
8375 command in a linker script. */
8378 lang_new_phdr (const char *name
,
8380 bfd_boolean filehdr
,
8385 struct lang_phdr
*n
, **pp
;
8388 n
= stat_alloc (sizeof (struct lang_phdr
));
8391 n
->type
= exp_get_vma (type
, 0, "program header type");
8392 n
->filehdr
= filehdr
;
8397 hdrs
= n
->type
== 1 && (phdrs
|| filehdr
);
8399 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
8402 && !((*pp
)->filehdr
|| (*pp
)->phdrs
))
8404 einfo (_("%X%P:%pS: PHDRS and FILEHDR are not supported"
8405 " when prior PT_LOAD headers lack them\n"), NULL
);
8412 /* Record the program header information in the output BFD. FIXME: We
8413 should not be calling an ELF specific function here. */
8416 lang_record_phdrs (void)
8420 lang_output_section_phdr_list
*last
;
8421 struct lang_phdr
*l
;
8422 lang_output_section_statement_type
*os
;
8425 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
8428 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
8435 for (os
= (void *) lang_os_list
.head
;
8439 lang_output_section_phdr_list
*pl
;
8441 if (os
->constraint
< 0)
8449 if (os
->sectype
== noload_section
8450 || os
->bfd_section
== NULL
8451 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
8454 /* Don't add orphans to PT_INTERP header. */
8460 lang_output_section_statement_type
*tmp_os
;
8462 /* If we have not run across a section with a program
8463 header assigned to it yet, then scan forwards to find
8464 one. This prevents inconsistencies in the linker's
8465 behaviour when a script has specified just a single
8466 header and there are sections in that script which are
8467 not assigned to it, and which occur before the first
8468 use of that header. See here for more details:
8469 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
8470 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
8473 last
= tmp_os
->phdrs
;
8477 einfo (_("%F%P: no sections assigned to phdrs\n"));
8482 if (os
->bfd_section
== NULL
)
8485 for (; pl
!= NULL
; pl
= pl
->next
)
8487 if (strcmp (pl
->name
, l
->name
) == 0)
8492 secs
= (asection
**) xrealloc (secs
,
8493 alc
* sizeof (asection
*));
8495 secs
[c
] = os
->bfd_section
;
8502 if (l
->flags
== NULL
)
8505 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
8510 at
= exp_get_vma (l
->at
, 0, "phdr load address");
8512 if (!bfd_record_phdr (link_info
.output_bfd
, l
->type
,
8513 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
8514 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
8515 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
8520 /* Make sure all the phdr assignments succeeded. */
8521 for (os
= (void *) lang_os_list
.head
;
8525 lang_output_section_phdr_list
*pl
;
8527 if (os
->constraint
< 0
8528 || os
->bfd_section
== NULL
)
8531 for (pl
= os
->phdrs
;
8534 if (!pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
8535 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
8536 os
->name
, pl
->name
);
8540 /* Record a list of sections which may not be cross referenced. */
8543 lang_add_nocrossref (lang_nocrossref_type
*l
)
8545 struct lang_nocrossrefs
*n
;
8547 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
8548 n
->next
= nocrossref_list
;
8550 n
->onlyfirst
= FALSE
;
8551 nocrossref_list
= n
;
8553 /* Set notice_all so that we get informed about all symbols. */
8554 link_info
.notice_all
= TRUE
;
8557 /* Record a section that cannot be referenced from a list of sections. */
8560 lang_add_nocrossref_to (lang_nocrossref_type
*l
)
8562 lang_add_nocrossref (l
);
8563 nocrossref_list
->onlyfirst
= TRUE
;
8566 /* Overlay handling. We handle overlays with some static variables. */
8568 /* The overlay virtual address. */
8569 static etree_type
*overlay_vma
;
8570 /* And subsection alignment. */
8571 static etree_type
*overlay_subalign
;
8573 /* An expression for the maximum section size seen so far. */
8574 static etree_type
*overlay_max
;
8576 /* A list of all the sections in this overlay. */
8578 struct overlay_list
{
8579 struct overlay_list
*next
;
8580 lang_output_section_statement_type
*os
;
8583 static struct overlay_list
*overlay_list
;
8585 /* Start handling an overlay. */
8588 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
8590 /* The grammar should prevent nested overlays from occurring. */
8591 ASSERT (overlay_vma
== NULL
8592 && overlay_subalign
== NULL
8593 && overlay_max
== NULL
);
8595 overlay_vma
= vma_expr
;
8596 overlay_subalign
= subalign
;
8599 /* Start a section in an overlay. We handle this by calling
8600 lang_enter_output_section_statement with the correct VMA.
8601 lang_leave_overlay sets up the LMA and memory regions. */
8604 lang_enter_overlay_section (const char *name
)
8606 struct overlay_list
*n
;
8609 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
8610 0, overlay_subalign
, 0, 0, 0);
8612 /* If this is the first section, then base the VMA of future
8613 sections on this one. This will work correctly even if `.' is
8614 used in the addresses. */
8615 if (overlay_list
== NULL
)
8616 overlay_vma
= exp_nameop (ADDR
, name
);
8618 /* Remember the section. */
8619 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
8620 n
->os
= current_section
;
8621 n
->next
= overlay_list
;
8624 size
= exp_nameop (SIZEOF
, name
);
8626 /* Arrange to work out the maximum section end address. */
8627 if (overlay_max
== NULL
)
8630 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
8633 /* Finish a section in an overlay. There isn't any special to do
8637 lang_leave_overlay_section (fill_type
*fill
,
8638 lang_output_section_phdr_list
*phdrs
)
8645 name
= current_section
->name
;
8647 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
8648 region and that no load-time region has been specified. It doesn't
8649 really matter what we say here, since lang_leave_overlay will
8651 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
8653 /* Define the magic symbols. */
8655 clean
= (char *) xmalloc (strlen (name
) + 1);
8657 for (s1
= name
; *s1
!= '\0'; s1
++)
8658 if (ISALNUM (*s1
) || *s1
== '_')
8662 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_start_");
8663 sprintf (buf
, "__load_start_%s", clean
);
8664 lang_add_assignment (exp_provide (buf
,
8665 exp_nameop (LOADADDR
, name
),
8668 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_stop_");
8669 sprintf (buf
, "__load_stop_%s", clean
);
8670 lang_add_assignment (exp_provide (buf
,
8672 exp_nameop (LOADADDR
, name
),
8673 exp_nameop (SIZEOF
, name
)),
8679 /* Finish an overlay. If there are any overlay wide settings, this
8680 looks through all the sections in the overlay and sets them. */
8683 lang_leave_overlay (etree_type
*lma_expr
,
8686 const char *memspec
,
8687 lang_output_section_phdr_list
*phdrs
,
8688 const char *lma_memspec
)
8690 lang_memory_region_type
*region
;
8691 lang_memory_region_type
*lma_region
;
8692 struct overlay_list
*l
;
8693 lang_nocrossref_type
*nocrossref
;
8695 lang_get_regions (®ion
, &lma_region
,
8696 memspec
, lma_memspec
,
8697 lma_expr
!= NULL
, FALSE
);
8701 /* After setting the size of the last section, set '.' to end of the
8703 if (overlay_list
!= NULL
)
8705 overlay_list
->os
->update_dot
= 1;
8706 overlay_list
->os
->update_dot_tree
8707 = exp_assign (".", exp_binop ('+', overlay_vma
, overlay_max
), FALSE
);
8713 struct overlay_list
*next
;
8715 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
8718 l
->os
->region
= region
;
8719 l
->os
->lma_region
= lma_region
;
8721 /* The first section has the load address specified in the
8722 OVERLAY statement. The rest are worked out from that.
8723 The base address is not needed (and should be null) if
8724 an LMA region was specified. */
8727 l
->os
->load_base
= lma_expr
;
8728 l
->os
->sectype
= first_overlay_section
;
8730 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
8731 l
->os
->phdrs
= phdrs
;
8735 lang_nocrossref_type
*nc
;
8737 nc
= (lang_nocrossref_type
*) xmalloc (sizeof *nc
);
8738 nc
->name
= l
->os
->name
;
8739 nc
->next
= nocrossref
;
8748 if (nocrossref
!= NULL
)
8749 lang_add_nocrossref (nocrossref
);
8752 overlay_list
= NULL
;
8754 overlay_subalign
= NULL
;
8757 /* Version handling. This is only useful for ELF. */
8759 /* If PREV is NULL, return first version pattern matching particular symbol.
8760 If PREV is non-NULL, return first version pattern matching particular
8761 symbol after PREV (previously returned by lang_vers_match). */
8763 static struct bfd_elf_version_expr
*
8764 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
8765 struct bfd_elf_version_expr
*prev
,
8769 const char *cxx_sym
= sym
;
8770 const char *java_sym
= sym
;
8771 struct bfd_elf_version_expr
*expr
= NULL
;
8772 enum demangling_styles curr_style
;
8774 curr_style
= CURRENT_DEMANGLING_STYLE
;
8775 cplus_demangle_set_style (no_demangling
);
8776 c_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_NO_OPTS
);
8779 cplus_demangle_set_style (curr_style
);
8781 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8783 cxx_sym
= bfd_demangle (link_info
.output_bfd
, sym
,
8784 DMGL_PARAMS
| DMGL_ANSI
);
8788 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8790 java_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_JAVA
);
8795 if (head
->htab
&& (prev
== NULL
|| prev
->literal
))
8797 struct bfd_elf_version_expr e
;
8799 switch (prev
? prev
->mask
: 0)
8802 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
8805 expr
= (struct bfd_elf_version_expr
*)
8806 htab_find ((htab_t
) head
->htab
, &e
);
8807 while (expr
&& strcmp (expr
->pattern
, c_sym
) == 0)
8808 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
8814 case BFD_ELF_VERSION_C_TYPE
:
8815 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8817 e
.pattern
= cxx_sym
;
8818 expr
= (struct bfd_elf_version_expr
*)
8819 htab_find ((htab_t
) head
->htab
, &e
);
8820 while (expr
&& strcmp (expr
->pattern
, cxx_sym
) == 0)
8821 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
8827 case BFD_ELF_VERSION_CXX_TYPE
:
8828 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8830 e
.pattern
= java_sym
;
8831 expr
= (struct bfd_elf_version_expr
*)
8832 htab_find ((htab_t
) head
->htab
, &e
);
8833 while (expr
&& strcmp (expr
->pattern
, java_sym
) == 0)
8834 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8845 /* Finally, try the wildcards. */
8846 if (prev
== NULL
|| prev
->literal
)
8847 expr
= head
->remaining
;
8850 for (; expr
; expr
= expr
->next
)
8857 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
8860 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8862 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
8866 if (fnmatch (expr
->pattern
, s
, 0) == 0)
8872 free ((char *) c_sym
);
8874 free ((char *) cxx_sym
);
8875 if (java_sym
!= sym
)
8876 free ((char *) java_sym
);
8880 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
8881 return a pointer to the symbol name with any backslash quotes removed. */
8884 realsymbol (const char *pattern
)
8887 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
8888 char *s
, *symbol
= (char *) xmalloc (strlen (pattern
) + 1);
8890 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
8892 /* It is a glob pattern only if there is no preceding
8896 /* Remove the preceding backslash. */
8903 if (*p
== '?' || *p
== '*' || *p
== '[')
8910 backslash
= *p
== '\\';
8926 /* This is called for each variable name or match expression. NEW_NAME is
8927 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
8928 pattern to be matched against symbol names. */
8930 struct bfd_elf_version_expr
*
8931 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
8932 const char *new_name
,
8934 bfd_boolean literal_p
)
8936 struct bfd_elf_version_expr
*ret
;
8938 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
8942 ret
->literal
= TRUE
;
8943 ret
->pattern
= literal_p
? new_name
: realsymbol (new_name
);
8944 if (ret
->pattern
== NULL
)
8946 ret
->pattern
= new_name
;
8947 ret
->literal
= FALSE
;
8950 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
8951 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
8952 else if (strcasecmp (lang
, "C++") == 0)
8953 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
8954 else if (strcasecmp (lang
, "Java") == 0)
8955 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
8958 einfo (_("%X%P: unknown language `%s' in version information\n"),
8960 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
8963 return ldemul_new_vers_pattern (ret
);
8966 /* This is called for each set of variable names and match
8969 struct bfd_elf_version_tree
*
8970 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
8971 struct bfd_elf_version_expr
*locals
)
8973 struct bfd_elf_version_tree
*ret
;
8975 ret
= (struct bfd_elf_version_tree
*) xcalloc (1, sizeof *ret
);
8976 ret
->globals
.list
= globals
;
8977 ret
->locals
.list
= locals
;
8978 ret
->match
= lang_vers_match
;
8979 ret
->name_indx
= (unsigned int) -1;
8983 /* This static variable keeps track of version indices. */
8985 static int version_index
;
8988 version_expr_head_hash (const void *p
)
8990 const struct bfd_elf_version_expr
*e
=
8991 (const struct bfd_elf_version_expr
*) p
;
8993 return htab_hash_string (e
->pattern
);
8997 version_expr_head_eq (const void *p1
, const void *p2
)
8999 const struct bfd_elf_version_expr
*e1
=
9000 (const struct bfd_elf_version_expr
*) p1
;
9001 const struct bfd_elf_version_expr
*e2
=
9002 (const struct bfd_elf_version_expr
*) p2
;
9004 return strcmp (e1
->pattern
, e2
->pattern
) == 0;
9008 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
9011 struct bfd_elf_version_expr
*e
, *next
;
9012 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
9014 for (e
= head
->list
; e
; e
= e
->next
)
9018 head
->mask
|= e
->mask
;
9023 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
9024 version_expr_head_eq
, NULL
);
9025 list_loc
= &head
->list
;
9026 remaining_loc
= &head
->remaining
;
9027 for (e
= head
->list
; e
; e
= next
)
9033 remaining_loc
= &e
->next
;
9037 void **loc
= htab_find_slot ((htab_t
) head
->htab
, e
, INSERT
);
9041 struct bfd_elf_version_expr
*e1
, *last
;
9043 e1
= (struct bfd_elf_version_expr
*) *loc
;
9047 if (e1
->mask
== e
->mask
)
9055 while (e1
&& strcmp (e1
->pattern
, e
->pattern
) == 0);
9059 /* This is a duplicate. */
9060 /* FIXME: Memory leak. Sometimes pattern is not
9061 xmalloced alone, but in larger chunk of memory. */
9062 /* free (e->pattern); */
9067 e
->next
= last
->next
;
9075 list_loc
= &e
->next
;
9079 *remaining_loc
= NULL
;
9080 *list_loc
= head
->remaining
;
9083 head
->remaining
= head
->list
;
9086 /* This is called when we know the name and dependencies of the
9090 lang_register_vers_node (const char *name
,
9091 struct bfd_elf_version_tree
*version
,
9092 struct bfd_elf_version_deps
*deps
)
9094 struct bfd_elf_version_tree
*t
, **pp
;
9095 struct bfd_elf_version_expr
*e1
;
9100 if (link_info
.version_info
!= NULL
9101 && (name
[0] == '\0' || link_info
.version_info
->name
[0] == '\0'))
9103 einfo (_("%X%P: anonymous version tag cannot be combined"
9104 " with other version tags\n"));
9109 /* Make sure this node has a unique name. */
9110 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9111 if (strcmp (t
->name
, name
) == 0)
9112 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
9114 lang_finalize_version_expr_head (&version
->globals
);
9115 lang_finalize_version_expr_head (&version
->locals
);
9117 /* Check the global and local match names, and make sure there
9118 aren't any duplicates. */
9120 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
9122 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9124 struct bfd_elf_version_expr
*e2
;
9126 if (t
->locals
.htab
&& e1
->literal
)
9128 e2
= (struct bfd_elf_version_expr
*)
9129 htab_find ((htab_t
) t
->locals
.htab
, e1
);
9130 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
9132 if (e1
->mask
== e2
->mask
)
9133 einfo (_("%X%P: duplicate expression `%s'"
9134 " in version information\n"), e1
->pattern
);
9138 else if (!e1
->literal
)
9139 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
9140 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
9141 && e1
->mask
== e2
->mask
)
9142 einfo (_("%X%P: duplicate expression `%s'"
9143 " in version information\n"), e1
->pattern
);
9147 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
9149 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9151 struct bfd_elf_version_expr
*e2
;
9153 if (t
->globals
.htab
&& e1
->literal
)
9155 e2
= (struct bfd_elf_version_expr
*)
9156 htab_find ((htab_t
) t
->globals
.htab
, e1
);
9157 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
9159 if (e1
->mask
== e2
->mask
)
9160 einfo (_("%X%P: duplicate expression `%s'"
9161 " in version information\n"),
9166 else if (!e1
->literal
)
9167 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
9168 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
9169 && e1
->mask
== e2
->mask
)
9170 einfo (_("%X%P: duplicate expression `%s'"
9171 " in version information\n"), e1
->pattern
);
9175 version
->deps
= deps
;
9176 version
->name
= name
;
9177 if (name
[0] != '\0')
9180 version
->vernum
= version_index
;
9183 version
->vernum
= 0;
9185 for (pp
= &link_info
.version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
9190 /* This is called when we see a version dependency. */
9192 struct bfd_elf_version_deps
*
9193 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
9195 struct bfd_elf_version_deps
*ret
;
9196 struct bfd_elf_version_tree
*t
;
9198 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
9201 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
9203 if (strcmp (t
->name
, name
) == 0)
9205 ret
->version_needed
= t
;
9210 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
9212 ret
->version_needed
= NULL
;
9217 lang_do_version_exports_section (void)
9219 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
9221 LANG_FOR_EACH_INPUT_STATEMENT (is
)
9223 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
9231 contents
= (char *) xmalloc (len
);
9232 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
9233 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
9236 while (p
< contents
+ len
)
9238 greg
= lang_new_vers_pattern (greg
, p
, NULL
, FALSE
);
9239 p
= strchr (p
, '\0') + 1;
9242 /* Do not free the contents, as we used them creating the regex. */
9244 /* Do not include this section in the link. */
9245 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
9248 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, FALSE
);
9249 lang_register_vers_node (command_line
.version_exports_section
,
9250 lang_new_vers_node (greg
, lreg
), NULL
);
9253 /* Evaluate LENGTH and ORIGIN parts of MEMORY spec */
9256 lang_do_memory_regions (void)
9258 lang_memory_region_type
*r
= lang_memory_region_list
;
9260 for (; r
!= NULL
; r
= r
->next
)
9264 exp_fold_tree_no_dot (r
->origin_exp
);
9265 if (expld
.result
.valid_p
)
9267 r
->origin
= expld
.result
.value
;
9268 r
->current
= r
->origin
;
9271 einfo (_("%F%P: invalid origin for memory region %s\n"),
9276 exp_fold_tree_no_dot (r
->length_exp
);
9277 if (expld
.result
.valid_p
)
9278 r
->length
= expld
.result
.value
;
9280 einfo (_("%F%P: invalid length for memory region %s\n"),
9287 lang_add_unique (const char *name
)
9289 struct unique_sections
*ent
;
9291 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
9292 if (strcmp (ent
->name
, name
) == 0)
9295 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
9296 ent
->name
= xstrdup (name
);
9297 ent
->next
= unique_section_list
;
9298 unique_section_list
= ent
;
9301 /* Append the list of dynamic symbols to the existing one. */
9304 lang_append_dynamic_list (struct bfd_elf_version_expr
*dynamic
)
9306 if (link_info
.dynamic_list
)
9308 struct bfd_elf_version_expr
*tail
;
9309 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
9311 tail
->next
= link_info
.dynamic_list
->head
.list
;
9312 link_info
.dynamic_list
->head
.list
= dynamic
;
9316 struct bfd_elf_dynamic_list
*d
;
9318 d
= (struct bfd_elf_dynamic_list
*) xcalloc (1, sizeof *d
);
9319 d
->head
.list
= dynamic
;
9320 d
->match
= lang_vers_match
;
9321 link_info
.dynamic_list
= d
;
9325 /* Append the list of C++ typeinfo dynamic symbols to the existing
9329 lang_append_dynamic_list_cpp_typeinfo (void)
9331 const char *symbols
[] =
9333 "typeinfo name for*",
9336 struct bfd_elf_version_expr
*dynamic
= NULL
;
9339 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9340 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9343 lang_append_dynamic_list (dynamic
);
9346 /* Append the list of C++ operator new and delete dynamic symbols to the
9350 lang_append_dynamic_list_cpp_new (void)
9352 const char *symbols
[] =
9357 struct bfd_elf_version_expr
*dynamic
= NULL
;
9360 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9361 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9364 lang_append_dynamic_list (dynamic
);
9367 /* Scan a space and/or comma separated string of features. */
9370 lang_ld_feature (char *str
)
9378 while (*p
== ',' || ISSPACE (*p
))
9383 while (*q
&& *q
!= ',' && !ISSPACE (*q
))
9387 if (strcasecmp (p
, "SANE_EXPR") == 0)
9388 config
.sane_expr
= TRUE
;
9390 einfo (_("%X%P: unknown feature `%s'\n"), p
);
9396 /* Pretty print memory amount. */
9399 lang_print_memory_size (bfd_vma sz
)
9401 if ((sz
& 0x3fffffff) == 0)
9402 printf ("%10" BFD_VMA_FMT
"u GB", sz
>> 30);
9403 else if ((sz
& 0xfffff) == 0)
9404 printf ("%10" BFD_VMA_FMT
"u MB", sz
>> 20);
9405 else if ((sz
& 0x3ff) == 0)
9406 printf ("%10" BFD_VMA_FMT
"u KB", sz
>> 10);
9408 printf (" %10" BFD_VMA_FMT
"u B", sz
);
9411 /* Implement --print-memory-usage: disply per region memory usage. */
9414 lang_print_memory_usage (void)
9416 lang_memory_region_type
*r
;
9418 printf ("Memory region Used Size Region Size %%age Used\n");
9419 for (r
= lang_memory_region_list
; r
->next
!= NULL
; r
= r
->next
)
9421 bfd_vma used_length
= r
->current
- r
->origin
;
9423 printf ("%16s: ",r
->name_list
.name
);
9424 lang_print_memory_size (used_length
);
9425 lang_print_memory_size ((bfd_vma
) r
->length
);
9429 double percent
= used_length
* 100.0 / r
->length
;
9430 printf (" %6.2f%%", percent
);