1 /* Linker command language support.
2 Copyright (C) 1991-2019 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"
46 #endif /* ENABLE_PLUGINS */
49 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
52 /* Convert between addresses in bytes and sizes in octets.
53 For currently supported targets, octets_per_byte is always a power
54 of two, so we can use shifts. */
55 #define TO_ADDR(X) ((X) >> opb_shift)
56 #define TO_SIZE(X) ((X) << opb_shift)
58 /* Local variables. */
59 static struct obstack stat_obstack
;
60 static struct obstack map_obstack
;
62 #define obstack_chunk_alloc xmalloc
63 #define obstack_chunk_free free
64 static const char *entry_symbol_default
= "start";
65 static bfd_boolean map_head_is_link_order
= FALSE
;
66 static lang_output_section_statement_type
*default_common_section
;
67 static bfd_boolean map_option_f
;
68 static bfd_vma print_dot
;
69 static lang_input_statement_type
*first_file
;
70 static const char *current_target
;
71 /* Header for list of statements corresponding to any files involved in the
72 link, either specified from the command-line or added implicitely (eg.
73 archive member used to resolved undefined symbol, wildcard statement from
74 linker script, etc.). Next pointer is in next field of a
75 lang_statement_header_type (reached via header field in a
76 lang_statement_union). */
77 static lang_statement_list_type statement_list
;
78 static lang_statement_list_type
*stat_save
[10];
79 static lang_statement_list_type
**stat_save_ptr
= &stat_save
[0];
80 static struct unique_sections
*unique_section_list
;
81 static struct asneeded_minfo
*asneeded_list_head
;
82 static unsigned int opb_shift
= 0;
84 /* Forward declarations. */
85 static void exp_init_os (etree_type
*);
86 static lang_input_statement_type
*lookup_name (const char *);
87 static void insert_undefined (const char *);
88 static bfd_boolean
sort_def_symbol (struct bfd_link_hash_entry
*, void *);
89 static void print_statement (lang_statement_union_type
*,
90 lang_output_section_statement_type
*);
91 static void print_statement_list (lang_statement_union_type
*,
92 lang_output_section_statement_type
*);
93 static void print_statements (void);
94 static void print_input_section (asection
*, bfd_boolean
);
95 static bfd_boolean
lang_one_common (struct bfd_link_hash_entry
*, void *);
96 static void lang_record_phdrs (void);
97 static void lang_do_version_exports_section (void);
98 static void lang_finalize_version_expr_head
99 (struct bfd_elf_version_expr_head
*);
100 static void lang_do_memory_regions (void);
102 /* Exported variables. */
103 const char *output_target
;
104 lang_output_section_statement_type
*abs_output_section
;
105 lang_statement_list_type lang_os_list
;
106 lang_statement_list_type
*stat_ptr
= &statement_list
;
107 /* Header for list of statements corresponding to files used in the final
108 executable. This can be either object file specified on the command-line
109 or library member resolving an undefined reference. Next pointer is in next
110 field of a lang_input_statement_type (reached via input_statement field in a
111 lang_statement_union). */
112 lang_statement_list_type file_chain
= { NULL
, NULL
};
113 /* Header for list of statements corresponding to files specified on the
114 command-line for linking. It thus contains real object files and archive
115 but not archive members. Next pointer is in next_real_file field of a
116 lang_input_statement_type statement (reached via input_statement field in a
117 lang_statement_union). */
118 lang_statement_list_type input_file_chain
;
119 struct bfd_sym_chain entry_symbol
= { NULL
, NULL
};
120 const char *entry_section
= ".text";
121 struct lang_input_statement_flags input_flags
;
122 bfd_boolean entry_from_cmdline
;
123 bfd_boolean undef_from_cmdline
;
124 bfd_boolean lang_has_input_file
= FALSE
;
125 bfd_boolean had_output_filename
= FALSE
;
126 bfd_boolean lang_float_flag
= FALSE
;
127 bfd_boolean delete_output_file_on_failure
= FALSE
;
128 struct lang_phdr
*lang_phdr_list
;
129 struct lang_nocrossrefs
*nocrossref_list
;
130 struct asneeded_minfo
**asneeded_list_tail
;
132 /* Functions that traverse the linker script and might evaluate
133 DEFINED() need to increment this at the start of the traversal. */
134 int lang_statement_iteration
= 0;
136 /* Return TRUE if the PATTERN argument is a wildcard pattern.
137 Although backslashes are treated specially if a pattern contains
138 wildcards, we do not consider the mere presence of a backslash to
139 be enough to cause the pattern to be treated as a wildcard.
140 That lets us handle DOS filenames more naturally. */
141 #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
143 #define new_stat(x, y) \
144 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
146 #define outside_section_address(q) \
147 ((q)->output_offset + (q)->output_section->vma)
149 #define outside_symbol_address(q) \
150 ((q)->value + outside_section_address (q->section))
152 #define SECTION_NAME_MAP_LENGTH (16)
155 stat_alloc (size_t size
)
157 return obstack_alloc (&stat_obstack
, size
);
161 name_match (const char *pattern
, const char *name
)
163 if (wildcardp (pattern
))
164 return fnmatch (pattern
, name
, 0);
165 return strcmp (pattern
, name
);
168 /* If PATTERN is of the form archive:file, return a pointer to the
169 separator. If not, return NULL. */
172 archive_path (const char *pattern
)
176 if (link_info
.path_separator
== 0)
179 p
= strchr (pattern
, link_info
.path_separator
);
180 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
181 if (p
== NULL
|| link_info
.path_separator
!= ':')
184 /* Assume a match on the second char is part of drive specifier,
185 as in "c:\silly.dos". */
186 if (p
== pattern
+ 1 && ISALPHA (*pattern
))
187 p
= strchr (p
+ 1, link_info
.path_separator
);
192 /* Given that FILE_SPEC results in a non-NULL SEP result from archive_path,
193 return whether F matches FILE_SPEC. */
196 input_statement_is_archive_path (const char *file_spec
, char *sep
,
197 lang_input_statement_type
*f
)
199 bfd_boolean match
= FALSE
;
202 || name_match (sep
+ 1, f
->filename
) == 0)
203 && ((sep
!= file_spec
)
204 == (f
->the_bfd
!= NULL
&& f
->the_bfd
->my_archive
!= NULL
)))
208 if (sep
!= file_spec
)
210 const char *aname
= f
->the_bfd
->my_archive
->filename
;
212 match
= name_match (file_spec
, aname
) == 0;
213 *sep
= link_info
.path_separator
;
220 unique_section_p (const asection
*sec
,
221 const lang_output_section_statement_type
*os
)
223 struct unique_sections
*unam
;
226 if (!link_info
.resolve_section_groups
227 && sec
->owner
!= NULL
228 && bfd_is_group_section (sec
->owner
, sec
))
230 && strcmp (os
->name
, DISCARD_SECTION_NAME
) == 0);
233 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
234 if (name_match (unam
->name
, secnam
) == 0)
240 /* Generic traversal routines for finding matching sections. */
242 /* Return true if FILE matches a pattern in EXCLUDE_LIST, otherwise return
246 walk_wild_file_in_exclude_list (struct name_list
*exclude_list
,
247 lang_input_statement_type
*file
)
249 struct name_list
*list_tmp
;
251 for (list_tmp
= exclude_list
;
253 list_tmp
= list_tmp
->next
)
255 char *p
= archive_path (list_tmp
->name
);
259 if (input_statement_is_archive_path (list_tmp
->name
, p
, file
))
263 else if (name_match (list_tmp
->name
, file
->filename
) == 0)
266 /* FIXME: Perhaps remove the following at some stage? Matching
267 unadorned archives like this was never documented and has
268 been superceded by the archive:path syntax. */
269 else if (file
->the_bfd
!= NULL
270 && file
->the_bfd
->my_archive
!= NULL
271 && name_match (list_tmp
->name
,
272 file
->the_bfd
->my_archive
->filename
) == 0)
279 /* Try processing a section against a wildcard. This just calls
280 the callback unless the filename exclusion list is present
281 and excludes the file. It's hardly ever present so this
282 function is very fast. */
285 walk_wild_consider_section (lang_wild_statement_type
*ptr
,
286 lang_input_statement_type
*file
,
288 struct wildcard_list
*sec
,
292 /* Don't process sections from files which were excluded. */
293 if (walk_wild_file_in_exclude_list (sec
->spec
.exclude_name_list
, file
))
296 (*callback
) (ptr
, sec
, s
, ptr
->section_flag_list
, file
, data
);
299 /* Lowest common denominator routine that can handle everything correctly,
303 walk_wild_section_general (lang_wild_statement_type
*ptr
,
304 lang_input_statement_type
*file
,
309 struct wildcard_list
*sec
;
311 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
313 sec
= ptr
->section_list
;
315 (*callback
) (ptr
, sec
, s
, ptr
->section_flag_list
, file
, data
);
319 bfd_boolean skip
= FALSE
;
321 if (sec
->spec
.name
!= NULL
)
323 const char *sname
= bfd_section_name (s
);
325 skip
= name_match (sec
->spec
.name
, sname
) != 0;
329 walk_wild_consider_section (ptr
, file
, s
, sec
, callback
, data
);
336 /* Routines to find a single section given its name. If there's more
337 than one section with that name, we report that. */
341 asection
*found_section
;
342 bfd_boolean multiple_sections_found
;
343 } section_iterator_callback_data
;
346 section_iterator_callback (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*s
, void *data
)
348 section_iterator_callback_data
*d
= (section_iterator_callback_data
*) data
;
350 if (d
->found_section
!= NULL
)
352 d
->multiple_sections_found
= TRUE
;
356 d
->found_section
= s
;
361 find_section (lang_input_statement_type
*file
,
362 struct wildcard_list
*sec
,
363 bfd_boolean
*multiple_sections_found
)
365 section_iterator_callback_data cb_data
= { NULL
, FALSE
};
367 bfd_get_section_by_name_if (file
->the_bfd
, sec
->spec
.name
,
368 section_iterator_callback
, &cb_data
);
369 *multiple_sections_found
= cb_data
.multiple_sections_found
;
370 return cb_data
.found_section
;
373 /* Code for handling simple wildcards without going through fnmatch,
374 which can be expensive because of charset translations etc. */
376 /* A simple wild is a literal string followed by a single '*',
377 where the literal part is at least 4 characters long. */
380 is_simple_wild (const char *name
)
382 size_t len
= strcspn (name
, "*?[");
383 return len
>= 4 && name
[len
] == '*' && name
[len
+ 1] == '\0';
387 match_simple_wild (const char *pattern
, const char *name
)
389 /* The first four characters of the pattern are guaranteed valid
390 non-wildcard characters. So we can go faster. */
391 if (pattern
[0] != name
[0] || pattern
[1] != name
[1]
392 || pattern
[2] != name
[2] || pattern
[3] != name
[3])
397 while (*pattern
!= '*')
398 if (*name
++ != *pattern
++)
404 /* Return the numerical value of the init_priority attribute from
405 section name NAME. */
408 get_init_priority (const asection
*sec
)
410 const char *name
= bfd_section_name (sec
);
413 /* GCC uses the following section names for the init_priority
414 attribute with numerical values 101 to 65535 inclusive. A
415 lower value means a higher priority.
417 1: .init_array.NNNNN/.fini_array.NNNNN: Where NNNNN is the
418 decimal numerical value of the init_priority attribute.
419 The order of execution in .init_array is forward and
420 .fini_array is backward.
421 2: .ctors.NNNNN/.dtors.NNNNN: Where NNNNN is 65535 minus the
422 decimal numerical value of the init_priority attribute.
423 The order of execution in .ctors is backward and .dtors
426 .init_array.NNNNN sections would normally be placed in an output
427 .init_array section, .fini_array.NNNNN in .fini_array,
428 .ctors.NNNNN in .ctors, and .dtors.NNNNN in .dtors. This means
429 we should sort by increasing number (and could just use
430 SORT_BY_NAME in scripts). However if .ctors.NNNNN sections are
431 being placed in .init_array (which may also contain
432 .init_array.NNNNN sections) or .dtors.NNNNN sections are being
433 placed in .fini_array then we need to extract the init_priority
434 attribute and sort on that. */
435 dot
= strrchr (name
, '.');
436 if (dot
!= NULL
&& ISDIGIT (dot
[1]))
439 unsigned long init_priority
= strtoul (dot
+ 1, &end
, 10);
443 && (strncmp (name
, ".ctors", 6) == 0
444 || strncmp (name
, ".dtors", 6) == 0))
445 init_priority
= 65535 - init_priority
;
446 if (init_priority
<= INT_MAX
)
447 return init_priority
;
453 /* Compare sections ASEC and BSEC according to SORT. */
456 compare_section (sort_type sort
, asection
*asec
, asection
*bsec
)
459 int a_priority
, b_priority
;
466 case by_init_priority
:
467 a_priority
= get_init_priority (asec
);
468 b_priority
= get_init_priority (bsec
);
469 if (a_priority
< 0 || b_priority
< 0)
471 ret
= a_priority
- b_priority
;
477 case by_alignment_name
:
478 ret
= bfd_section_alignment (bsec
) - bfd_section_alignment (asec
);
485 ret
= strcmp (bfd_section_name (asec
), bfd_section_name (bsec
));
488 case by_name_alignment
:
489 ret
= strcmp (bfd_section_name (asec
), bfd_section_name (bsec
));
495 ret
= bfd_section_alignment (bsec
) - bfd_section_alignment (asec
);
502 /* Build a Binary Search Tree to sort sections, unlike insertion sort
503 used in wild_sort(). BST is considerably faster if the number of
504 of sections are large. */
506 static lang_section_bst_type
**
507 wild_sort_fast (lang_wild_statement_type
*wild
,
508 struct wildcard_list
*sec
,
509 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
512 lang_section_bst_type
**tree
;
515 if (!wild
->filenames_sorted
516 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
518 /* Append at the right end of tree. */
520 tree
= &((*tree
)->right
);
526 /* Find the correct node to append this section. */
527 if (compare_section (sec
->spec
.sorted
, section
, (*tree
)->section
) < 0)
528 tree
= &((*tree
)->left
);
530 tree
= &((*tree
)->right
);
536 /* Use wild_sort_fast to build a BST to sort sections. */
539 output_section_callback_fast (lang_wild_statement_type
*ptr
,
540 struct wildcard_list
*sec
,
542 struct flag_info
*sflag_list ATTRIBUTE_UNUSED
,
543 lang_input_statement_type
*file
,
546 lang_section_bst_type
*node
;
547 lang_section_bst_type
**tree
;
548 lang_output_section_statement_type
*os
;
550 os
= (lang_output_section_statement_type
*) output
;
552 if (unique_section_p (section
, os
))
555 node
= (lang_section_bst_type
*) xmalloc (sizeof (lang_section_bst_type
));
558 node
->section
= section
;
560 tree
= wild_sort_fast (ptr
, sec
, file
, section
);
565 /* Convert a sorted sections' BST back to list form. */
568 output_section_callback_tree_to_list (lang_wild_statement_type
*ptr
,
569 lang_section_bst_type
*tree
,
573 output_section_callback_tree_to_list (ptr
, tree
->left
, output
);
575 lang_add_section (&ptr
->children
, tree
->section
, NULL
,
576 (lang_output_section_statement_type
*) output
);
579 output_section_callback_tree_to_list (ptr
, tree
->right
, output
);
584 /* Specialized, optimized routines for handling different kinds of
588 walk_wild_section_specs1_wild0 (lang_wild_statement_type
*ptr
,
589 lang_input_statement_type
*file
,
593 /* We can just do a hash lookup for the section with the right name.
594 But if that lookup discovers more than one section with the name
595 (should be rare), we fall back to the general algorithm because
596 we would otherwise have to sort the sections to make sure they
597 get processed in the bfd's order. */
598 bfd_boolean multiple_sections_found
;
599 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
600 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
602 if (multiple_sections_found
)
603 walk_wild_section_general (ptr
, file
, callback
, data
);
605 walk_wild_consider_section (ptr
, file
, s0
, sec0
, callback
, data
);
609 walk_wild_section_specs1_wild1 (lang_wild_statement_type
*ptr
,
610 lang_input_statement_type
*file
,
615 struct wildcard_list
*wildsec0
= ptr
->handler_data
[0];
617 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
619 const char *sname
= bfd_section_name (s
);
620 bfd_boolean skip
= !match_simple_wild (wildsec0
->spec
.name
, sname
);
623 walk_wild_consider_section (ptr
, file
, s
, wildsec0
, callback
, data
);
628 walk_wild_section_specs2_wild1 (lang_wild_statement_type
*ptr
,
629 lang_input_statement_type
*file
,
634 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
635 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
636 bfd_boolean multiple_sections_found
;
637 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
639 if (multiple_sections_found
)
641 walk_wild_section_general (ptr
, file
, callback
, data
);
645 /* Note that if the section was not found, s0 is NULL and
646 we'll simply never succeed the s == s0 test below. */
647 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
649 /* Recall that in this code path, a section cannot satisfy more
650 than one spec, so if s == s0 then it cannot match
653 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
656 const char *sname
= bfd_section_name (s
);
657 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
660 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
,
667 walk_wild_section_specs3_wild2 (lang_wild_statement_type
*ptr
,
668 lang_input_statement_type
*file
,
673 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
674 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
675 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
676 bfd_boolean multiple_sections_found
;
677 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
679 if (multiple_sections_found
)
681 walk_wild_section_general (ptr
, file
, callback
, data
);
685 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
688 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
691 const char *sname
= bfd_section_name (s
);
692 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
695 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
, data
);
698 skip
= !match_simple_wild (wildsec2
->spec
.name
, sname
);
700 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
708 walk_wild_section_specs4_wild2 (lang_wild_statement_type
*ptr
,
709 lang_input_statement_type
*file
,
714 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
715 struct wildcard_list
*sec1
= ptr
->handler_data
[1];
716 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
717 struct wildcard_list
*wildsec3
= ptr
->handler_data
[3];
718 bfd_boolean multiple_sections_found
;
719 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
), *s1
;
721 if (multiple_sections_found
)
723 walk_wild_section_general (ptr
, file
, callback
, data
);
727 s1
= find_section (file
, sec1
, &multiple_sections_found
);
728 if (multiple_sections_found
)
730 walk_wild_section_general (ptr
, file
, callback
, data
);
734 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
737 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
740 walk_wild_consider_section (ptr
, file
, s
, sec1
, callback
, data
);
743 const char *sname
= bfd_section_name (s
);
744 bfd_boolean skip
= !match_simple_wild (wildsec2
->spec
.name
,
748 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
752 skip
= !match_simple_wild (wildsec3
->spec
.name
, sname
);
754 walk_wild_consider_section (ptr
, file
, s
, wildsec3
,
762 walk_wild_section (lang_wild_statement_type
*ptr
,
763 lang_input_statement_type
*file
,
767 if (file
->flags
.just_syms
)
770 (*ptr
->walk_wild_section_handler
) (ptr
, file
, callback
, data
);
773 /* Returns TRUE when name1 is a wildcard spec that might match
774 something name2 can match. We're conservative: we return FALSE
775 only if the prefixes of name1 and name2 are different up to the
776 first wildcard character. */
779 wild_spec_can_overlap (const char *name1
, const char *name2
)
781 size_t prefix1_len
= strcspn (name1
, "?*[");
782 size_t prefix2_len
= strcspn (name2
, "?*[");
783 size_t min_prefix_len
;
785 /* Note that if there is no wildcard character, then we treat the
786 terminating 0 as part of the prefix. Thus ".text" won't match
787 ".text." or ".text.*", for example. */
788 if (name1
[prefix1_len
] == '\0')
790 if (name2
[prefix2_len
] == '\0')
793 min_prefix_len
= prefix1_len
< prefix2_len
? prefix1_len
: prefix2_len
;
795 return memcmp (name1
, name2
, min_prefix_len
) == 0;
798 /* Select specialized code to handle various kinds of wildcard
802 analyze_walk_wild_section_handler (lang_wild_statement_type
*ptr
)
805 int wild_name_count
= 0;
806 struct wildcard_list
*sec
;
810 ptr
->walk_wild_section_handler
= walk_wild_section_general
;
811 ptr
->handler_data
[0] = NULL
;
812 ptr
->handler_data
[1] = NULL
;
813 ptr
->handler_data
[2] = NULL
;
814 ptr
->handler_data
[3] = NULL
;
817 /* Count how many wildcard_specs there are, and how many of those
818 actually use wildcards in the name. Also, bail out if any of the
819 wildcard names are NULL. (Can this actually happen?
820 walk_wild_section used to test for it.) And bail out if any
821 of the wildcards are more complex than a simple string
822 ending in a single '*'. */
823 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
826 if (sec
->spec
.name
== NULL
)
828 if (wildcardp (sec
->spec
.name
))
831 if (!is_simple_wild (sec
->spec
.name
))
836 /* The zero-spec case would be easy to optimize but it doesn't
837 happen in practice. Likewise, more than 4 specs doesn't
838 happen in practice. */
839 if (sec_count
== 0 || sec_count
> 4)
842 /* Check that no two specs can match the same section. */
843 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
845 struct wildcard_list
*sec2
;
846 for (sec2
= sec
->next
; sec2
!= NULL
; sec2
= sec2
->next
)
848 if (wild_spec_can_overlap (sec
->spec
.name
, sec2
->spec
.name
))
853 signature
= (sec_count
<< 8) + wild_name_count
;
857 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild0
;
860 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild1
;
863 ptr
->walk_wild_section_handler
= walk_wild_section_specs2_wild1
;
866 ptr
->walk_wild_section_handler
= walk_wild_section_specs3_wild2
;
869 ptr
->walk_wild_section_handler
= walk_wild_section_specs4_wild2
;
875 /* Now fill the data array with pointers to the specs, first the
876 specs with non-wildcard names, then the specs with wildcard
877 names. It's OK to process the specs in different order from the
878 given order, because we've already determined that no section
879 will match more than one spec. */
881 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
882 if (!wildcardp (sec
->spec
.name
))
883 ptr
->handler_data
[data_counter
++] = sec
;
884 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
885 if (wildcardp (sec
->spec
.name
))
886 ptr
->handler_data
[data_counter
++] = sec
;
889 /* Handle a wild statement for a single file F. */
892 walk_wild_file (lang_wild_statement_type
*s
,
893 lang_input_statement_type
*f
,
897 if (walk_wild_file_in_exclude_list (s
->exclude_name_list
, f
))
900 if (f
->the_bfd
== NULL
901 || !bfd_check_format (f
->the_bfd
, bfd_archive
))
902 walk_wild_section (s
, f
, callback
, data
);
907 /* This is an archive file. We must map each member of the
908 archive separately. */
909 member
= bfd_openr_next_archived_file (f
->the_bfd
, NULL
);
910 while (member
!= NULL
)
912 /* When lookup_name is called, it will call the add_symbols
913 entry point for the archive. For each element of the
914 archive which is included, BFD will call ldlang_add_file,
915 which will set the usrdata field of the member to the
916 lang_input_statement. */
917 if (bfd_usrdata (member
) != NULL
)
918 walk_wild_section (s
, bfd_usrdata (member
), callback
, data
);
920 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
926 walk_wild (lang_wild_statement_type
*s
, callback_t callback
, void *data
)
928 const char *file_spec
= s
->filename
;
931 if (file_spec
== NULL
)
933 /* Perform the iteration over all files in the list. */
934 LANG_FOR_EACH_INPUT_STATEMENT (f
)
936 walk_wild_file (s
, f
, callback
, data
);
939 else if ((p
= archive_path (file_spec
)) != NULL
)
941 LANG_FOR_EACH_INPUT_STATEMENT (f
)
943 if (input_statement_is_archive_path (file_spec
, p
, f
))
944 walk_wild_file (s
, f
, callback
, data
);
947 else if (wildcardp (file_spec
))
949 LANG_FOR_EACH_INPUT_STATEMENT (f
)
951 if (fnmatch (file_spec
, f
->filename
, 0) == 0)
952 walk_wild_file (s
, f
, callback
, data
);
957 lang_input_statement_type
*f
;
959 /* Perform the iteration over a single file. */
960 f
= lookup_name (file_spec
);
962 walk_wild_file (s
, f
, callback
, data
);
966 /* lang_for_each_statement walks the parse tree and calls the provided
967 function for each node, except those inside output section statements
968 with constraint set to -1. */
971 lang_for_each_statement_worker (void (*func
) (lang_statement_union_type
*),
972 lang_statement_union_type
*s
)
974 for (; s
!= NULL
; s
= s
->header
.next
)
978 switch (s
->header
.type
)
980 case lang_constructors_statement_enum
:
981 lang_for_each_statement_worker (func
, constructor_list
.head
);
983 case lang_output_section_statement_enum
:
984 if (s
->output_section_statement
.constraint
!= -1)
985 lang_for_each_statement_worker
986 (func
, s
->output_section_statement
.children
.head
);
988 case lang_wild_statement_enum
:
989 lang_for_each_statement_worker (func
,
990 s
->wild_statement
.children
.head
);
992 case lang_group_statement_enum
:
993 lang_for_each_statement_worker (func
,
994 s
->group_statement
.children
.head
);
996 case lang_data_statement_enum
:
997 case lang_reloc_statement_enum
:
998 case lang_object_symbols_statement_enum
:
999 case lang_output_statement_enum
:
1000 case lang_target_statement_enum
:
1001 case lang_input_section_enum
:
1002 case lang_input_statement_enum
:
1003 case lang_assignment_statement_enum
:
1004 case lang_padding_statement_enum
:
1005 case lang_address_statement_enum
:
1006 case lang_fill_statement_enum
:
1007 case lang_insert_statement_enum
:
1017 lang_for_each_statement (void (*func
) (lang_statement_union_type
*))
1019 lang_for_each_statement_worker (func
, statement_list
.head
);
1022 /*----------------------------------------------------------------------*/
1025 lang_list_init (lang_statement_list_type
*list
)
1028 list
->tail
= &list
->head
;
1032 lang_statement_append (lang_statement_list_type
*list
,
1036 *(list
->tail
) = element
;
1041 push_stat_ptr (lang_statement_list_type
*new_ptr
)
1043 if (stat_save_ptr
>= stat_save
+ sizeof (stat_save
) / sizeof (stat_save
[0]))
1045 *stat_save_ptr
++ = stat_ptr
;
1052 if (stat_save_ptr
<= stat_save
)
1054 stat_ptr
= *--stat_save_ptr
;
1057 /* Build a new statement node for the parse tree. */
1059 static lang_statement_union_type
*
1060 new_statement (enum statement_enum type
,
1062 lang_statement_list_type
*list
)
1064 lang_statement_union_type
*new_stmt
;
1066 new_stmt
= stat_alloc (size
);
1067 new_stmt
->header
.type
= type
;
1068 new_stmt
->header
.next
= NULL
;
1069 lang_statement_append (list
, new_stmt
, &new_stmt
->header
.next
);
1073 /* Build a new input file node for the language. There are several
1074 ways in which we treat an input file, eg, we only look at symbols,
1075 or prefix it with a -l etc.
1077 We can be supplied with requests for input files more than once;
1078 they may, for example be split over several lines like foo.o(.text)
1079 foo.o(.data) etc, so when asked for a file we check that we haven't
1080 got it already so we don't duplicate the bfd. */
1082 static lang_input_statement_type
*
1083 new_afile (const char *name
,
1084 lang_input_file_enum_type file_type
,
1087 lang_input_statement_type
*p
;
1089 lang_has_input_file
= TRUE
;
1091 p
= new_stat (lang_input_statement
, stat_ptr
);
1092 memset (&p
->the_bfd
, 0,
1093 sizeof (*p
) - offsetof (lang_input_statement_type
, the_bfd
));
1095 p
->flags
.dynamic
= input_flags
.dynamic
;
1096 p
->flags
.add_DT_NEEDED_for_dynamic
= input_flags
.add_DT_NEEDED_for_dynamic
;
1097 p
->flags
.add_DT_NEEDED_for_regular
= input_flags
.add_DT_NEEDED_for_regular
;
1098 p
->flags
.whole_archive
= input_flags
.whole_archive
;
1099 p
->flags
.sysrooted
= input_flags
.sysrooted
;
1103 case lang_input_file_is_symbols_only_enum
:
1105 p
->local_sym_name
= name
;
1106 p
->flags
.real
= TRUE
;
1107 p
->flags
.just_syms
= TRUE
;
1109 case lang_input_file_is_fake_enum
:
1111 p
->local_sym_name
= name
;
1113 case lang_input_file_is_l_enum
:
1114 if (name
[0] == ':' && name
[1] != '\0')
1116 p
->filename
= name
+ 1;
1117 p
->flags
.full_name_provided
= TRUE
;
1121 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
1122 p
->flags
.maybe_archive
= TRUE
;
1123 p
->flags
.real
= TRUE
;
1124 p
->flags
.search_dirs
= TRUE
;
1126 case lang_input_file_is_marker_enum
:
1128 p
->local_sym_name
= name
;
1129 p
->flags
.search_dirs
= TRUE
;
1131 case lang_input_file_is_search_file_enum
:
1133 p
->local_sym_name
= name
;
1134 p
->flags
.real
= TRUE
;
1135 p
->flags
.search_dirs
= TRUE
;
1137 case lang_input_file_is_file_enum
:
1139 p
->local_sym_name
= name
;
1140 p
->flags
.real
= TRUE
;
1146 lang_statement_append (&input_file_chain
, p
, &p
->next_real_file
);
1150 lang_input_statement_type
*
1151 lang_add_input_file (const char *name
,
1152 lang_input_file_enum_type file_type
,
1156 && (*name
== '=' || CONST_STRNEQ (name
, "$SYSROOT")))
1158 lang_input_statement_type
*ret
;
1159 char *sysrooted_name
1160 = concat (ld_sysroot
,
1161 name
+ (*name
== '=' ? 1 : strlen ("$SYSROOT")),
1162 (const char *) NULL
);
1164 /* We've now forcibly prepended the sysroot, making the input
1165 file independent of the context. Therefore, temporarily
1166 force a non-sysrooted context for this statement, so it won't
1167 get the sysroot prepended again when opened. (N.B. if it's a
1168 script, any child nodes with input files starting with "/"
1169 will be handled as "sysrooted" as they'll be found to be
1170 within the sysroot subdirectory.) */
1171 unsigned int outer_sysrooted
= input_flags
.sysrooted
;
1172 input_flags
.sysrooted
= 0;
1173 ret
= new_afile (sysrooted_name
, file_type
, target
);
1174 input_flags
.sysrooted
= outer_sysrooted
;
1178 return new_afile (name
, file_type
, target
);
1181 struct out_section_hash_entry
1183 struct bfd_hash_entry root
;
1184 lang_statement_union_type s
;
1187 /* The hash table. */
1189 static struct bfd_hash_table output_section_statement_table
;
1191 /* Support routines for the hash table used by lang_output_section_find,
1192 initialize the table, fill in an entry and remove the table. */
1194 static struct bfd_hash_entry
*
1195 output_section_statement_newfunc (struct bfd_hash_entry
*entry
,
1196 struct bfd_hash_table
*table
,
1199 lang_output_section_statement_type
**nextp
;
1200 struct out_section_hash_entry
*ret
;
1204 entry
= (struct bfd_hash_entry
*) bfd_hash_allocate (table
,
1210 entry
= bfd_hash_newfunc (entry
, table
, string
);
1214 ret
= (struct out_section_hash_entry
*) entry
;
1215 memset (&ret
->s
, 0, sizeof (ret
->s
));
1216 ret
->s
.header
.type
= lang_output_section_statement_enum
;
1217 ret
->s
.output_section_statement
.subsection_alignment
= NULL
;
1218 ret
->s
.output_section_statement
.section_alignment
= NULL
;
1219 ret
->s
.output_section_statement
.block_value
= 1;
1220 lang_list_init (&ret
->s
.output_section_statement
.children
);
1221 lang_statement_append (stat_ptr
, &ret
->s
, &ret
->s
.header
.next
);
1223 /* For every output section statement added to the list, except the
1224 first one, lang_os_list.tail points to the "next"
1225 field of the last element of the list. */
1226 if (lang_os_list
.head
!= NULL
)
1227 ret
->s
.output_section_statement
.prev
1228 = ((lang_output_section_statement_type
*)
1229 ((char *) lang_os_list
.tail
1230 - offsetof (lang_output_section_statement_type
, next
)));
1232 /* GCC's strict aliasing rules prevent us from just casting the
1233 address, so we store the pointer in a variable and cast that
1235 nextp
= &ret
->s
.output_section_statement
.next
;
1236 lang_statement_append (&lang_os_list
, &ret
->s
, nextp
);
1241 output_section_statement_table_init (void)
1243 if (!bfd_hash_table_init_n (&output_section_statement_table
,
1244 output_section_statement_newfunc
,
1245 sizeof (struct out_section_hash_entry
),
1247 einfo (_("%F%P: can not create hash table: %E\n"));
1251 output_section_statement_table_free (void)
1253 bfd_hash_table_free (&output_section_statement_table
);
1256 /* Build enough state so that the parser can build its tree. */
1261 obstack_begin (&stat_obstack
, 1000);
1263 stat_ptr
= &statement_list
;
1265 output_section_statement_table_init ();
1267 lang_list_init (stat_ptr
);
1269 lang_list_init (&input_file_chain
);
1270 lang_list_init (&lang_os_list
);
1271 lang_list_init (&file_chain
);
1272 first_file
= lang_add_input_file (NULL
, lang_input_file_is_marker_enum
,
1274 abs_output_section
=
1275 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
, 0, TRUE
);
1277 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
1279 asneeded_list_head
= NULL
;
1280 asneeded_list_tail
= &asneeded_list_head
;
1286 output_section_statement_table_free ();
1289 /*----------------------------------------------------------------------
1290 A region is an area of memory declared with the
1291 MEMORY { name:org=exp, len=exp ... }
1294 We maintain a list of all the regions here.
1296 If no regions are specified in the script, then the default is used
1297 which is created when looked up to be the entire data space.
1299 If create is true we are creating a region inside a MEMORY block.
1300 In this case it is probably an error to create a region that has
1301 already been created. If we are not inside a MEMORY block it is
1302 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1303 and so we issue a warning.
1305 Each region has at least one name. The first name is either
1306 DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add
1307 alias names to an existing region within a script with
1308 REGION_ALIAS (alias, region_name). Each name corresponds to at most one
1311 static lang_memory_region_type
*lang_memory_region_list
;
1312 static lang_memory_region_type
**lang_memory_region_list_tail
1313 = &lang_memory_region_list
;
1315 lang_memory_region_type
*
1316 lang_memory_region_lookup (const char *const name
, bfd_boolean create
)
1318 lang_memory_region_name
*n
;
1319 lang_memory_region_type
*r
;
1320 lang_memory_region_type
*new_region
;
1322 /* NAME is NULL for LMA memspecs if no region was specified. */
1326 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1327 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1328 if (strcmp (n
->name
, name
) == 0)
1331 einfo (_("%P:%pS: warning: redeclaration of memory region `%s'\n"),
1336 if (!create
&& strcmp (name
, DEFAULT_MEMORY_REGION
))
1337 einfo (_("%P:%pS: warning: memory region `%s' not declared\n"),
1340 new_region
= stat_alloc (sizeof (lang_memory_region_type
));
1342 new_region
->name_list
.name
= xstrdup (name
);
1343 new_region
->name_list
.next
= NULL
;
1344 new_region
->next
= NULL
;
1345 new_region
->origin_exp
= NULL
;
1346 new_region
->origin
= 0;
1347 new_region
->length_exp
= NULL
;
1348 new_region
->length
= ~(bfd_size_type
) 0;
1349 new_region
->current
= 0;
1350 new_region
->last_os
= NULL
;
1351 new_region
->flags
= 0;
1352 new_region
->not_flags
= 0;
1353 new_region
->had_full_message
= FALSE
;
1355 *lang_memory_region_list_tail
= new_region
;
1356 lang_memory_region_list_tail
= &new_region
->next
;
1362 lang_memory_region_alias (const char *alias
, const char *region_name
)
1364 lang_memory_region_name
*n
;
1365 lang_memory_region_type
*r
;
1366 lang_memory_region_type
*region
;
1368 /* The default region must be unique. This ensures that it is not necessary
1369 to iterate through the name list if someone wants the check if a region is
1370 the default memory region. */
1371 if (strcmp (region_name
, DEFAULT_MEMORY_REGION
) == 0
1372 || strcmp (alias
, DEFAULT_MEMORY_REGION
) == 0)
1373 einfo (_("%F%P:%pS: error: alias for default memory region\n"), NULL
);
1375 /* Look for the target region and check if the alias is not already
1378 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1379 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1381 if (region
== NULL
&& strcmp (n
->name
, region_name
) == 0)
1383 if (strcmp (n
->name
, alias
) == 0)
1384 einfo (_("%F%P:%pS: error: redefinition of memory region "
1389 /* Check if the target region exists. */
1391 einfo (_("%F%P:%pS: error: memory region `%s' "
1392 "for alias `%s' does not exist\n"),
1393 NULL
, region_name
, alias
);
1395 /* Add alias to region name list. */
1396 n
= stat_alloc (sizeof (lang_memory_region_name
));
1397 n
->name
= xstrdup (alias
);
1398 n
->next
= region
->name_list
.next
;
1399 region
->name_list
.next
= n
;
1402 static lang_memory_region_type
*
1403 lang_memory_default (asection
*section
)
1405 lang_memory_region_type
*p
;
1407 flagword sec_flags
= section
->flags
;
1409 /* Override SEC_DATA to mean a writable section. */
1410 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
1411 sec_flags
|= SEC_DATA
;
1413 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
1415 if ((p
->flags
& sec_flags
) != 0
1416 && (p
->not_flags
& sec_flags
) == 0)
1421 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
1424 /* Get the output section statement directly from the userdata. */
1426 lang_output_section_statement_type
*
1427 lang_output_section_get (const asection
*output_section
)
1429 return bfd_section_userdata (output_section
);
1432 /* Find or create an output_section_statement with the given NAME.
1433 If CONSTRAINT is non-zero match one with that constraint, otherwise
1434 match any non-negative constraint. If CREATE, always make a
1435 new output_section_statement for SPECIAL CONSTRAINT. */
1437 lang_output_section_statement_type
*
1438 lang_output_section_statement_lookup (const char *name
,
1442 struct out_section_hash_entry
*entry
;
1444 entry
= ((struct out_section_hash_entry
*)
1445 bfd_hash_lookup (&output_section_statement_table
, name
,
1450 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1454 if (entry
->s
.output_section_statement
.name
!= NULL
)
1456 /* We have a section of this name, but it might not have the correct
1458 struct out_section_hash_entry
*last_ent
;
1460 name
= entry
->s
.output_section_statement
.name
;
1461 if (create
&& constraint
== SPECIAL
)
1462 /* Not traversing to the end reverses the order of the second
1463 and subsequent SPECIAL sections in the hash table chain,
1464 but that shouldn't matter. */
1469 if (constraint
== entry
->s
.output_section_statement
.constraint
1471 && entry
->s
.output_section_statement
.constraint
>= 0))
1472 return &entry
->s
.output_section_statement
;
1474 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1476 while (entry
!= NULL
1477 && name
== entry
->s
.output_section_statement
.name
);
1483 = ((struct out_section_hash_entry
*)
1484 output_section_statement_newfunc (NULL
,
1485 &output_section_statement_table
,
1489 einfo (_("%F%P: failed creating section `%s': %E\n"), name
);
1492 entry
->root
= last_ent
->root
;
1493 last_ent
->root
.next
= &entry
->root
;
1496 entry
->s
.output_section_statement
.name
= name
;
1497 entry
->s
.output_section_statement
.constraint
= constraint
;
1498 return &entry
->s
.output_section_statement
;
1501 /* Find the next output_section_statement with the same name as OS.
1502 If CONSTRAINT is non-zero, find one with that constraint otherwise
1503 match any non-negative constraint. */
1505 lang_output_section_statement_type
*
1506 next_matching_output_section_statement (lang_output_section_statement_type
*os
,
1509 /* All output_section_statements are actually part of a
1510 struct out_section_hash_entry. */
1511 struct out_section_hash_entry
*entry
= (struct out_section_hash_entry
*)
1513 - offsetof (struct out_section_hash_entry
, s
.output_section_statement
));
1514 const char *name
= os
->name
;
1516 ASSERT (name
== entry
->root
.string
);
1519 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1521 || name
!= entry
->s
.output_section_statement
.name
)
1524 while (constraint
!= entry
->s
.output_section_statement
.constraint
1526 || entry
->s
.output_section_statement
.constraint
< 0));
1528 return &entry
->s
.output_section_statement
;
1531 /* A variant of lang_output_section_find used by place_orphan.
1532 Returns the output statement that should precede a new output
1533 statement for SEC. If an exact match is found on certain flags,
1536 lang_output_section_statement_type
*
1537 lang_output_section_find_by_flags (const asection
*sec
,
1539 lang_output_section_statement_type
**exact
,
1540 lang_match_sec_type_func match_type
)
1542 lang_output_section_statement_type
*first
, *look
, *found
;
1543 flagword look_flags
, differ
;
1545 /* We know the first statement on this list is *ABS*. May as well
1547 first
= &lang_os_list
.head
->output_section_statement
;
1548 first
= first
->next
;
1550 /* First try for an exact match. */
1552 for (look
= first
; look
; look
= look
->next
)
1554 look_flags
= look
->flags
;
1555 if (look
->bfd_section
!= NULL
)
1557 look_flags
= look
->bfd_section
->flags
;
1558 if (match_type
&& !match_type (link_info
.output_bfd
,
1563 differ
= look_flags
^ sec_flags
;
1564 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1565 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1575 if ((sec_flags
& SEC_CODE
) != 0
1576 && (sec_flags
& SEC_ALLOC
) != 0)
1578 /* Try for a rw code section. */
1579 for (look
= first
; look
; look
= look
->next
)
1581 look_flags
= look
->flags
;
1582 if (look
->bfd_section
!= NULL
)
1584 look_flags
= look
->bfd_section
->flags
;
1585 if (match_type
&& !match_type (link_info
.output_bfd
,
1590 differ
= look_flags
^ sec_flags
;
1591 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1592 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1596 else if ((sec_flags
& SEC_READONLY
) != 0
1597 && (sec_flags
& SEC_ALLOC
) != 0)
1599 /* .rodata can go after .text, .sdata2 after .rodata. */
1600 for (look
= first
; look
; look
= look
->next
)
1602 look_flags
= look
->flags
;
1603 if (look
->bfd_section
!= NULL
)
1605 look_flags
= look
->bfd_section
->flags
;
1606 if (match_type
&& !match_type (link_info
.output_bfd
,
1611 differ
= look_flags
^ sec_flags
;
1612 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1613 | SEC_READONLY
| SEC_SMALL_DATA
))
1614 || (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1616 && !(look_flags
& SEC_SMALL_DATA
)))
1620 else if ((sec_flags
& SEC_THREAD_LOCAL
) != 0
1621 && (sec_flags
& SEC_ALLOC
) != 0)
1623 /* .tdata can go after .data, .tbss after .tdata. Treat .tbss
1624 as if it were a loaded section, and don't use match_type. */
1625 bfd_boolean seen_thread_local
= FALSE
;
1628 for (look
= first
; look
; look
= look
->next
)
1630 look_flags
= look
->flags
;
1631 if (look
->bfd_section
!= NULL
)
1632 look_flags
= look
->bfd_section
->flags
;
1634 differ
= look_flags
^ (sec_flags
| SEC_LOAD
| SEC_HAS_CONTENTS
);
1635 if (!(differ
& (SEC_THREAD_LOCAL
| SEC_ALLOC
)))
1637 /* .tdata and .tbss must be adjacent and in that order. */
1638 if (!(look_flags
& SEC_LOAD
)
1639 && (sec_flags
& SEC_LOAD
))
1640 /* ..so if we're at a .tbss section and we're placing
1641 a .tdata section stop looking and return the
1642 previous section. */
1645 seen_thread_local
= TRUE
;
1647 else if (seen_thread_local
)
1649 else if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
)))
1653 else if ((sec_flags
& SEC_SMALL_DATA
) != 0
1654 && (sec_flags
& SEC_ALLOC
) != 0)
1656 /* .sdata goes after .data, .sbss after .sdata. */
1657 for (look
= first
; look
; look
= look
->next
)
1659 look_flags
= look
->flags
;
1660 if (look
->bfd_section
!= NULL
)
1662 look_flags
= look
->bfd_section
->flags
;
1663 if (match_type
&& !match_type (link_info
.output_bfd
,
1668 differ
= look_flags
^ sec_flags
;
1669 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1670 | SEC_THREAD_LOCAL
))
1671 || ((look_flags
& SEC_SMALL_DATA
)
1672 && !(sec_flags
& SEC_HAS_CONTENTS
)))
1676 else if ((sec_flags
& SEC_HAS_CONTENTS
) != 0
1677 && (sec_flags
& SEC_ALLOC
) != 0)
1679 /* .data goes after .rodata. */
1680 for (look
= first
; look
; look
= look
->next
)
1682 look_flags
= look
->flags
;
1683 if (look
->bfd_section
!= NULL
)
1685 look_flags
= look
->bfd_section
->flags
;
1686 if (match_type
&& !match_type (link_info
.output_bfd
,
1691 differ
= look_flags
^ sec_flags
;
1692 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1693 | SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1697 else if ((sec_flags
& SEC_ALLOC
) != 0)
1699 /* .bss goes after any other alloc section. */
1700 for (look
= first
; look
; look
= look
->next
)
1702 look_flags
= look
->flags
;
1703 if (look
->bfd_section
!= NULL
)
1705 look_flags
= look
->bfd_section
->flags
;
1706 if (match_type
&& !match_type (link_info
.output_bfd
,
1711 differ
= look_flags
^ sec_flags
;
1712 if (!(differ
& SEC_ALLOC
))
1718 /* non-alloc go last. */
1719 for (look
= first
; look
; look
= look
->next
)
1721 look_flags
= look
->flags
;
1722 if (look
->bfd_section
!= NULL
)
1723 look_flags
= look
->bfd_section
->flags
;
1724 differ
= look_flags
^ sec_flags
;
1725 if (!(differ
& SEC_DEBUGGING
))
1731 if (found
|| !match_type
)
1734 return lang_output_section_find_by_flags (sec
, sec_flags
, NULL
, NULL
);
1737 /* Find the last output section before given output statement.
1738 Used by place_orphan. */
1741 output_prev_sec_find (lang_output_section_statement_type
*os
)
1743 lang_output_section_statement_type
*lookup
;
1745 for (lookup
= os
->prev
; lookup
!= NULL
; lookup
= lookup
->prev
)
1747 if (lookup
->constraint
< 0)
1750 if (lookup
->bfd_section
!= NULL
&& lookup
->bfd_section
->owner
!= NULL
)
1751 return lookup
->bfd_section
;
1757 /* Look for a suitable place for a new output section statement. The
1758 idea is to skip over anything that might be inside a SECTIONS {}
1759 statement in a script, before we find another output section
1760 statement. Assignments to "dot" before an output section statement
1761 are assumed to belong to it, except in two cases; The first
1762 assignment to dot, and assignments before non-alloc sections.
1763 Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
1764 similar assignments that set the initial address, or we might
1765 insert non-alloc note sections among assignments setting end of
1768 static lang_statement_union_type
**
1769 insert_os_after (lang_output_section_statement_type
*after
)
1771 lang_statement_union_type
**where
;
1772 lang_statement_union_type
**assign
= NULL
;
1773 bfd_boolean ignore_first
;
1775 ignore_first
= after
== &lang_os_list
.head
->output_section_statement
;
1777 for (where
= &after
->header
.next
;
1779 where
= &(*where
)->header
.next
)
1781 switch ((*where
)->header
.type
)
1783 case lang_assignment_statement_enum
:
1786 lang_assignment_statement_type
*ass
;
1788 ass
= &(*where
)->assignment_statement
;
1789 if (ass
->exp
->type
.node_class
!= etree_assert
1790 && ass
->exp
->assign
.dst
[0] == '.'
1791 && ass
->exp
->assign
.dst
[1] == 0)
1795 ignore_first
= FALSE
;
1799 case lang_wild_statement_enum
:
1800 case lang_input_section_enum
:
1801 case lang_object_symbols_statement_enum
:
1802 case lang_fill_statement_enum
:
1803 case lang_data_statement_enum
:
1804 case lang_reloc_statement_enum
:
1805 case lang_padding_statement_enum
:
1806 case lang_constructors_statement_enum
:
1808 ignore_first
= FALSE
;
1810 case lang_output_section_statement_enum
:
1813 asection
*s
= (*where
)->output_section_statement
.bfd_section
;
1816 || s
->map_head
.s
== NULL
1817 || (s
->flags
& SEC_ALLOC
) != 0)
1821 case lang_input_statement_enum
:
1822 case lang_address_statement_enum
:
1823 case lang_target_statement_enum
:
1824 case lang_output_statement_enum
:
1825 case lang_group_statement_enum
:
1826 case lang_insert_statement_enum
:
1835 lang_output_section_statement_type
*
1836 lang_insert_orphan (asection
*s
,
1837 const char *secname
,
1839 lang_output_section_statement_type
*after
,
1840 struct orphan_save
*place
,
1841 etree_type
*address
,
1842 lang_statement_list_type
*add_child
)
1844 lang_statement_list_type add
;
1845 lang_output_section_statement_type
*os
;
1846 lang_output_section_statement_type
**os_tail
;
1848 /* If we have found an appropriate place for the output section
1849 statements for this orphan, add them to our own private list,
1850 inserting them later into the global statement list. */
1853 lang_list_init (&add
);
1854 push_stat_ptr (&add
);
1857 if (bfd_link_relocatable (&link_info
)
1858 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
1859 address
= exp_intop (0);
1861 os_tail
= (lang_output_section_statement_type
**) lang_os_list
.tail
;
1862 os
= lang_enter_output_section_statement (secname
, address
, normal_section
,
1863 NULL
, NULL
, NULL
, constraint
, 0);
1865 if (add_child
== NULL
)
1866 add_child
= &os
->children
;
1867 lang_add_section (add_child
, s
, NULL
, os
);
1869 if (after
&& (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) != 0)
1871 const char *region
= (after
->region
1872 ? after
->region
->name_list
.name
1873 : DEFAULT_MEMORY_REGION
);
1874 const char *lma_region
= (after
->lma_region
1875 ? after
->lma_region
->name_list
.name
1877 lang_leave_output_section_statement (NULL
, region
, after
->phdrs
,
1881 lang_leave_output_section_statement (NULL
, DEFAULT_MEMORY_REGION
, NULL
,
1884 /* Restore the global list pointer. */
1888 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
1890 asection
*snew
, *as
;
1891 bfd_boolean place_after
= place
->stmt
== NULL
;
1892 bfd_boolean insert_after
= TRUE
;
1894 snew
= os
->bfd_section
;
1896 /* Shuffle the bfd section list to make the output file look
1897 neater. This is really only cosmetic. */
1898 if (place
->section
== NULL
1899 && after
!= &lang_os_list
.head
->output_section_statement
)
1901 asection
*bfd_section
= after
->bfd_section
;
1903 /* If the output statement hasn't been used to place any input
1904 sections (and thus doesn't have an output bfd_section),
1905 look for the closest prior output statement having an
1907 if (bfd_section
== NULL
)
1908 bfd_section
= output_prev_sec_find (after
);
1910 if (bfd_section
!= NULL
&& bfd_section
!= snew
)
1911 place
->section
= &bfd_section
->next
;
1914 if (place
->section
== NULL
)
1915 place
->section
= &link_info
.output_bfd
->sections
;
1917 as
= *place
->section
;
1921 /* Put the section at the end of the list. */
1923 /* Unlink the section. */
1924 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1926 /* Now tack it back on in the right place. */
1927 bfd_section_list_append (link_info
.output_bfd
, snew
);
1929 else if ((bfd_get_flavour (link_info
.output_bfd
)
1930 == bfd_target_elf_flavour
)
1931 && (bfd_get_flavour (s
->owner
)
1932 == bfd_target_elf_flavour
)
1933 && ((elf_section_type (s
) == SHT_NOTE
1934 && (s
->flags
& SEC_LOAD
) != 0)
1935 || (elf_section_type (as
) == SHT_NOTE
1936 && (as
->flags
& SEC_LOAD
) != 0)))
1938 /* Make sure that output note sections are grouped and sorted
1939 by alignments when inserting a note section or insert a
1940 section after a note section, */
1942 /* A specific section after which the output note section
1943 should be placed. */
1944 asection
*after_sec
;
1945 /* True if we need to insert the orphan section after a
1946 specific section to maintain output note section order. */
1947 bfd_boolean after_sec_note
= FALSE
;
1949 static asection
*first_orphan_note
= NULL
;
1951 /* Group and sort output note section by alignments in
1954 if (elf_section_type (s
) == SHT_NOTE
1955 && (s
->flags
& SEC_LOAD
) != 0)
1957 /* Search from the beginning for the last output note
1958 section with equal or larger alignments. NB: Don't
1959 place orphan note section after non-note sections. */
1961 first_orphan_note
= NULL
;
1962 for (sec
= link_info
.output_bfd
->sections
;
1964 && !bfd_is_abs_section (sec
));
1967 && elf_section_type (sec
) == SHT_NOTE
1968 && (sec
->flags
& SEC_LOAD
) != 0)
1970 if (!first_orphan_note
)
1971 first_orphan_note
= sec
;
1972 if (sec
->alignment_power
>= s
->alignment_power
)
1975 else if (first_orphan_note
)
1977 /* Stop if there is non-note section after the first
1978 orphan note section. */
1982 /* If this will be the first orphan note section, it can
1983 be placed at the default location. */
1984 after_sec_note
= first_orphan_note
!= NULL
;
1985 if (after_sec
== NULL
&& after_sec_note
)
1987 /* If all output note sections have smaller
1988 alignments, place the section before all
1989 output orphan note sections. */
1990 after_sec
= first_orphan_note
;
1991 insert_after
= FALSE
;
1994 else if (first_orphan_note
)
1996 /* Don't place non-note sections in the middle of orphan
1998 after_sec_note
= TRUE
;
2000 for (sec
= as
->next
;
2002 && !bfd_is_abs_section (sec
));
2004 if (elf_section_type (sec
) == SHT_NOTE
2005 && (sec
->flags
& SEC_LOAD
) != 0)
2013 /* Search forward to insert OS after AFTER_SEC output
2015 lang_output_section_statement_type
*stmt
, *next
;
2016 bfd_boolean found
= FALSE
;
2017 for (stmt
= after
; stmt
!= NULL
; stmt
= next
)
2022 if (stmt
->bfd_section
== after_sec
)
2032 /* If INSERT_AFTER is FALSE, place OS before
2033 AFTER_SEC output statement. */
2034 if (next
&& next
->bfd_section
== after_sec
)
2044 /* Search backward to insert OS after AFTER_SEC output
2047 for (stmt
= after
; stmt
!= NULL
; stmt
= stmt
->prev
)
2051 if (stmt
->bfd_section
== after_sec
)
2060 /* If INSERT_AFTER is FALSE, place OS before
2061 AFTER_SEC output statement. */
2062 if (stmt
->next
->bfd_section
== after_sec
)
2072 if (after_sec
== NULL
2073 || (insert_after
&& after_sec
->next
!= snew
)
2074 || (!insert_after
&& after_sec
->prev
!= snew
))
2076 /* Unlink the section. */
2077 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2079 /* Place SNEW after AFTER_SEC. If AFTER_SEC is NULL,
2084 bfd_section_list_insert_after (link_info
.output_bfd
,
2087 bfd_section_list_insert_before (link_info
.output_bfd
,
2091 bfd_section_list_prepend (link_info
.output_bfd
, snew
);
2094 else if (as
!= snew
&& as
->prev
!= snew
)
2096 /* Unlink the section. */
2097 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2099 /* Now tack it back on in the right place. */
2100 bfd_section_list_insert_before (link_info
.output_bfd
,
2104 else if (as
!= snew
&& as
->prev
!= snew
)
2106 /* Unlink the section. */
2107 bfd_section_list_remove (link_info
.output_bfd
, snew
);
2109 /* Now tack it back on in the right place. */
2110 bfd_section_list_insert_before (link_info
.output_bfd
, as
, snew
);
2113 /* Save the end of this list. Further ophans of this type will
2114 follow the one we've just added. */
2115 place
->section
= &snew
->next
;
2117 /* The following is non-cosmetic. We try to put the output
2118 statements in some sort of reasonable order here, because they
2119 determine the final load addresses of the orphan sections.
2120 In addition, placing output statements in the wrong order may
2121 require extra segments. For instance, given a typical
2122 situation of all read-only sections placed in one segment and
2123 following that a segment containing all the read-write
2124 sections, we wouldn't want to place an orphan read/write
2125 section before or amongst the read-only ones. */
2126 if (add
.head
!= NULL
)
2128 lang_output_section_statement_type
*newly_added_os
;
2130 /* Place OS after AFTER if AFTER_NOTE is TRUE. */
2133 lang_statement_union_type
**where
= insert_os_after (after
);
2138 place
->os_tail
= &after
->next
;
2142 /* Put it after the last orphan statement we added. */
2143 *add
.tail
= *place
->stmt
;
2144 *place
->stmt
= add
.head
;
2147 /* Fix the global list pointer if we happened to tack our
2148 new list at the tail. */
2149 if (*stat_ptr
->tail
== add
.head
)
2150 stat_ptr
->tail
= add
.tail
;
2152 /* Save the end of this list. */
2153 place
->stmt
= add
.tail
;
2155 /* Do the same for the list of output section statements. */
2156 newly_added_os
= *os_tail
;
2158 newly_added_os
->prev
= (lang_output_section_statement_type
*)
2159 ((char *) place
->os_tail
2160 - offsetof (lang_output_section_statement_type
, next
));
2161 newly_added_os
->next
= *place
->os_tail
;
2162 if (newly_added_os
->next
!= NULL
)
2163 newly_added_os
->next
->prev
= newly_added_os
;
2164 *place
->os_tail
= newly_added_os
;
2165 place
->os_tail
= &newly_added_os
->next
;
2167 /* Fixing the global list pointer here is a little different.
2168 We added to the list in lang_enter_output_section_statement,
2169 trimmed off the new output_section_statment above when
2170 assigning *os_tail = NULL, but possibly added it back in
2171 the same place when assigning *place->os_tail. */
2172 if (*os_tail
== NULL
)
2173 lang_os_list
.tail
= (lang_statement_union_type
**) os_tail
;
2180 lang_print_asneeded (void)
2182 struct asneeded_minfo
*m
;
2184 if (asneeded_list_head
== NULL
)
2187 minfo (_("\nAs-needed library included to satisfy reference by file (symbol)\n\n"));
2189 for (m
= asneeded_list_head
; m
!= NULL
; m
= m
->next
)
2193 minfo ("%s", m
->soname
);
2194 len
= strlen (m
->soname
);
2208 minfo ("%pB ", m
->ref
);
2209 minfo ("(%pT)\n", m
->name
);
2214 lang_map_flags (flagword flag
)
2216 if (flag
& SEC_ALLOC
)
2219 if (flag
& SEC_CODE
)
2222 if (flag
& SEC_READONLY
)
2225 if (flag
& SEC_DATA
)
2228 if (flag
& SEC_LOAD
)
2235 lang_memory_region_type
*m
;
2236 bfd_boolean dis_header_printed
= FALSE
;
2238 LANG_FOR_EACH_INPUT_STATEMENT (file
)
2242 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
2243 || file
->flags
.just_syms
)
2246 if (config
.print_map_discarded
)
2247 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2248 if ((s
->output_section
== NULL
2249 || s
->output_section
->owner
!= link_info
.output_bfd
)
2250 && (s
->flags
& (SEC_LINKER_CREATED
| SEC_KEEP
)) == 0)
2252 if (! dis_header_printed
)
2254 fprintf (config
.map_file
, _("\nDiscarded input sections\n\n"));
2255 dis_header_printed
= TRUE
;
2258 print_input_section (s
, TRUE
);
2262 minfo (_("\nMemory Configuration\n\n"));
2263 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
2264 _("Name"), _("Origin"), _("Length"), _("Attributes"));
2266 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
2271 fprintf (config
.map_file
, "%-16s ", m
->name_list
.name
);
2273 sprintf_vma (buf
, m
->origin
);
2274 minfo ("0x%s ", buf
);
2282 minfo ("0x%V", m
->length
);
2283 if (m
->flags
|| m
->not_flags
)
2291 lang_map_flags (m
->flags
);
2297 lang_map_flags (m
->not_flags
);
2304 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
2306 if (!link_info
.reduce_memory_overheads
)
2308 obstack_begin (&map_obstack
, 1000);
2309 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
2311 expld
.phase
= lang_fixed_phase_enum
;
2312 lang_statement_iteration
++;
2313 print_statements ();
2315 ldemul_extra_map_file_text (link_info
.output_bfd
, &link_info
,
2320 sort_def_symbol (struct bfd_link_hash_entry
*hash_entry
,
2321 void *info ATTRIBUTE_UNUSED
)
2323 if ((hash_entry
->type
== bfd_link_hash_defined
2324 || hash_entry
->type
== bfd_link_hash_defweak
)
2325 && hash_entry
->u
.def
.section
->owner
!= link_info
.output_bfd
2326 && hash_entry
->u
.def
.section
->owner
!= NULL
)
2328 input_section_userdata_type
*ud
;
2329 struct map_symbol_def
*def
;
2331 ud
= bfd_section_userdata (hash_entry
->u
.def
.section
);
2334 ud
= stat_alloc (sizeof (*ud
));
2335 bfd_set_section_userdata (hash_entry
->u
.def
.section
, ud
);
2336 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2337 ud
->map_symbol_def_count
= 0;
2339 else if (!ud
->map_symbol_def_tail
)
2340 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2342 def
= (struct map_symbol_def
*) obstack_alloc (&map_obstack
, sizeof *def
);
2343 def
->entry
= hash_entry
;
2344 *(ud
->map_symbol_def_tail
) = def
;
2345 ud
->map_symbol_def_tail
= &def
->next
;
2346 ud
->map_symbol_def_count
++;
2351 /* Initialize an output section. */
2354 init_os (lang_output_section_statement_type
*s
, flagword flags
)
2356 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
2357 einfo (_("%F%P: illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
2359 if (s
->constraint
!= SPECIAL
)
2360 s
->bfd_section
= bfd_get_section_by_name (link_info
.output_bfd
, s
->name
);
2361 if (s
->bfd_section
== NULL
)
2362 s
->bfd_section
= bfd_make_section_anyway_with_flags (link_info
.output_bfd
,
2364 if (s
->bfd_section
== NULL
)
2366 einfo (_("%F%P: output format %s cannot represent section"
2367 " called %s: %E\n"),
2368 link_info
.output_bfd
->xvec
->name
, s
->name
);
2370 s
->bfd_section
->output_section
= s
->bfd_section
;
2371 s
->bfd_section
->output_offset
= 0;
2373 /* Set the userdata of the output section to the output section
2374 statement to avoid lookup. */
2375 bfd_set_section_userdata (s
->bfd_section
, s
);
2377 /* If there is a base address, make sure that any sections it might
2378 mention are initialized. */
2379 if (s
->addr_tree
!= NULL
)
2380 exp_init_os (s
->addr_tree
);
2382 if (s
->load_base
!= NULL
)
2383 exp_init_os (s
->load_base
);
2385 /* If supplied an alignment, set it. */
2386 if (s
->section_alignment
!= NULL
)
2387 s
->bfd_section
->alignment_power
= exp_get_power (s
->section_alignment
,
2388 "section alignment");
2391 /* Make sure that all output sections mentioned in an expression are
2395 exp_init_os (etree_type
*exp
)
2397 switch (exp
->type
.node_class
)
2401 case etree_provided
:
2402 exp_init_os (exp
->assign
.src
);
2406 exp_init_os (exp
->binary
.lhs
);
2407 exp_init_os (exp
->binary
.rhs
);
2411 exp_init_os (exp
->trinary
.cond
);
2412 exp_init_os (exp
->trinary
.lhs
);
2413 exp_init_os (exp
->trinary
.rhs
);
2417 exp_init_os (exp
->assert_s
.child
);
2421 exp_init_os (exp
->unary
.child
);
2425 switch (exp
->type
.node_code
)
2431 lang_output_section_statement_type
*os
;
2433 os
= lang_output_section_find (exp
->name
.name
);
2434 if (os
!= NULL
&& os
->bfd_section
== NULL
)
2446 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
2448 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
2450 /* If we are only reading symbols from this object, then we want to
2451 discard all sections. */
2452 if (entry
->flags
.just_syms
)
2454 bfd_link_just_syms (abfd
, sec
, &link_info
);
2458 /* Deal with SHF_EXCLUDE ELF sections. */
2459 if (!bfd_link_relocatable (&link_info
)
2460 && (abfd
->flags
& BFD_PLUGIN
) == 0
2461 && (sec
->flags
& (SEC_GROUP
| SEC_KEEP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
2462 sec
->output_section
= bfd_abs_section_ptr
;
2464 if (!(abfd
->flags
& DYNAMIC
))
2465 bfd_section_already_linked (abfd
, sec
, &link_info
);
2469 /* Returns true if SECTION is one we know will be discarded based on its
2470 section flags, otherwise returns false. */
2473 lang_discard_section_p (asection
*section
)
2475 bfd_boolean discard
;
2476 flagword flags
= section
->flags
;
2478 /* Discard sections marked with SEC_EXCLUDE. */
2479 discard
= (flags
& SEC_EXCLUDE
) != 0;
2481 /* Discard the group descriptor sections when we're finally placing the
2482 sections from within the group. */
2483 if ((flags
& SEC_GROUP
) != 0
2484 && link_info
.resolve_section_groups
)
2487 /* Discard debugging sections if we are stripping debugging
2489 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
2490 && (flags
& SEC_DEBUGGING
) != 0)
2496 /* The wild routines.
2498 These expand statements like *(.text) and foo.o to a list of
2499 explicit actions, like foo.o(.text), bar.o(.text) and
2500 foo.o(.text, .data). */
2502 /* Add SECTION to the output section OUTPUT. Do this by creating a
2503 lang_input_section statement which is placed at PTR. */
2506 lang_add_section (lang_statement_list_type
*ptr
,
2508 struct flag_info
*sflag_info
,
2509 lang_output_section_statement_type
*output
)
2511 flagword flags
= section
->flags
;
2513 bfd_boolean discard
;
2514 lang_input_section_type
*new_section
;
2515 bfd
*abfd
= link_info
.output_bfd
;
2517 /* Is this section one we know should be discarded? */
2518 discard
= lang_discard_section_p (section
);
2520 /* Discard input sections which are assigned to a section named
2521 DISCARD_SECTION_NAME. */
2522 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
2527 if (section
->output_section
== NULL
)
2529 /* This prevents future calls from assigning this section. */
2530 section
->output_section
= bfd_abs_section_ptr
;
2539 keep
= bfd_lookup_section_flags (&link_info
, sflag_info
, section
);
2544 if (section
->output_section
!= NULL
)
2547 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2548 to an output section, because we want to be able to include a
2549 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2550 section (I don't know why we want to do this, but we do).
2551 build_link_order in ldwrite.c handles this case by turning
2552 the embedded SEC_NEVER_LOAD section into a fill. */
2553 flags
&= ~ SEC_NEVER_LOAD
;
2555 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2556 already been processed. One reason to do this is that on pe
2557 format targets, .text$foo sections go into .text and it's odd
2558 to see .text with SEC_LINK_ONCE set. */
2559 if ((flags
& (SEC_LINK_ONCE
| SEC_GROUP
)) == (SEC_LINK_ONCE
| SEC_GROUP
))
2561 if (link_info
.resolve_section_groups
)
2562 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2564 flags
&= ~(SEC_LINK_DUPLICATES
| SEC_RELOC
);
2566 else if (!bfd_link_relocatable (&link_info
))
2567 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2569 switch (output
->sectype
)
2571 case normal_section
:
2572 case overlay_section
:
2573 case first_overlay_section
:
2575 case noalloc_section
:
2576 flags
&= ~SEC_ALLOC
;
2578 case noload_section
:
2580 flags
|= SEC_NEVER_LOAD
;
2581 /* Unfortunately GNU ld has managed to evolve two different
2582 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2583 alloc, no contents section. All others get a noload, noalloc
2585 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
2586 flags
&= ~SEC_HAS_CONTENTS
;
2588 flags
&= ~SEC_ALLOC
;
2592 if (output
->bfd_section
== NULL
)
2593 init_os (output
, flags
);
2595 /* If SEC_READONLY is not set in the input section, then clear
2596 it from the output section. */
2597 output
->bfd_section
->flags
&= flags
| ~SEC_READONLY
;
2599 if (output
->bfd_section
->linker_has_input
)
2601 /* Only set SEC_READONLY flag on the first input section. */
2602 flags
&= ~ SEC_READONLY
;
2604 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2605 if ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2606 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2607 || ((flags
& SEC_MERGE
) != 0
2608 && output
->bfd_section
->entsize
!= section
->entsize
))
2610 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2611 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2614 output
->bfd_section
->flags
|= flags
;
2616 if (!output
->bfd_section
->linker_has_input
)
2618 output
->bfd_section
->linker_has_input
= 1;
2619 /* This must happen after flags have been updated. The output
2620 section may have been created before we saw its first input
2621 section, eg. for a data statement. */
2622 bfd_init_private_section_data (section
->owner
, section
,
2623 link_info
.output_bfd
,
2624 output
->bfd_section
,
2626 if ((flags
& SEC_MERGE
) != 0)
2627 output
->bfd_section
->entsize
= section
->entsize
;
2630 if ((flags
& SEC_TIC54X_BLOCK
) != 0
2631 && bfd_get_arch (section
->owner
) == bfd_arch_tic54x
)
2633 /* FIXME: This value should really be obtained from the bfd... */
2634 output
->block_value
= 128;
2637 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2638 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2640 section
->output_section
= output
->bfd_section
;
2642 if (!map_head_is_link_order
)
2644 asection
*s
= output
->bfd_section
->map_tail
.s
;
2645 output
->bfd_section
->map_tail
.s
= section
;
2646 section
->map_head
.s
= NULL
;
2647 section
->map_tail
.s
= s
;
2649 s
->map_head
.s
= section
;
2651 output
->bfd_section
->map_head
.s
= section
;
2654 /* Add a section reference to the list. */
2655 new_section
= new_stat (lang_input_section
, ptr
);
2656 new_section
->section
= section
;
2659 /* Handle wildcard sorting. This returns the lang_input_section which
2660 should follow the one we are going to create for SECTION and FILE,
2661 based on the sorting requirements of WILD. It returns NULL if the
2662 new section should just go at the end of the current list. */
2664 static lang_statement_union_type
*
2665 wild_sort (lang_wild_statement_type
*wild
,
2666 struct wildcard_list
*sec
,
2667 lang_input_statement_type
*file
,
2670 lang_statement_union_type
*l
;
2672 if (!wild
->filenames_sorted
2673 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
2676 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
2678 lang_input_section_type
*ls
;
2680 if (l
->header
.type
!= lang_input_section_enum
)
2682 ls
= &l
->input_section
;
2684 /* Sorting by filename takes precedence over sorting by section
2687 if (wild
->filenames_sorted
)
2689 const char *fn
, *ln
;
2693 /* The PE support for the .idata section as generated by
2694 dlltool assumes that files will be sorted by the name of
2695 the archive and then the name of the file within the
2698 if (file
->the_bfd
!= NULL
2699 && file
->the_bfd
->my_archive
!= NULL
)
2701 fn
= bfd_get_filename (file
->the_bfd
->my_archive
);
2706 fn
= file
->filename
;
2710 if (ls
->section
->owner
->my_archive
!= NULL
)
2712 ln
= bfd_get_filename (ls
->section
->owner
->my_archive
);
2717 ln
= ls
->section
->owner
->filename
;
2721 i
= filename_cmp (fn
, ln
);
2730 fn
= file
->filename
;
2732 ln
= ls
->section
->owner
->filename
;
2734 i
= filename_cmp (fn
, ln
);
2742 /* Here either the files are not sorted by name, or we are
2743 looking at the sections for this file. */
2746 && sec
->spec
.sorted
!= none
2747 && sec
->spec
.sorted
!= by_none
)
2748 if (compare_section (sec
->spec
.sorted
, section
, ls
->section
) < 0)
2755 /* Expand a wild statement for a particular FILE. SECTION may be
2756 NULL, in which case it is a wild card. */
2759 output_section_callback (lang_wild_statement_type
*ptr
,
2760 struct wildcard_list
*sec
,
2762 struct flag_info
*sflag_info
,
2763 lang_input_statement_type
*file
,
2766 lang_statement_union_type
*before
;
2767 lang_output_section_statement_type
*os
;
2769 os
= (lang_output_section_statement_type
*) output
;
2771 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2772 if (unique_section_p (section
, os
))
2775 before
= wild_sort (ptr
, sec
, file
, section
);
2777 /* Here BEFORE points to the lang_input_section which
2778 should follow the one we are about to add. If BEFORE
2779 is NULL, then the section should just go at the end
2780 of the current list. */
2783 lang_add_section (&ptr
->children
, section
, sflag_info
, os
);
2786 lang_statement_list_type list
;
2787 lang_statement_union_type
**pp
;
2789 lang_list_init (&list
);
2790 lang_add_section (&list
, section
, sflag_info
, os
);
2792 /* If we are discarding the section, LIST.HEAD will
2794 if (list
.head
!= NULL
)
2796 ASSERT (list
.head
->header
.next
== NULL
);
2798 for (pp
= &ptr
->children
.head
;
2800 pp
= &(*pp
)->header
.next
)
2801 ASSERT (*pp
!= NULL
);
2803 list
.head
->header
.next
= *pp
;
2809 /* Check if all sections in a wild statement for a particular FILE
2813 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2814 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2816 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
2817 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2820 lang_output_section_statement_type
*os
;
2822 os
= (lang_output_section_statement_type
*) output
;
2824 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2825 if (unique_section_p (section
, os
))
2828 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2829 os
->all_input_readonly
= FALSE
;
2832 /* This is passed a file name which must have been seen already and
2833 added to the statement tree. We will see if it has been opened
2834 already and had its symbols read. If not then we'll read it. */
2836 static lang_input_statement_type
*
2837 lookup_name (const char *name
)
2839 lang_input_statement_type
*search
;
2841 for (search
= &input_file_chain
.head
->input_statement
;
2843 search
= search
->next_real_file
)
2845 /* Use the local_sym_name as the name of the file that has
2846 already been loaded as filename might have been transformed
2847 via the search directory lookup mechanism. */
2848 const char *filename
= search
->local_sym_name
;
2850 if (filename
!= NULL
2851 && filename_cmp (filename
, name
) == 0)
2857 /* Arrange to splice the input statement added by new_afile into
2858 statement_list after the current input_file_chain tail.
2859 We know input_file_chain is not an empty list, and that
2860 lookup_name was called via open_input_bfds. Later calls to
2861 lookup_name should always match an existing input_statement. */
2862 lang_statement_union_type
**tail
= stat_ptr
->tail
;
2863 lang_statement_union_type
**after
2864 = (void *) ((char *) input_file_chain
.tail
2865 - offsetof (lang_input_statement_type
, next_real_file
)
2866 + offsetof (lang_input_statement_type
, header
.next
));
2867 lang_statement_union_type
*rest
= *after
;
2868 stat_ptr
->tail
= after
;
2869 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2871 *stat_ptr
->tail
= rest
;
2873 stat_ptr
->tail
= tail
;
2876 /* If we have already added this file, or this file is not real
2877 don't add this file. */
2878 if (search
->flags
.loaded
|| !search
->flags
.real
)
2881 if (!load_symbols (search
, NULL
))
2887 /* Save LIST as a list of libraries whose symbols should not be exported. */
2892 struct excluded_lib
*next
;
2894 static struct excluded_lib
*excluded_libs
;
2897 add_excluded_libs (const char *list
)
2899 const char *p
= list
, *end
;
2903 struct excluded_lib
*entry
;
2904 end
= strpbrk (p
, ",:");
2906 end
= p
+ strlen (p
);
2907 entry
= (struct excluded_lib
*) xmalloc (sizeof (*entry
));
2908 entry
->next
= excluded_libs
;
2909 entry
->name
= (char *) xmalloc (end
- p
+ 1);
2910 memcpy (entry
->name
, p
, end
- p
);
2911 entry
->name
[end
- p
] = '\0';
2912 excluded_libs
= entry
;
2920 check_excluded_libs (bfd
*abfd
)
2922 struct excluded_lib
*lib
= excluded_libs
;
2926 int len
= strlen (lib
->name
);
2927 const char *filename
= lbasename (abfd
->filename
);
2929 if (strcmp (lib
->name
, "ALL") == 0)
2931 abfd
->no_export
= TRUE
;
2935 if (filename_ncmp (lib
->name
, filename
, len
) == 0
2936 && (filename
[len
] == '\0'
2937 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
2938 && filename
[len
+ 2] == '\0')))
2940 abfd
->no_export
= TRUE
;
2948 /* Get the symbols for an input file. */
2951 load_symbols (lang_input_statement_type
*entry
,
2952 lang_statement_list_type
*place
)
2956 if (entry
->flags
.loaded
)
2959 ldfile_open_file (entry
);
2961 /* Do not process further if the file was missing. */
2962 if (entry
->flags
.missing_file
)
2965 if (trace_files
|| verbose
)
2966 info_msg ("%pI\n", entry
);
2968 if (!bfd_check_format (entry
->the_bfd
, bfd_archive
)
2969 && !bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
2972 struct lang_input_statement_flags save_flags
;
2975 err
= bfd_get_error ();
2977 /* See if the emulation has some special knowledge. */
2978 if (ldemul_unrecognized_file (entry
))
2981 if (err
== bfd_error_file_ambiguously_recognized
)
2985 einfo (_("%P: %pB: file not recognized: %E;"
2986 " matching formats:"), entry
->the_bfd
);
2987 for (p
= matching
; *p
!= NULL
; p
++)
2991 else if (err
!= bfd_error_file_not_recognized
2993 einfo (_("%F%P: %pB: file not recognized: %E\n"), entry
->the_bfd
);
2995 bfd_close (entry
->the_bfd
);
2996 entry
->the_bfd
= NULL
;
2998 /* Try to interpret the file as a linker script. */
2999 save_flags
= input_flags
;
3000 ldfile_open_command_file (entry
->filename
);
3002 push_stat_ptr (place
);
3003 input_flags
.add_DT_NEEDED_for_regular
3004 = entry
->flags
.add_DT_NEEDED_for_regular
;
3005 input_flags
.add_DT_NEEDED_for_dynamic
3006 = entry
->flags
.add_DT_NEEDED_for_dynamic
;
3007 input_flags
.whole_archive
= entry
->flags
.whole_archive
;
3008 input_flags
.dynamic
= entry
->flags
.dynamic
;
3010 ldfile_assumed_script
= TRUE
;
3011 parser_input
= input_script
;
3013 ldfile_assumed_script
= FALSE
;
3015 /* missing_file is sticky. sysrooted will already have been
3016 restored when seeing EOF in yyparse, but no harm to restore
3018 save_flags
.missing_file
|= input_flags
.missing_file
;
3019 input_flags
= save_flags
;
3023 entry
->flags
.loaded
= TRUE
;
3028 if (ldemul_recognized_file (entry
))
3031 /* We don't call ldlang_add_file for an archive. Instead, the
3032 add_symbols entry point will call ldlang_add_file, via the
3033 add_archive_element callback, for each element of the archive
3035 switch (bfd_get_format (entry
->the_bfd
))
3041 if (!entry
->flags
.reload
)
3042 ldlang_add_file (entry
);
3046 check_excluded_libs (entry
->the_bfd
);
3048 bfd_set_usrdata (entry
->the_bfd
, entry
);
3049 if (entry
->flags
.whole_archive
)
3052 bfd_boolean loaded
= TRUE
;
3057 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
3062 if (!bfd_check_format (member
, bfd_object
))
3064 einfo (_("%F%P: %pB: member %pB in archive is not an object\n"),
3065 entry
->the_bfd
, member
);
3070 if (!(*link_info
.callbacks
3071 ->add_archive_element
) (&link_info
, member
,
3072 "--whole-archive", &subsbfd
))
3075 /* Potentially, the add_archive_element hook may have set a
3076 substitute BFD for us. */
3077 if (!bfd_link_add_symbols (subsbfd
, &link_info
))
3079 einfo (_("%F%P: %pB: error adding symbols: %E\n"), member
);
3084 entry
->flags
.loaded
= loaded
;
3090 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
3091 entry
->flags
.loaded
= TRUE
;
3093 einfo (_("%F%P: %pB: error adding symbols: %E\n"), entry
->the_bfd
);
3095 return entry
->flags
.loaded
;
3098 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
3099 may be NULL, indicating that it is a wildcard. Separate
3100 lang_input_section statements are created for each part of the
3101 expansion; they are added after the wild statement S. OUTPUT is
3102 the output section. */
3105 wild (lang_wild_statement_type
*s
,
3106 const char *target ATTRIBUTE_UNUSED
,
3107 lang_output_section_statement_type
*output
)
3109 struct wildcard_list
*sec
;
3111 if (s
->handler_data
[0]
3112 && s
->handler_data
[0]->spec
.sorted
== by_name
3113 && !s
->filenames_sorted
)
3115 lang_section_bst_type
*tree
;
3117 walk_wild (s
, output_section_callback_fast
, output
);
3122 output_section_callback_tree_to_list (s
, tree
, output
);
3127 walk_wild (s
, output_section_callback
, output
);
3129 if (default_common_section
== NULL
)
3130 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
3131 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
3133 /* Remember the section that common is going to in case we
3134 later get something which doesn't know where to put it. */
3135 default_common_section
= output
;
3140 /* Return TRUE iff target is the sought target. */
3143 get_target (const bfd_target
*target
, void *data
)
3145 const char *sought
= (const char *) data
;
3147 return strcmp (target
->name
, sought
) == 0;
3150 /* Like strcpy() but convert to lower case as well. */
3153 stricpy (char *dest
, const char *src
)
3157 while ((c
= *src
++) != 0)
3158 *dest
++ = TOLOWER (c
);
3163 /* Remove the first occurrence of needle (if any) in haystack
3167 strcut (char *haystack
, const char *needle
)
3169 haystack
= strstr (haystack
, needle
);
3175 for (src
= haystack
+ strlen (needle
); *src
;)
3176 *haystack
++ = *src
++;
3182 /* Compare two target format name strings.
3183 Return a value indicating how "similar" they are. */
3186 name_compare (const char *first
, const char *second
)
3192 copy1
= (char *) xmalloc (strlen (first
) + 1);
3193 copy2
= (char *) xmalloc (strlen (second
) + 1);
3195 /* Convert the names to lower case. */
3196 stricpy (copy1
, first
);
3197 stricpy (copy2
, second
);
3199 /* Remove size and endian strings from the name. */
3200 strcut (copy1
, "big");
3201 strcut (copy1
, "little");
3202 strcut (copy2
, "big");
3203 strcut (copy2
, "little");
3205 /* Return a value based on how many characters match,
3206 starting from the beginning. If both strings are
3207 the same then return 10 * their length. */
3208 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
3209 if (copy1
[result
] == 0)
3221 /* Set by closest_target_match() below. */
3222 static const bfd_target
*winner
;
3224 /* Scan all the valid bfd targets looking for one that has the endianness
3225 requirement that was specified on the command line, and is the nearest
3226 match to the original output target. */
3229 closest_target_match (const bfd_target
*target
, void *data
)
3231 const bfd_target
*original
= (const bfd_target
*) data
;
3233 if (command_line
.endian
== ENDIAN_BIG
3234 && target
->byteorder
!= BFD_ENDIAN_BIG
)
3237 if (command_line
.endian
== ENDIAN_LITTLE
3238 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
3241 /* Must be the same flavour. */
3242 if (target
->flavour
!= original
->flavour
)
3245 /* Ignore generic big and little endian elf vectors. */
3246 if (strcmp (target
->name
, "elf32-big") == 0
3247 || strcmp (target
->name
, "elf64-big") == 0
3248 || strcmp (target
->name
, "elf32-little") == 0
3249 || strcmp (target
->name
, "elf64-little") == 0)
3252 /* If we have not found a potential winner yet, then record this one. */
3259 /* Oh dear, we now have two potential candidates for a successful match.
3260 Compare their names and choose the better one. */
3261 if (name_compare (target
->name
, original
->name
)
3262 > name_compare (winner
->name
, original
->name
))
3265 /* Keep on searching until wqe have checked them all. */
3269 /* Return the BFD target format of the first input file. */
3272 get_first_input_target (void)
3274 const char *target
= NULL
;
3276 LANG_FOR_EACH_INPUT_STATEMENT (s
)
3278 if (s
->header
.type
== lang_input_statement_enum
3281 ldfile_open_file (s
);
3283 if (s
->the_bfd
!= NULL
3284 && bfd_check_format (s
->the_bfd
, bfd_object
))
3286 target
= bfd_get_target (s
->the_bfd
);
3298 lang_get_output_target (void)
3302 /* Has the user told us which output format to use? */
3303 if (output_target
!= NULL
)
3304 return output_target
;
3306 /* No - has the current target been set to something other than
3308 if (current_target
!= default_target
&& current_target
!= NULL
)
3309 return current_target
;
3311 /* No - can we determine the format of the first input file? */
3312 target
= get_first_input_target ();
3316 /* Failed - use the default output target. */
3317 return default_target
;
3320 /* Open the output file. */
3323 open_output (const char *name
)
3325 output_target
= lang_get_output_target ();
3327 /* Has the user requested a particular endianness on the command
3329 if (command_line
.endian
!= ENDIAN_UNSET
)
3331 /* Get the chosen target. */
3332 const bfd_target
*target
3333 = bfd_iterate_over_targets (get_target
, (void *) output_target
);
3335 /* If the target is not supported, we cannot do anything. */
3338 enum bfd_endian desired_endian
;
3340 if (command_line
.endian
== ENDIAN_BIG
)
3341 desired_endian
= BFD_ENDIAN_BIG
;
3343 desired_endian
= BFD_ENDIAN_LITTLE
;
3345 /* See if the target has the wrong endianness. This should
3346 not happen if the linker script has provided big and
3347 little endian alternatives, but some scrips don't do
3349 if (target
->byteorder
!= desired_endian
)
3351 /* If it does, then see if the target provides
3352 an alternative with the correct endianness. */
3353 if (target
->alternative_target
!= NULL
3354 && (target
->alternative_target
->byteorder
== desired_endian
))
3355 output_target
= target
->alternative_target
->name
;
3358 /* Try to find a target as similar as possible to
3359 the default target, but which has the desired
3360 endian characteristic. */
3361 bfd_iterate_over_targets (closest_target_match
,
3364 /* Oh dear - we could not find any targets that
3365 satisfy our requirements. */
3367 einfo (_("%P: warning: could not find any targets"
3368 " that match endianness requirement\n"));
3370 output_target
= winner
->name
;
3376 link_info
.output_bfd
= bfd_openw (name
, output_target
);
3378 if (link_info
.output_bfd
== NULL
)
3380 if (bfd_get_error () == bfd_error_invalid_target
)
3381 einfo (_("%F%P: target %s not found\n"), output_target
);
3383 einfo (_("%F%P: cannot open output file %s: %E\n"), name
);
3386 delete_output_file_on_failure
= TRUE
;
3388 if (!bfd_set_format (link_info
.output_bfd
, bfd_object
))
3389 einfo (_("%F%P: %s: can not make object file: %E\n"), name
);
3390 if (!bfd_set_arch_mach (link_info
.output_bfd
,
3391 ldfile_output_architecture
,
3392 ldfile_output_machine
))
3393 einfo (_("%F%P: %s: can not set architecture: %E\n"), name
);
3395 link_info
.hash
= bfd_link_hash_table_create (link_info
.output_bfd
);
3396 if (link_info
.hash
== NULL
)
3397 einfo (_("%F%P: can not create hash table: %E\n"));
3399 bfd_set_gp_size (link_info
.output_bfd
, g_switch_value
);
3403 ldlang_open_output (lang_statement_union_type
*statement
)
3405 switch (statement
->header
.type
)
3407 case lang_output_statement_enum
:
3408 ASSERT (link_info
.output_bfd
== NULL
);
3409 open_output (statement
->output_statement
.name
);
3410 ldemul_set_output_arch ();
3411 if (config
.magic_demand_paged
3412 && !bfd_link_relocatable (&link_info
))
3413 link_info
.output_bfd
->flags
|= D_PAGED
;
3415 link_info
.output_bfd
->flags
&= ~D_PAGED
;
3416 if (config
.text_read_only
)
3417 link_info
.output_bfd
->flags
|= WP_TEXT
;
3419 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
3420 if (link_info
.traditional_format
)
3421 link_info
.output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
3423 link_info
.output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
3426 case lang_target_statement_enum
:
3427 current_target
= statement
->target_statement
.target
;
3437 unsigned x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3438 ldfile_output_machine
);
3441 while ((x
& 1) == 0)
3449 /* Open all the input files. */
3453 OPEN_BFD_NORMAL
= 0,
3457 #ifdef ENABLE_PLUGINS
3458 static lang_input_statement_type
*plugin_insert
= NULL
;
3459 static struct bfd_link_hash_entry
*plugin_undefs
= NULL
;
3463 open_input_bfds (lang_statement_union_type
*s
, enum open_bfd_mode mode
)
3465 for (; s
!= NULL
; s
= s
->header
.next
)
3467 switch (s
->header
.type
)
3469 case lang_constructors_statement_enum
:
3470 open_input_bfds (constructor_list
.head
, mode
);
3472 case lang_output_section_statement_enum
:
3473 open_input_bfds (s
->output_section_statement
.children
.head
, mode
);
3475 case lang_wild_statement_enum
:
3476 /* Maybe we should load the file's symbols. */
3477 if ((mode
& OPEN_BFD_RESCAN
) == 0
3478 && s
->wild_statement
.filename
3479 && !wildcardp (s
->wild_statement
.filename
)
3480 && !archive_path (s
->wild_statement
.filename
))
3481 lookup_name (s
->wild_statement
.filename
);
3482 open_input_bfds (s
->wild_statement
.children
.head
, mode
);
3484 case lang_group_statement_enum
:
3486 struct bfd_link_hash_entry
*undefs
;
3487 #ifdef ENABLE_PLUGINS
3488 lang_input_statement_type
*plugin_insert_save
;
3491 /* We must continually search the entries in the group
3492 until no new symbols are added to the list of undefined
3497 #ifdef ENABLE_PLUGINS
3498 plugin_insert_save
= plugin_insert
;
3500 undefs
= link_info
.hash
->undefs_tail
;
3501 open_input_bfds (s
->group_statement
.children
.head
,
3502 mode
| OPEN_BFD_FORCE
);
3504 while (undefs
!= link_info
.hash
->undefs_tail
3505 #ifdef ENABLE_PLUGINS
3506 /* Objects inserted by a plugin, which are loaded
3507 before we hit this loop, may have added new
3509 || (plugin_insert
!= plugin_insert_save
&& plugin_undefs
)
3514 case lang_target_statement_enum
:
3515 current_target
= s
->target_statement
.target
;
3517 case lang_input_statement_enum
:
3518 if (s
->input_statement
.flags
.real
)
3520 lang_statement_union_type
**os_tail
;
3521 lang_statement_list_type add
;
3524 s
->input_statement
.target
= current_target
;
3526 /* If we are being called from within a group, and this
3527 is an archive which has already been searched, then
3528 force it to be researched unless the whole archive
3529 has been loaded already. Do the same for a rescan.
3530 Likewise reload --as-needed shared libs. */
3531 if (mode
!= OPEN_BFD_NORMAL
3532 #ifdef ENABLE_PLUGINS
3533 && ((mode
& OPEN_BFD_RESCAN
) == 0
3534 || plugin_insert
== NULL
)
3536 && s
->input_statement
.flags
.loaded
3537 && (abfd
= s
->input_statement
.the_bfd
) != NULL
3538 && ((bfd_get_format (abfd
) == bfd_archive
3539 && !s
->input_statement
.flags
.whole_archive
)
3540 || (bfd_get_format (abfd
) == bfd_object
3541 && ((abfd
->flags
) & DYNAMIC
) != 0
3542 && s
->input_statement
.flags
.add_DT_NEEDED_for_regular
3543 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3544 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)))
3546 s
->input_statement
.flags
.loaded
= FALSE
;
3547 s
->input_statement
.flags
.reload
= TRUE
;
3550 os_tail
= lang_os_list
.tail
;
3551 lang_list_init (&add
);
3553 if (!load_symbols (&s
->input_statement
, &add
))
3554 config
.make_executable
= FALSE
;
3556 if (add
.head
!= NULL
)
3558 /* If this was a script with output sections then
3559 tack any added statements on to the end of the
3560 list. This avoids having to reorder the output
3561 section statement list. Very likely the user
3562 forgot -T, and whatever we do here will not meet
3563 naive user expectations. */
3564 if (os_tail
!= lang_os_list
.tail
)
3566 einfo (_("%P: warning: %s contains output sections;"
3567 " did you forget -T?\n"),
3568 s
->input_statement
.filename
);
3569 *stat_ptr
->tail
= add
.head
;
3570 stat_ptr
->tail
= add
.tail
;
3574 *add
.tail
= s
->header
.next
;
3575 s
->header
.next
= add
.head
;
3579 #ifdef ENABLE_PLUGINS
3580 /* If we have found the point at which a plugin added new
3581 files, clear plugin_insert to enable archive rescan. */
3582 if (&s
->input_statement
== plugin_insert
)
3583 plugin_insert
= NULL
;
3586 case lang_assignment_statement_enum
:
3587 if (s
->assignment_statement
.exp
->type
.node_class
!= etree_assert
)
3588 exp_fold_tree_no_dot (s
->assignment_statement
.exp
);
3595 /* Exit if any of the files were missing. */
3596 if (input_flags
.missing_file
)
3600 /* Add the supplied name to the symbol table as an undefined reference.
3601 This is a two step process as the symbol table doesn't even exist at
3602 the time the ld command line is processed. First we put the name
3603 on a list, then, once the output file has been opened, transfer the
3604 name to the symbol table. */
3606 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3608 #define ldlang_undef_chain_list_head entry_symbol.next
3611 ldlang_add_undef (const char *const name
, bfd_boolean cmdline
)
3613 ldlang_undef_chain_list_type
*new_undef
;
3615 undef_from_cmdline
= undef_from_cmdline
|| cmdline
;
3616 new_undef
= stat_alloc (sizeof (*new_undef
));
3617 new_undef
->next
= ldlang_undef_chain_list_head
;
3618 ldlang_undef_chain_list_head
= new_undef
;
3620 new_undef
->name
= xstrdup (name
);
3622 if (link_info
.output_bfd
!= NULL
)
3623 insert_undefined (new_undef
->name
);
3626 /* Insert NAME as undefined in the symbol table. */
3629 insert_undefined (const char *name
)
3631 struct bfd_link_hash_entry
*h
;
3633 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
3635 einfo (_("%F%P: bfd_link_hash_lookup failed: %E\n"));
3636 if (h
->type
== bfd_link_hash_new
)
3638 h
->type
= bfd_link_hash_undefined
;
3639 h
->u
.undef
.abfd
= NULL
;
3640 h
->non_ir_ref_regular
= TRUE
;
3641 if (is_elf_hash_table (link_info
.hash
))
3642 ((struct elf_link_hash_entry
*) h
)->mark
= 1;
3643 bfd_link_add_undef (link_info
.hash
, h
);
3647 /* Run through the list of undefineds created above and place them
3648 into the linker hash table as undefined symbols belonging to the
3652 lang_place_undefineds (void)
3654 ldlang_undef_chain_list_type
*ptr
;
3656 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3657 insert_undefined (ptr
->name
);
3660 /* Structure used to build the list of symbols that the user has required
3663 struct require_defined_symbol
3666 struct require_defined_symbol
*next
;
3669 /* The list of symbols that the user has required be defined. */
3671 static struct require_defined_symbol
*require_defined_symbol_list
;
3673 /* Add a new symbol NAME to the list of symbols that are required to be
3677 ldlang_add_require_defined (const char *const name
)
3679 struct require_defined_symbol
*ptr
;
3681 ldlang_add_undef (name
, TRUE
);
3682 ptr
= stat_alloc (sizeof (*ptr
));
3683 ptr
->next
= require_defined_symbol_list
;
3684 ptr
->name
= strdup (name
);
3685 require_defined_symbol_list
= ptr
;
3688 /* Check that all symbols the user required to be defined, are defined,
3689 raise an error if we find a symbol that is not defined. */
3692 ldlang_check_require_defined_symbols (void)
3694 struct require_defined_symbol
*ptr
;
3696 for (ptr
= require_defined_symbol_list
; ptr
!= NULL
; ptr
= ptr
->next
)
3698 struct bfd_link_hash_entry
*h
;
3700 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
,
3701 FALSE
, FALSE
, TRUE
);
3703 || (h
->type
!= bfd_link_hash_defined
3704 && h
->type
!= bfd_link_hash_defweak
))
3705 einfo(_("%X%P: required symbol `%s' not defined\n"), ptr
->name
);
3709 /* Check for all readonly or some readwrite sections. */
3712 check_input_sections
3713 (lang_statement_union_type
*s
,
3714 lang_output_section_statement_type
*output_section_statement
)
3716 for (; s
!= NULL
; s
= s
->header
.next
)
3718 switch (s
->header
.type
)
3720 case lang_wild_statement_enum
:
3721 walk_wild (&s
->wild_statement
, check_section_callback
,
3722 output_section_statement
);
3723 if (!output_section_statement
->all_input_readonly
)
3726 case lang_constructors_statement_enum
:
3727 check_input_sections (constructor_list
.head
,
3728 output_section_statement
);
3729 if (!output_section_statement
->all_input_readonly
)
3732 case lang_group_statement_enum
:
3733 check_input_sections (s
->group_statement
.children
.head
,
3734 output_section_statement
);
3735 if (!output_section_statement
->all_input_readonly
)
3744 /* Update wildcard statements if needed. */
3747 update_wild_statements (lang_statement_union_type
*s
)
3749 struct wildcard_list
*sec
;
3751 switch (sort_section
)
3761 for (; s
!= NULL
; s
= s
->header
.next
)
3763 switch (s
->header
.type
)
3768 case lang_wild_statement_enum
:
3769 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
3771 /* Don't sort .init/.fini sections. */
3772 if (strcmp (sec
->spec
.name
, ".init") != 0
3773 && strcmp (sec
->spec
.name
, ".fini") != 0)
3774 switch (sec
->spec
.sorted
)
3777 sec
->spec
.sorted
= sort_section
;
3780 if (sort_section
== by_alignment
)
3781 sec
->spec
.sorted
= by_name_alignment
;
3784 if (sort_section
== by_name
)
3785 sec
->spec
.sorted
= by_alignment_name
;
3792 case lang_constructors_statement_enum
:
3793 update_wild_statements (constructor_list
.head
);
3796 case lang_output_section_statement_enum
:
3797 update_wild_statements
3798 (s
->output_section_statement
.children
.head
);
3801 case lang_group_statement_enum
:
3802 update_wild_statements (s
->group_statement
.children
.head
);
3810 /* Open input files and attach to output sections. */
3813 map_input_to_output_sections
3814 (lang_statement_union_type
*s
, const char *target
,
3815 lang_output_section_statement_type
*os
)
3817 for (; s
!= NULL
; s
= s
->header
.next
)
3819 lang_output_section_statement_type
*tos
;
3822 switch (s
->header
.type
)
3824 case lang_wild_statement_enum
:
3825 wild (&s
->wild_statement
, target
, os
);
3827 case lang_constructors_statement_enum
:
3828 map_input_to_output_sections (constructor_list
.head
,
3832 case lang_output_section_statement_enum
:
3833 tos
= &s
->output_section_statement
;
3834 if (tos
->constraint
!= 0)
3836 if (tos
->constraint
!= ONLY_IF_RW
3837 && tos
->constraint
!= ONLY_IF_RO
)
3839 tos
->all_input_readonly
= TRUE
;
3840 check_input_sections (tos
->children
.head
, tos
);
3841 if (tos
->all_input_readonly
!= (tos
->constraint
== ONLY_IF_RO
))
3843 tos
->constraint
= -1;
3847 map_input_to_output_sections (tos
->children
.head
,
3851 case lang_output_statement_enum
:
3853 case lang_target_statement_enum
:
3854 target
= s
->target_statement
.target
;
3856 case lang_group_statement_enum
:
3857 map_input_to_output_sections (s
->group_statement
.children
.head
,
3861 case lang_data_statement_enum
:
3862 /* Make sure that any sections mentioned in the expression
3864 exp_init_os (s
->data_statement
.exp
);
3865 /* The output section gets CONTENTS, ALLOC and LOAD, but
3866 these may be overridden by the script. */
3867 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
;
3868 switch (os
->sectype
)
3870 case normal_section
:
3871 case overlay_section
:
3872 case first_overlay_section
:
3874 case noalloc_section
:
3875 flags
= SEC_HAS_CONTENTS
;
3877 case noload_section
:
3878 if (bfd_get_flavour (link_info
.output_bfd
)
3879 == bfd_target_elf_flavour
)
3880 flags
= SEC_NEVER_LOAD
| SEC_ALLOC
;
3882 flags
= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
;
3885 if (os
->bfd_section
== NULL
)
3886 init_os (os
, flags
);
3888 os
->bfd_section
->flags
|= flags
;
3890 case lang_input_section_enum
:
3892 case lang_fill_statement_enum
:
3893 case lang_object_symbols_statement_enum
:
3894 case lang_reloc_statement_enum
:
3895 case lang_padding_statement_enum
:
3896 case lang_input_statement_enum
:
3897 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3900 case lang_assignment_statement_enum
:
3901 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3904 /* Make sure that any sections mentioned in the assignment
3906 exp_init_os (s
->assignment_statement
.exp
);
3908 case lang_address_statement_enum
:
3909 /* Mark the specified section with the supplied address.
3910 If this section was actually a segment marker, then the
3911 directive is ignored if the linker script explicitly
3912 processed the segment marker. Originally, the linker
3913 treated segment directives (like -Ttext on the
3914 command-line) as section directives. We honor the
3915 section directive semantics for backwards compatibility;
3916 linker scripts that do not specifically check for
3917 SEGMENT_START automatically get the old semantics. */
3918 if (!s
->address_statement
.segment
3919 || !s
->address_statement
.segment
->used
)
3921 const char *name
= s
->address_statement
.section_name
;
3923 /* Create the output section statement here so that
3924 orphans with a set address will be placed after other
3925 script sections. If we let the orphan placement code
3926 place them in amongst other sections then the address
3927 will affect following script sections, which is
3928 likely to surprise naive users. */
3929 tos
= lang_output_section_statement_lookup (name
, 0, TRUE
);
3930 tos
->addr_tree
= s
->address_statement
.address
;
3931 if (tos
->bfd_section
== NULL
)
3935 case lang_insert_statement_enum
:
3941 /* An insert statement snips out all the linker statements from the
3942 start of the list and places them after the output section
3943 statement specified by the insert. This operation is complicated
3944 by the fact that we keep a doubly linked list of output section
3945 statements as well as the singly linked list of all statements.
3946 FIXME someday: Twiddling with the list not only moves statements
3947 from the user's script but also input and group statements that are
3948 built from command line object files and --start-group. We only
3949 get away with this because the list pointers used by file_chain
3950 and input_file_chain are not reordered, and processing via
3951 statement_list after this point mostly ignores input statements.
3952 One exception is the map file, where LOAD and START GROUP/END GROUP
3953 can end up looking odd. */
3956 process_insert_statements (lang_statement_union_type
**start
)
3958 lang_statement_union_type
**s
;
3959 lang_output_section_statement_type
*first_os
= NULL
;
3960 lang_output_section_statement_type
*last_os
= NULL
;
3961 lang_output_section_statement_type
*os
;
3966 if ((*s
)->header
.type
== lang_output_section_statement_enum
)
3968 /* Keep pointers to the first and last output section
3969 statement in the sequence we may be about to move. */
3970 os
= &(*s
)->output_section_statement
;
3972 ASSERT (last_os
== NULL
|| last_os
->next
== os
);
3975 /* Set constraint negative so that lang_output_section_find
3976 won't match this output section statement. At this
3977 stage in linking constraint has values in the range
3978 [-1, ONLY_IN_RW]. */
3979 last_os
->constraint
= -2 - last_os
->constraint
;
3980 if (first_os
== NULL
)
3983 else if ((*s
)->header
.type
== lang_group_statement_enum
)
3985 /* A user might put -T between --start-group and
3986 --end-group. One way this odd construct might arise is
3987 from a wrapper around ld to change library search
3988 behaviour. For example:
3990 exec real_ld --start-group "$@" --end-group
3991 This isn't completely unreasonable so go looking inside a
3992 group statement for insert statements. */
3993 process_insert_statements (&(*s
)->group_statement
.children
.head
);
3995 else if ((*s
)->header
.type
== lang_insert_statement_enum
)
3997 lang_insert_statement_type
*i
= &(*s
)->insert_statement
;
3998 lang_output_section_statement_type
*where
;
3999 lang_statement_union_type
**ptr
;
4000 lang_statement_union_type
*first
;
4002 where
= lang_output_section_find (i
->where
);
4003 if (where
!= NULL
&& i
->is_before
)
4006 where
= where
->prev
;
4007 while (where
!= NULL
&& where
->constraint
< 0);
4011 einfo (_("%F%P: %s not found for insert\n"), i
->where
);
4015 /* Deal with reordering the output section statement list. */
4016 if (last_os
!= NULL
)
4018 asection
*first_sec
, *last_sec
;
4019 struct lang_output_section_statement_struct
**next
;
4021 /* Snip out the output sections we are moving. */
4022 first_os
->prev
->next
= last_os
->next
;
4023 if (last_os
->next
== NULL
)
4025 next
= &first_os
->prev
->next
;
4026 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4029 last_os
->next
->prev
= first_os
->prev
;
4030 /* Add them in at the new position. */
4031 last_os
->next
= where
->next
;
4032 if (where
->next
== NULL
)
4034 next
= &last_os
->next
;
4035 lang_os_list
.tail
= (lang_statement_union_type
**) next
;
4038 where
->next
->prev
= last_os
;
4039 first_os
->prev
= where
;
4040 where
->next
= first_os
;
4042 /* Move the bfd sections in the same way. */
4045 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4047 os
->constraint
= -2 - os
->constraint
;
4048 if (os
->bfd_section
!= NULL
4049 && os
->bfd_section
->owner
!= NULL
)
4051 last_sec
= os
->bfd_section
;
4052 if (first_sec
== NULL
)
4053 first_sec
= last_sec
;
4058 if (last_sec
!= NULL
)
4060 asection
*sec
= where
->bfd_section
;
4062 sec
= output_prev_sec_find (where
);
4064 /* The place we want to insert must come after the
4065 sections we are moving. So if we find no
4066 section or if the section is the same as our
4067 last section, then no move is needed. */
4068 if (sec
!= NULL
&& sec
!= last_sec
)
4070 /* Trim them off. */
4071 if (first_sec
->prev
!= NULL
)
4072 first_sec
->prev
->next
= last_sec
->next
;
4074 link_info
.output_bfd
->sections
= last_sec
->next
;
4075 if (last_sec
->next
!= NULL
)
4076 last_sec
->next
->prev
= first_sec
->prev
;
4078 link_info
.output_bfd
->section_last
= first_sec
->prev
;
4080 last_sec
->next
= sec
->next
;
4081 if (sec
->next
!= NULL
)
4082 sec
->next
->prev
= last_sec
;
4084 link_info
.output_bfd
->section_last
= last_sec
;
4085 first_sec
->prev
= sec
;
4086 sec
->next
= first_sec
;
4094 ptr
= insert_os_after (where
);
4095 /* Snip everything from the start of the list, up to and
4096 including the insert statement we are currently processing. */
4098 *start
= (*s
)->header
.next
;
4099 /* Add them back where they belong, minus the insert. */
4102 statement_list
.tail
= s
;
4107 s
= &(*s
)->header
.next
;
4110 /* Undo constraint twiddling. */
4111 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
4113 os
->constraint
= -2 - os
->constraint
;
4119 /* An output section might have been removed after its statement was
4120 added. For example, ldemul_before_allocation can remove dynamic
4121 sections if they turn out to be not needed. Clean them up here. */
4124 strip_excluded_output_sections (void)
4126 lang_output_section_statement_type
*os
;
4128 /* Run lang_size_sections (if not already done). */
4129 if (expld
.phase
!= lang_mark_phase_enum
)
4131 expld
.phase
= lang_mark_phase_enum
;
4132 expld
.dataseg
.phase
= exp_seg_none
;
4133 one_lang_size_sections_pass (NULL
, FALSE
);
4134 lang_reset_memory_regions ();
4137 for (os
= &lang_os_list
.head
->output_section_statement
;
4141 asection
*output_section
;
4142 bfd_boolean exclude
;
4144 if (os
->constraint
< 0)
4147 output_section
= os
->bfd_section
;
4148 if (output_section
== NULL
)
4151 exclude
= (output_section
->rawsize
== 0
4152 && (output_section
->flags
& SEC_KEEP
) == 0
4153 && !bfd_section_removed_from_list (link_info
.output_bfd
,
4156 /* Some sections have not yet been sized, notably .gnu.version,
4157 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
4158 input sections, so don't drop output sections that have such
4159 input sections unless they are also marked SEC_EXCLUDE. */
4160 if (exclude
&& output_section
->map_head
.s
!= NULL
)
4164 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
4165 if ((s
->flags
& SEC_EXCLUDE
) == 0
4166 && ((s
->flags
& SEC_LINKER_CREATED
) != 0
4167 || link_info
.emitrelocations
))
4176 /* We don't set bfd_section to NULL since bfd_section of the
4177 removed output section statement may still be used. */
4178 if (!os
->update_dot
)
4180 output_section
->flags
|= SEC_EXCLUDE
;
4181 bfd_section_list_remove (link_info
.output_bfd
, output_section
);
4182 link_info
.output_bfd
->section_count
--;
4187 /* Called from ldwrite to clear out asection.map_head and
4188 asection.map_tail for use as link_orders in ldwrite. */
4191 lang_clear_os_map (void)
4193 lang_output_section_statement_type
*os
;
4195 if (map_head_is_link_order
)
4198 for (os
= &lang_os_list
.head
->output_section_statement
;
4202 asection
*output_section
;
4204 if (os
->constraint
< 0)
4207 output_section
= os
->bfd_section
;
4208 if (output_section
== NULL
)
4211 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
4212 output_section
->map_head
.link_order
= NULL
;
4213 output_section
->map_tail
.link_order
= NULL
;
4216 /* Stop future calls to lang_add_section from messing with map_head
4217 and map_tail link_order fields. */
4218 map_head_is_link_order
= TRUE
;
4222 print_output_section_statement
4223 (lang_output_section_statement_type
*output_section_statement
)
4225 asection
*section
= output_section_statement
->bfd_section
;
4228 if (output_section_statement
!= abs_output_section
)
4230 minfo ("\n%s", output_section_statement
->name
);
4232 if (section
!= NULL
)
4234 print_dot
= section
->vma
;
4236 len
= strlen (output_section_statement
->name
);
4237 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4242 while (len
< SECTION_NAME_MAP_LENGTH
)
4248 minfo ("0x%V %W", section
->vma
, TO_ADDR (section
->size
));
4250 if (section
->vma
!= section
->lma
)
4251 minfo (_(" load address 0x%V"), section
->lma
);
4253 if (output_section_statement
->update_dot_tree
!= NULL
)
4254 exp_fold_tree (output_section_statement
->update_dot_tree
,
4255 bfd_abs_section_ptr
, &print_dot
);
4261 print_statement_list (output_section_statement
->children
.head
,
4262 output_section_statement
);
4266 print_assignment (lang_assignment_statement_type
*assignment
,
4267 lang_output_section_statement_type
*output_section
)
4274 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4277 if (assignment
->exp
->type
.node_class
== etree_assert
)
4280 tree
= assignment
->exp
->assert_s
.child
;
4284 const char *dst
= assignment
->exp
->assign
.dst
;
4286 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
4287 tree
= assignment
->exp
;
4290 osec
= output_section
->bfd_section
;
4292 osec
= bfd_abs_section_ptr
;
4294 if (assignment
->exp
->type
.node_class
!= etree_provide
)
4295 exp_fold_tree (tree
, osec
, &print_dot
);
4297 expld
.result
.valid_p
= FALSE
;
4299 if (expld
.result
.valid_p
)
4303 if (assignment
->exp
->type
.node_class
== etree_assert
4305 || expld
.assign_name
!= NULL
)
4307 value
= expld
.result
.value
;
4309 if (expld
.result
.section
!= NULL
)
4310 value
+= expld
.result
.section
->vma
;
4312 minfo ("0x%V", value
);
4318 struct bfd_link_hash_entry
*h
;
4320 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
4321 FALSE
, FALSE
, TRUE
);
4323 && (h
->type
== bfd_link_hash_defined
4324 || h
->type
== bfd_link_hash_defweak
))
4326 value
= h
->u
.def
.value
;
4327 value
+= h
->u
.def
.section
->output_section
->vma
;
4328 value
+= h
->u
.def
.section
->output_offset
;
4330 minfo ("[0x%V]", value
);
4333 minfo ("[unresolved]");
4338 if (assignment
->exp
->type
.node_class
== etree_provide
)
4339 minfo ("[!provide]");
4346 expld
.assign_name
= NULL
;
4349 exp_print_tree (assignment
->exp
);
4354 print_input_statement (lang_input_statement_type
*statm
)
4356 if (statm
->filename
!= NULL
)
4357 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
4360 /* Print all symbols defined in a particular section. This is called
4361 via bfd_link_hash_traverse, or by print_all_symbols. */
4364 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
4366 asection
*sec
= (asection
*) ptr
;
4368 if ((hash_entry
->type
== bfd_link_hash_defined
4369 || hash_entry
->type
== bfd_link_hash_defweak
)
4370 && sec
== hash_entry
->u
.def
.section
)
4374 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4377 (hash_entry
->u
.def
.value
4378 + hash_entry
->u
.def
.section
->output_offset
4379 + hash_entry
->u
.def
.section
->output_section
->vma
));
4381 minfo (" %pT\n", hash_entry
->root
.string
);
4388 hash_entry_addr_cmp (const void *a
, const void *b
)
4390 const struct bfd_link_hash_entry
*l
= *(const struct bfd_link_hash_entry
**)a
;
4391 const struct bfd_link_hash_entry
*r
= *(const struct bfd_link_hash_entry
**)b
;
4393 if (l
->u
.def
.value
< r
->u
.def
.value
)
4395 else if (l
->u
.def
.value
> r
->u
.def
.value
)
4402 print_all_symbols (asection
*sec
)
4404 input_section_userdata_type
*ud
= bfd_section_userdata (sec
);
4405 struct map_symbol_def
*def
;
4406 struct bfd_link_hash_entry
**entries
;
4412 *ud
->map_symbol_def_tail
= 0;
4414 /* Sort the symbols by address. */
4415 entries
= (struct bfd_link_hash_entry
**)
4416 obstack_alloc (&map_obstack
,
4417 ud
->map_symbol_def_count
* sizeof (*entries
));
4419 for (i
= 0, def
= ud
->map_symbol_def_head
; def
; def
= def
->next
, i
++)
4420 entries
[i
] = def
->entry
;
4422 qsort (entries
, ud
->map_symbol_def_count
, sizeof (*entries
),
4423 hash_entry_addr_cmp
);
4425 /* Print the symbols. */
4426 for (i
= 0; i
< ud
->map_symbol_def_count
; i
++)
4427 print_one_symbol (entries
[i
], sec
);
4429 obstack_free (&map_obstack
, entries
);
4432 /* Print information about an input section to the map file. */
4435 print_input_section (asection
*i
, bfd_boolean is_discarded
)
4437 bfd_size_type size
= i
->size
;
4444 minfo ("%s", i
->name
);
4446 len
= 1 + strlen (i
->name
);
4447 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4452 while (len
< SECTION_NAME_MAP_LENGTH
)
4458 if (i
->output_section
!= NULL
4459 && i
->output_section
->owner
== link_info
.output_bfd
)
4460 addr
= i
->output_section
->vma
+ i
->output_offset
;
4468 minfo ("0x%V %W %pB\n", addr
, size
, i
->owner
);
4470 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
4472 len
= SECTION_NAME_MAP_LENGTH
+ 3;
4484 minfo (_("%W (size before relaxing)\n"), i
->rawsize
);
4487 if (i
->output_section
!= NULL
4488 && i
->output_section
->owner
== link_info
.output_bfd
)
4490 if (link_info
.reduce_memory_overheads
)
4491 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, i
);
4493 print_all_symbols (i
);
4495 /* Update print_dot, but make sure that we do not move it
4496 backwards - this could happen if we have overlays and a
4497 later overlay is shorter than an earier one. */
4498 if (addr
+ TO_ADDR (size
) > print_dot
)
4499 print_dot
= addr
+ TO_ADDR (size
);
4504 print_fill_statement (lang_fill_statement_type
*fill
)
4508 fputs (" FILL mask 0x", config
.map_file
);
4509 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
4510 fprintf (config
.map_file
, "%02x", *p
);
4511 fputs ("\n", config
.map_file
);
4515 print_data_statement (lang_data_statement_type
*data
)
4523 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4526 addr
= data
->output_offset
;
4527 if (data
->output_section
!= NULL
)
4528 addr
+= data
->output_section
->vma
;
4556 if (size
< TO_SIZE ((unsigned) 1))
4557 size
= TO_SIZE ((unsigned) 1);
4558 minfo ("0x%V %W %s 0x%v", addr
, TO_ADDR (size
), name
, data
->value
);
4560 if (data
->exp
->type
.node_class
!= etree_value
)
4563 exp_print_tree (data
->exp
);
4568 print_dot
= addr
+ TO_ADDR (size
);
4571 /* Print an address statement. These are generated by options like
4575 print_address_statement (lang_address_statement_type
*address
)
4577 minfo (_("Address of section %s set to "), address
->section_name
);
4578 exp_print_tree (address
->address
);
4582 /* Print a reloc statement. */
4585 print_reloc_statement (lang_reloc_statement_type
*reloc
)
4592 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4595 addr
= reloc
->output_offset
;
4596 if (reloc
->output_section
!= NULL
)
4597 addr
+= reloc
->output_section
->vma
;
4599 size
= bfd_get_reloc_size (reloc
->howto
);
4601 minfo ("0x%V %W RELOC %s ", addr
, TO_ADDR (size
), reloc
->howto
->name
);
4603 if (reloc
->name
!= NULL
)
4604 minfo ("%s+", reloc
->name
);
4606 minfo ("%s+", reloc
->section
->name
);
4608 exp_print_tree (reloc
->addend_exp
);
4612 print_dot
= addr
+ TO_ADDR (size
);
4616 print_padding_statement (lang_padding_statement_type
*s
)
4624 len
= sizeof " *fill*" - 1;
4625 while (len
< SECTION_NAME_MAP_LENGTH
)
4631 addr
= s
->output_offset
;
4632 if (s
->output_section
!= NULL
)
4633 addr
+= s
->output_section
->vma
;
4634 minfo ("0x%V %W ", addr
, TO_ADDR (s
->size
));
4636 if (s
->fill
->size
!= 0)
4640 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
4641 fprintf (config
.map_file
, "%02x", *p
);
4646 print_dot
= addr
+ TO_ADDR (s
->size
);
4650 print_wild_statement (lang_wild_statement_type
*w
,
4651 lang_output_section_statement_type
*os
)
4653 struct wildcard_list
*sec
;
4657 if (w
->exclude_name_list
)
4660 minfo ("EXCLUDE_FILE(%s", w
->exclude_name_list
->name
);
4661 for (tmp
= w
->exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4662 minfo (" %s", tmp
->name
);
4666 if (w
->filenames_sorted
)
4667 minfo ("SORT_BY_NAME(");
4668 if (w
->filename
!= NULL
)
4669 minfo ("%s", w
->filename
);
4672 if (w
->filenames_sorted
)
4676 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
4678 int closing_paren
= 0;
4680 switch (sec
->spec
.sorted
)
4686 minfo ("SORT_BY_NAME(");
4691 minfo ("SORT_BY_ALIGNMENT(");
4695 case by_name_alignment
:
4696 minfo ("SORT_BY_NAME(SORT_BY_ALIGNMENT(");
4700 case by_alignment_name
:
4701 minfo ("SORT_BY_ALIGNMENT(SORT_BY_NAME(");
4706 minfo ("SORT_NONE(");
4710 case by_init_priority
:
4711 minfo ("SORT_BY_INIT_PRIORITY(");
4716 if (sec
->spec
.exclude_name_list
!= NULL
)
4719 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
4720 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4721 minfo (" %s", tmp
->name
);
4724 if (sec
->spec
.name
!= NULL
)
4725 minfo ("%s", sec
->spec
.name
);
4728 for (;closing_paren
> 0; closing_paren
--)
4737 print_statement_list (w
->children
.head
, os
);
4740 /* Print a group statement. */
4743 print_group (lang_group_statement_type
*s
,
4744 lang_output_section_statement_type
*os
)
4746 fprintf (config
.map_file
, "START GROUP\n");
4747 print_statement_list (s
->children
.head
, os
);
4748 fprintf (config
.map_file
, "END GROUP\n");
4751 /* Print the list of statements in S.
4752 This can be called for any statement type. */
4755 print_statement_list (lang_statement_union_type
*s
,
4756 lang_output_section_statement_type
*os
)
4760 print_statement (s
, os
);
4765 /* Print the first statement in statement list S.
4766 This can be called for any statement type. */
4769 print_statement (lang_statement_union_type
*s
,
4770 lang_output_section_statement_type
*os
)
4772 switch (s
->header
.type
)
4775 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
4778 case lang_constructors_statement_enum
:
4779 if (constructor_list
.head
!= NULL
)
4781 if (constructors_sorted
)
4782 minfo (" SORT (CONSTRUCTORS)\n");
4784 minfo (" CONSTRUCTORS\n");
4785 print_statement_list (constructor_list
.head
, os
);
4788 case lang_wild_statement_enum
:
4789 print_wild_statement (&s
->wild_statement
, os
);
4791 case lang_address_statement_enum
:
4792 print_address_statement (&s
->address_statement
);
4794 case lang_object_symbols_statement_enum
:
4795 minfo (" CREATE_OBJECT_SYMBOLS\n");
4797 case lang_fill_statement_enum
:
4798 print_fill_statement (&s
->fill_statement
);
4800 case lang_data_statement_enum
:
4801 print_data_statement (&s
->data_statement
);
4803 case lang_reloc_statement_enum
:
4804 print_reloc_statement (&s
->reloc_statement
);
4806 case lang_input_section_enum
:
4807 print_input_section (s
->input_section
.section
, FALSE
);
4809 case lang_padding_statement_enum
:
4810 print_padding_statement (&s
->padding_statement
);
4812 case lang_output_section_statement_enum
:
4813 print_output_section_statement (&s
->output_section_statement
);
4815 case lang_assignment_statement_enum
:
4816 print_assignment (&s
->assignment_statement
, os
);
4818 case lang_target_statement_enum
:
4819 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
4821 case lang_output_statement_enum
:
4822 minfo ("OUTPUT(%s", s
->output_statement
.name
);
4823 if (output_target
!= NULL
)
4824 minfo (" %s", output_target
);
4827 case lang_input_statement_enum
:
4828 print_input_statement (&s
->input_statement
);
4830 case lang_group_statement_enum
:
4831 print_group (&s
->group_statement
, os
);
4833 case lang_insert_statement_enum
:
4834 minfo ("INSERT %s %s\n",
4835 s
->insert_statement
.is_before
? "BEFORE" : "AFTER",
4836 s
->insert_statement
.where
);
4842 print_statements (void)
4844 print_statement_list (statement_list
.head
, abs_output_section
);
4847 /* Print the first N statements in statement list S to STDERR.
4848 If N == 0, nothing is printed.
4849 If N < 0, the entire list is printed.
4850 Intended to be called from GDB. */
4853 dprint_statement (lang_statement_union_type
*s
, int n
)
4855 FILE *map_save
= config
.map_file
;
4857 config
.map_file
= stderr
;
4860 print_statement_list (s
, abs_output_section
);
4863 while (s
&& --n
>= 0)
4865 print_statement (s
, abs_output_section
);
4870 config
.map_file
= map_save
;
4874 insert_pad (lang_statement_union_type
**ptr
,
4876 bfd_size_type alignment_needed
,
4877 asection
*output_section
,
4880 static fill_type zero_fill
;
4881 lang_statement_union_type
*pad
= NULL
;
4883 if (ptr
!= &statement_list
.head
)
4884 pad
= ((lang_statement_union_type
*)
4885 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
4887 && pad
->header
.type
== lang_padding_statement_enum
4888 && pad
->padding_statement
.output_section
== output_section
)
4890 /* Use the existing pad statement. */
4892 else if ((pad
= *ptr
) != NULL
4893 && pad
->header
.type
== lang_padding_statement_enum
4894 && pad
->padding_statement
.output_section
== output_section
)
4896 /* Use the existing pad statement. */
4900 /* Make a new padding statement, linked into existing chain. */
4901 pad
= stat_alloc (sizeof (lang_padding_statement_type
));
4902 pad
->header
.next
= *ptr
;
4904 pad
->header
.type
= lang_padding_statement_enum
;
4905 pad
->padding_statement
.output_section
= output_section
;
4908 pad
->padding_statement
.fill
= fill
;
4910 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
4911 pad
->padding_statement
.size
= alignment_needed
;
4912 if (!(output_section
->flags
& SEC_FIXED_SIZE
))
4913 output_section
->size
= TO_SIZE (dot
+ TO_ADDR (alignment_needed
)
4914 - output_section
->vma
);
4917 /* Work out how much this section will move the dot point. */
4921 (lang_statement_union_type
**this_ptr
,
4922 lang_output_section_statement_type
*output_section_statement
,
4926 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
4927 asection
*i
= is
->section
;
4928 asection
*o
= output_section_statement
->bfd_section
;
4930 if (i
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
4931 i
->output_offset
= i
->vma
- o
->vma
;
4932 else if (((i
->flags
& SEC_EXCLUDE
) != 0)
4933 || output_section_statement
->ignored
)
4934 i
->output_offset
= dot
- o
->vma
;
4937 bfd_size_type alignment_needed
;
4939 /* Align this section first to the input sections requirement,
4940 then to the output section's requirement. If this alignment
4941 is greater than any seen before, then record it too. Perform
4942 the alignment by inserting a magic 'padding' statement. */
4944 if (output_section_statement
->subsection_alignment
!= NULL
)
4946 = exp_get_power (output_section_statement
->subsection_alignment
,
4947 "subsection alignment");
4949 if (o
->alignment_power
< i
->alignment_power
)
4950 o
->alignment_power
= i
->alignment_power
;
4952 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
4954 if (alignment_needed
!= 0)
4956 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
4957 dot
+= alignment_needed
;
4960 /* Remember where in the output section this input section goes. */
4961 i
->output_offset
= dot
- o
->vma
;
4963 /* Mark how big the output section must be to contain this now. */
4964 dot
+= TO_ADDR (i
->size
);
4965 if (!(o
->flags
& SEC_FIXED_SIZE
))
4966 o
->size
= TO_SIZE (dot
- o
->vma
);
4979 sort_sections_by_lma (const void *arg1
, const void *arg2
)
4981 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
4982 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
4984 if (sec1
->lma
< sec2
->lma
)
4986 else if (sec1
->lma
> sec2
->lma
)
4988 else if (sec1
->id
< sec2
->id
)
4990 else if (sec1
->id
> sec2
->id
)
4997 sort_sections_by_vma (const void *arg1
, const void *arg2
)
4999 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
5000 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
5002 if (sec1
->vma
< sec2
->vma
)
5004 else if (sec1
->vma
> sec2
->vma
)
5006 else if (sec1
->id
< sec2
->id
)
5008 else if (sec1
->id
> sec2
->id
)
5014 #define IS_TBSS(s) \
5015 ((s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == SEC_THREAD_LOCAL)
5017 #define IGNORE_SECTION(s) \
5018 ((s->flags & SEC_ALLOC) == 0 || IS_TBSS (s))
5020 /* Check to see if any allocated sections overlap with other allocated
5021 sections. This can happen if a linker script specifies the output
5022 section addresses of the two sections. Also check whether any memory
5023 region has overflowed. */
5026 lang_check_section_addresses (void)
5029 struct check_sec
*sections
;
5034 bfd_vma p_start
= 0;
5036 lang_memory_region_type
*m
;
5037 bfd_boolean overlays
;
5039 /* Detect address space overflow on allocated sections. */
5040 addr_mask
= ((bfd_vma
) 1 <<
5041 (bfd_arch_bits_per_address (link_info
.output_bfd
) - 1)) - 1;
5042 addr_mask
= (addr_mask
<< 1) + 1;
5043 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5044 if ((s
->flags
& SEC_ALLOC
) != 0)
5046 s_end
= (s
->vma
+ s
->size
) & addr_mask
;
5047 if (s_end
!= 0 && s_end
< (s
->vma
& addr_mask
))
5048 einfo (_("%X%P: section %s VMA wraps around address space\n"),
5052 s_end
= (s
->lma
+ s
->size
) & addr_mask
;
5053 if (s_end
!= 0 && s_end
< (s
->lma
& addr_mask
))
5054 einfo (_("%X%P: section %s LMA wraps around address space\n"),
5059 if (bfd_count_sections (link_info
.output_bfd
) <= 1)
5062 count
= bfd_count_sections (link_info
.output_bfd
);
5063 sections
= XNEWVEC (struct check_sec
, count
);
5065 /* Scan all sections in the output list. */
5067 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5069 if (IGNORE_SECTION (s
)
5073 sections
[count
].sec
= s
;
5074 sections
[count
].warned
= FALSE
;
5084 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_lma
);
5086 /* First check section LMAs. There should be no overlap of LMAs on
5087 loadable sections, even with overlays. */
5088 for (p
= NULL
, i
= 0; i
< count
; i
++)
5090 s
= sections
[i
].sec
;
5091 if ((s
->flags
& SEC_LOAD
) != 0)
5094 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5096 /* Look for an overlap. We have sorted sections by lma, so
5097 we know that s_start >= p_start. Besides the obvious
5098 case of overlap when the current section starts before
5099 the previous one ends, we also must have overlap if the
5100 previous section wraps around the address space. */
5102 && (s_start
<= p_end
5103 || p_end
< p_start
))
5105 einfo (_("%X%P: section %s LMA [%V,%V]"
5106 " overlaps section %s LMA [%V,%V]\n"),
5107 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5108 sections
[i
].warned
= TRUE
;
5116 /* If any non-zero size allocated section (excluding tbss) starts at
5117 exactly the same VMA as another such section, then we have
5118 overlays. Overlays generated by the OVERLAY keyword will have
5119 this property. It is possible to intentionally generate overlays
5120 that fail this test, but it would be unusual. */
5121 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_vma
);
5123 p_start
= sections
[0].sec
->vma
;
5124 for (i
= 1; i
< count
; i
++)
5126 s_start
= sections
[i
].sec
->vma
;
5127 if (p_start
== s_start
)
5135 /* Now check section VMAs if no overlays were detected. */
5138 for (p
= NULL
, i
= 0; i
< count
; i
++)
5140 s
= sections
[i
].sec
;
5142 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
5145 && !sections
[i
].warned
5146 && (s_start
<= p_end
5147 || p_end
< p_start
))
5148 einfo (_("%X%P: section %s VMA [%V,%V]"
5149 " overlaps section %s VMA [%V,%V]\n"),
5150 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
5159 /* If any memory region has overflowed, report by how much.
5160 We do not issue this diagnostic for regions that had sections
5161 explicitly placed outside their bounds; os_region_check's
5162 diagnostics are adequate for that case.
5164 FIXME: It is conceivable that m->current - (m->origin + m->length)
5165 might overflow a 32-bit integer. There is, alas, no way to print
5166 a bfd_vma quantity in decimal. */
5167 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
5168 if (m
->had_full_message
)
5170 unsigned long over
= m
->current
- (m
->origin
+ m
->length
);
5171 einfo (ngettext ("%X%P: region `%s' overflowed by %lu byte\n",
5172 "%X%P: region `%s' overflowed by %lu bytes\n",
5174 m
->name_list
.name
, over
);
5178 /* Make sure the new address is within the region. We explicitly permit the
5179 current address to be at the exact end of the region when the address is
5180 non-zero, in case the region is at the end of addressable memory and the
5181 calculation wraps around. */
5184 os_region_check (lang_output_section_statement_type
*os
,
5185 lang_memory_region_type
*region
,
5189 if ((region
->current
< region
->origin
5190 || (region
->current
- region
->origin
> region
->length
))
5191 && ((region
->current
!= region
->origin
+ region
->length
)
5196 einfo (_("%X%P: address 0x%v of %pB section `%s'"
5197 " is not within region `%s'\n"),
5199 os
->bfd_section
->owner
,
5200 os
->bfd_section
->name
,
5201 region
->name_list
.name
);
5203 else if (!region
->had_full_message
)
5205 region
->had_full_message
= TRUE
;
5207 einfo (_("%X%P: %pB section `%s' will not fit in region `%s'\n"),
5208 os
->bfd_section
->owner
,
5209 os
->bfd_section
->name
,
5210 region
->name_list
.name
);
5216 ldlang_check_relro_region (lang_statement_union_type
*s
,
5217 seg_align_type
*seg
)
5219 if (seg
->relro
== exp_seg_relro_start
)
5221 if (!seg
->relro_start_stat
)
5222 seg
->relro_start_stat
= s
;
5225 ASSERT (seg
->relro_start_stat
== s
);
5228 else if (seg
->relro
== exp_seg_relro_end
)
5230 if (!seg
->relro_end_stat
)
5231 seg
->relro_end_stat
= s
;
5234 ASSERT (seg
->relro_end_stat
== s
);
5239 /* Set the sizes for all the output sections. */
5242 lang_size_sections_1
5243 (lang_statement_union_type
**prev
,
5244 lang_output_section_statement_type
*output_section_statement
,
5248 bfd_boolean check_regions
)
5250 lang_statement_union_type
*s
;
5252 /* Size up the sections from their constituent parts. */
5253 for (s
= *prev
; s
!= NULL
; s
= s
->header
.next
)
5255 switch (s
->header
.type
)
5257 case lang_output_section_statement_enum
:
5259 bfd_vma newdot
, after
, dotdelta
;
5260 lang_output_section_statement_type
*os
;
5261 lang_memory_region_type
*r
;
5262 int section_alignment
= 0;
5264 os
= &s
->output_section_statement
;
5265 if (os
->constraint
== -1)
5268 /* FIXME: We shouldn't need to zero section vmas for ld -r
5269 here, in lang_insert_orphan, or in the default linker scripts.
5270 This is covering for coff backend linker bugs. See PR6945. */
5271 if (os
->addr_tree
== NULL
5272 && bfd_link_relocatable (&link_info
)
5273 && (bfd_get_flavour (link_info
.output_bfd
)
5274 == bfd_target_coff_flavour
))
5275 os
->addr_tree
= exp_intop (0);
5276 if (os
->addr_tree
!= NULL
)
5278 os
->processed_vma
= FALSE
;
5279 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
5281 if (expld
.result
.valid_p
)
5283 dot
= expld
.result
.value
;
5284 if (expld
.result
.section
!= NULL
)
5285 dot
+= expld
.result
.section
->vma
;
5287 else if (expld
.phase
!= lang_mark_phase_enum
)
5288 einfo (_("%F%P:%pS: non constant or forward reference"
5289 " address expression for section %s\n"),
5290 os
->addr_tree
, os
->name
);
5293 if (os
->bfd_section
== NULL
)
5294 /* This section was removed or never actually created. */
5297 /* If this is a COFF shared library section, use the size and
5298 address from the input section. FIXME: This is COFF
5299 specific; it would be cleaner if there were some other way
5300 to do this, but nothing simple comes to mind. */
5301 if (((bfd_get_flavour (link_info
.output_bfd
)
5302 == bfd_target_ecoff_flavour
)
5303 || (bfd_get_flavour (link_info
.output_bfd
)
5304 == bfd_target_coff_flavour
))
5305 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
5309 if (os
->children
.head
== NULL
5310 || os
->children
.head
->header
.next
!= NULL
5311 || (os
->children
.head
->header
.type
5312 != lang_input_section_enum
))
5313 einfo (_("%X%P: internal error on COFF shared library"
5314 " section %s\n"), os
->name
);
5316 input
= os
->children
.head
->input_section
.section
;
5317 bfd_set_section_vma (os
->bfd_section
,
5318 bfd_section_vma (input
));
5319 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5320 os
->bfd_section
->size
= input
->size
;
5326 if (bfd_is_abs_section (os
->bfd_section
))
5328 /* No matter what happens, an abs section starts at zero. */
5329 ASSERT (os
->bfd_section
->vma
== 0);
5333 if (os
->addr_tree
== NULL
)
5335 /* No address specified for this section, get one
5336 from the region specification. */
5337 if (os
->region
== NULL
5338 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
5339 && os
->region
->name_list
.name
[0] == '*'
5340 && strcmp (os
->region
->name_list
.name
,
5341 DEFAULT_MEMORY_REGION
) == 0))
5343 os
->region
= lang_memory_default (os
->bfd_section
);
5346 /* If a loadable section is using the default memory
5347 region, and some non default memory regions were
5348 defined, issue an error message. */
5350 && !IGNORE_SECTION (os
->bfd_section
)
5351 && !bfd_link_relocatable (&link_info
)
5353 && strcmp (os
->region
->name_list
.name
,
5354 DEFAULT_MEMORY_REGION
) == 0
5355 && lang_memory_region_list
!= NULL
5356 && (strcmp (lang_memory_region_list
->name_list
.name
,
5357 DEFAULT_MEMORY_REGION
) != 0
5358 || lang_memory_region_list
->next
!= NULL
)
5359 && expld
.phase
!= lang_mark_phase_enum
)
5361 /* By default this is an error rather than just a
5362 warning because if we allocate the section to the
5363 default memory region we can end up creating an
5364 excessively large binary, or even seg faulting when
5365 attempting to perform a negative seek. See
5366 sources.redhat.com/ml/binutils/2003-04/msg00423.html
5367 for an example of this. This behaviour can be
5368 overridden by the using the --no-check-sections
5370 if (command_line
.check_section_addresses
)
5371 einfo (_("%F%P: error: no memory region specified"
5372 " for loadable section `%s'\n"),
5373 bfd_section_name (os
->bfd_section
));
5375 einfo (_("%P: warning: no memory region specified"
5376 " for loadable section `%s'\n"),
5377 bfd_section_name (os
->bfd_section
));
5380 newdot
= os
->region
->current
;
5381 section_alignment
= os
->bfd_section
->alignment_power
;
5384 section_alignment
= exp_get_power (os
->section_alignment
,
5385 "section alignment");
5387 /* Align to what the section needs. */
5388 if (section_alignment
> 0)
5390 bfd_vma savedot
= newdot
;
5391 newdot
= align_power (newdot
, section_alignment
);
5393 dotdelta
= newdot
- savedot
;
5395 && (config
.warn_section_align
5396 || os
->addr_tree
!= NULL
)
5397 && expld
.phase
!= lang_mark_phase_enum
)
5398 einfo (ngettext ("%P: warning: changing start of "
5399 "section %s by %lu byte\n",
5400 "%P: warning: changing start of "
5401 "section %s by %lu bytes\n",
5402 (unsigned long) dotdelta
),
5403 os
->name
, (unsigned long) dotdelta
);
5406 bfd_set_section_vma (os
->bfd_section
, newdot
);
5408 os
->bfd_section
->output_offset
= 0;
5411 lang_size_sections_1 (&os
->children
.head
, os
,
5412 os
->fill
, newdot
, relax
, check_regions
);
5414 os
->processed_vma
= TRUE
;
5416 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5417 /* Except for some special linker created sections,
5418 no output section should change from zero size
5419 after strip_excluded_output_sections. A non-zero
5420 size on an ignored section indicates that some
5421 input section was not sized early enough. */
5422 ASSERT (os
->bfd_section
->size
== 0);
5425 dot
= os
->bfd_section
->vma
;
5427 /* Put the section within the requested block size, or
5428 align at the block boundary. */
5430 + TO_ADDR (os
->bfd_section
->size
)
5431 + os
->block_value
- 1)
5432 & - (bfd_vma
) os
->block_value
);
5434 if (!(os
->bfd_section
->flags
& SEC_FIXED_SIZE
))
5435 os
->bfd_section
->size
= TO_SIZE (after
5436 - os
->bfd_section
->vma
);
5439 /* Set section lma. */
5442 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
5446 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
5447 os
->bfd_section
->lma
= lma
;
5449 else if (os
->lma_region
!= NULL
)
5451 bfd_vma lma
= os
->lma_region
->current
;
5453 if (os
->align_lma_with_input
)
5457 /* When LMA_REGION is the same as REGION, align the LMA
5458 as we did for the VMA, possibly including alignment
5459 from the bfd section. If a different region, then
5460 only align according to the value in the output
5462 if (os
->lma_region
!= os
->region
)
5463 section_alignment
= exp_get_power (os
->section_alignment
,
5464 "section alignment");
5465 if (section_alignment
> 0)
5466 lma
= align_power (lma
, section_alignment
);
5468 os
->bfd_section
->lma
= lma
;
5470 else if (r
->last_os
!= NULL
5471 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5476 last
= r
->last_os
->output_section_statement
.bfd_section
;
5478 /* A backwards move of dot should be accompanied by
5479 an explicit assignment to the section LMA (ie.
5480 os->load_base set) because backwards moves can
5481 create overlapping LMAs. */
5483 && os
->bfd_section
->size
!= 0
5484 && dot
+ TO_ADDR (os
->bfd_section
->size
) <= last
->vma
)
5486 /* If dot moved backwards then leave lma equal to
5487 vma. This is the old default lma, which might
5488 just happen to work when the backwards move is
5489 sufficiently large. Nag if this changes anything,
5490 so people can fix their linker scripts. */
5492 if (last
->vma
!= last
->lma
)
5493 einfo (_("%P: warning: dot moved backwards "
5494 "before `%s'\n"), os
->name
);
5498 /* If this is an overlay, set the current lma to that
5499 at the end of the previous section. */
5500 if (os
->sectype
== overlay_section
)
5501 lma
= last
->lma
+ TO_ADDR (last
->size
);
5503 /* Otherwise, keep the same lma to vma relationship
5504 as the previous section. */
5506 lma
= dot
+ last
->lma
- last
->vma
;
5508 if (section_alignment
> 0)
5509 lma
= align_power (lma
, section_alignment
);
5510 os
->bfd_section
->lma
= lma
;
5513 os
->processed_lma
= TRUE
;
5515 /* Keep track of normal sections using the default
5516 lma region. We use this to set the lma for
5517 following sections. Overlays or other linker
5518 script assignment to lma might mean that the
5519 default lma == vma is incorrect.
5520 To avoid warnings about dot moving backwards when using
5521 -Ttext, don't start tracking sections until we find one
5522 of non-zero size or with lma set differently to vma.
5523 Do this tracking before we short-cut the loop so that we
5524 track changes for the case where the section size is zero,
5525 but the lma is set differently to the vma. This is
5526 important, if an orphan section is placed after an
5527 otherwise empty output section that has an explicit lma
5528 set, we want that lma reflected in the orphans lma. */
5529 if (((!IGNORE_SECTION (os
->bfd_section
)
5530 && (os
->bfd_section
->size
!= 0
5531 || (r
->last_os
== NULL
5532 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
5533 || (r
->last_os
!= NULL
5534 && dot
>= (r
->last_os
->output_section_statement
5535 .bfd_section
->vma
))))
5536 || os
->sectype
== first_overlay_section
)
5537 && os
->lma_region
== NULL
5538 && !bfd_link_relocatable (&link_info
))
5541 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5544 /* .tbss sections effectively have zero size. */
5545 if (!IS_TBSS (os
->bfd_section
)
5546 || bfd_link_relocatable (&link_info
))
5547 dotdelta
= TO_ADDR (os
->bfd_section
->size
);
5552 if (os
->update_dot_tree
!= 0)
5553 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5555 /* Update dot in the region ?
5556 We only do this if the section is going to be allocated,
5557 since unallocated sections do not contribute to the region's
5558 overall size in memory. */
5559 if (os
->region
!= NULL
5560 && (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)))
5562 os
->region
->current
= dot
;
5565 /* Make sure the new address is within the region. */
5566 os_region_check (os
, os
->region
, os
->addr_tree
,
5567 os
->bfd_section
->vma
);
5569 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
5570 && ((os
->bfd_section
->flags
& SEC_LOAD
)
5571 || os
->align_lma_with_input
))
5573 os
->lma_region
->current
= os
->bfd_section
->lma
+ dotdelta
;
5576 os_region_check (os
, os
->lma_region
, NULL
,
5577 os
->bfd_section
->lma
);
5583 case lang_constructors_statement_enum
:
5584 dot
= lang_size_sections_1 (&constructor_list
.head
,
5585 output_section_statement
,
5586 fill
, dot
, relax
, check_regions
);
5589 case lang_data_statement_enum
:
5591 unsigned int size
= 0;
5593 s
->data_statement
.output_offset
=
5594 dot
- output_section_statement
->bfd_section
->vma
;
5595 s
->data_statement
.output_section
=
5596 output_section_statement
->bfd_section
;
5598 /* We might refer to provided symbols in the expression, and
5599 need to mark them as needed. */
5600 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5602 switch (s
->data_statement
.type
)
5620 if (size
< TO_SIZE ((unsigned) 1))
5621 size
= TO_SIZE ((unsigned) 1);
5622 dot
+= TO_ADDR (size
);
5623 if (!(output_section_statement
->bfd_section
->flags
5625 output_section_statement
->bfd_section
->size
5626 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5631 case lang_reloc_statement_enum
:
5635 s
->reloc_statement
.output_offset
=
5636 dot
- output_section_statement
->bfd_section
->vma
;
5637 s
->reloc_statement
.output_section
=
5638 output_section_statement
->bfd_section
;
5639 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
5640 dot
+= TO_ADDR (size
);
5641 if (!(output_section_statement
->bfd_section
->flags
5643 output_section_statement
->bfd_section
->size
5644 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5648 case lang_wild_statement_enum
:
5649 dot
= lang_size_sections_1 (&s
->wild_statement
.children
.head
,
5650 output_section_statement
,
5651 fill
, dot
, relax
, check_regions
);
5654 case lang_object_symbols_statement_enum
:
5655 link_info
.create_object_symbols_section
5656 = output_section_statement
->bfd_section
;
5657 output_section_statement
->bfd_section
->flags
|= SEC_KEEP
;
5660 case lang_output_statement_enum
:
5661 case lang_target_statement_enum
:
5664 case lang_input_section_enum
:
5668 i
= s
->input_section
.section
;
5673 if (!bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
5674 einfo (_("%F%P: can't relax section: %E\n"));
5678 dot
= size_input_section (prev
, output_section_statement
,
5683 case lang_input_statement_enum
:
5686 case lang_fill_statement_enum
:
5687 s
->fill_statement
.output_section
=
5688 output_section_statement
->bfd_section
;
5690 fill
= s
->fill_statement
.fill
;
5693 case lang_assignment_statement_enum
:
5695 bfd_vma newdot
= dot
;
5696 etree_type
*tree
= s
->assignment_statement
.exp
;
5698 expld
.dataseg
.relro
= exp_seg_relro_none
;
5700 exp_fold_tree (tree
,
5701 output_section_statement
->bfd_section
,
5704 ldlang_check_relro_region (s
, &expld
.dataseg
);
5706 expld
.dataseg
.relro
= exp_seg_relro_none
;
5708 /* This symbol may be relative to this section. */
5709 if ((tree
->type
.node_class
== etree_provided
5710 || tree
->type
.node_class
== etree_assign
)
5711 && (tree
->assign
.dst
[0] != '.'
5712 || tree
->assign
.dst
[1] != '\0'))
5713 output_section_statement
->update_dot
= 1;
5715 if (!output_section_statement
->ignored
)
5717 if (output_section_statement
== abs_output_section
)
5719 /* If we don't have an output section, then just adjust
5720 the default memory address. */
5721 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
5722 FALSE
)->current
= newdot
;
5724 else if (newdot
!= dot
)
5726 /* Insert a pad after this statement. We can't
5727 put the pad before when relaxing, in case the
5728 assignment references dot. */
5729 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
5730 output_section_statement
->bfd_section
, dot
);
5732 /* Don't neuter the pad below when relaxing. */
5735 /* If dot is advanced, this implies that the section
5736 should have space allocated to it, unless the
5737 user has explicitly stated that the section
5738 should not be allocated. */
5739 if (output_section_statement
->sectype
!= noalloc_section
5740 && (output_section_statement
->sectype
!= noload_section
5741 || (bfd_get_flavour (link_info
.output_bfd
)
5742 == bfd_target_elf_flavour
)))
5743 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
5750 case lang_padding_statement_enum
:
5751 /* If this is the first time lang_size_sections is called,
5752 we won't have any padding statements. If this is the
5753 second or later passes when relaxing, we should allow
5754 padding to shrink. If padding is needed on this pass, it
5755 will be added back in. */
5756 s
->padding_statement
.size
= 0;
5758 /* Make sure output_offset is valid. If relaxation shrinks
5759 the section and this pad isn't needed, it's possible to
5760 have output_offset larger than the final size of the
5761 section. bfd_set_section_contents will complain even for
5762 a pad size of zero. */
5763 s
->padding_statement
.output_offset
5764 = dot
- output_section_statement
->bfd_section
->vma
;
5767 case lang_group_statement_enum
:
5768 dot
= lang_size_sections_1 (&s
->group_statement
.children
.head
,
5769 output_section_statement
,
5770 fill
, dot
, relax
, check_regions
);
5773 case lang_insert_statement_enum
:
5776 /* We can only get here when relaxing is turned on. */
5777 case lang_address_statement_enum
:
5784 prev
= &s
->header
.next
;
5789 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
5790 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
5791 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
5792 segments. We are allowed an opportunity to override this decision. */
5795 ldlang_override_segment_assignment (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5796 bfd
*abfd ATTRIBUTE_UNUSED
,
5797 asection
*current_section
,
5798 asection
*previous_section
,
5799 bfd_boolean new_segment
)
5801 lang_output_section_statement_type
*cur
;
5802 lang_output_section_statement_type
*prev
;
5804 /* The checks below are only necessary when the BFD library has decided
5805 that the two sections ought to be placed into the same segment. */
5809 /* Paranoia checks. */
5810 if (current_section
== NULL
|| previous_section
== NULL
)
5813 /* If this flag is set, the target never wants code and non-code
5814 sections comingled in the same segment. */
5815 if (config
.separate_code
5816 && ((current_section
->flags
^ previous_section
->flags
) & SEC_CODE
))
5819 /* Find the memory regions associated with the two sections.
5820 We call lang_output_section_find() here rather than scanning the list
5821 of output sections looking for a matching section pointer because if
5822 we have a large number of sections then a hash lookup is faster. */
5823 cur
= lang_output_section_find (current_section
->name
);
5824 prev
= lang_output_section_find (previous_section
->name
);
5826 /* More paranoia. */
5827 if (cur
== NULL
|| prev
== NULL
)
5830 /* If the regions are different then force the sections to live in
5831 different segments. See the email thread starting at the following
5832 URL for the reasons why this is necessary:
5833 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
5834 return cur
->region
!= prev
->region
;
5838 one_lang_size_sections_pass (bfd_boolean
*relax
, bfd_boolean check_regions
)
5840 lang_statement_iteration
++;
5841 lang_size_sections_1 (&statement_list
.head
, abs_output_section
,
5842 0, 0, relax
, check_regions
);
5846 lang_size_segment (seg_align_type
*seg
)
5848 /* If XXX_SEGMENT_ALIGN XXX_SEGMENT_END pair was seen, check whether
5849 a page could be saved in the data segment. */
5850 bfd_vma first
, last
;
5852 first
= -seg
->base
& (seg
->pagesize
- 1);
5853 last
= seg
->end
& (seg
->pagesize
- 1);
5855 && ((seg
->base
& ~(seg
->pagesize
- 1))
5856 != (seg
->end
& ~(seg
->pagesize
- 1)))
5857 && first
+ last
<= seg
->pagesize
)
5859 seg
->phase
= exp_seg_adjust
;
5863 seg
->phase
= exp_seg_done
;
5868 lang_size_relro_segment_1 (seg_align_type
*seg
)
5870 bfd_vma relro_end
, desired_end
;
5873 /* Compute the expected PT_GNU_RELRO/PT_LOAD segment end. */
5874 relro_end
= ((seg
->relro_end
+ seg
->pagesize
- 1)
5875 & ~(seg
->pagesize
- 1));
5877 /* Adjust by the offset arg of XXX_SEGMENT_RELRO_END. */
5878 desired_end
= relro_end
- seg
->relro_offset
;
5880 /* For sections in the relro segment.. */
5881 for (sec
= link_info
.output_bfd
->section_last
; sec
; sec
= sec
->prev
)
5882 if ((sec
->flags
& SEC_ALLOC
) != 0
5883 && sec
->vma
>= seg
->base
5884 && sec
->vma
< seg
->relro_end
- seg
->relro_offset
)
5886 /* Where do we want to put this section so that it ends as
5888 bfd_vma start
, end
, bump
;
5890 end
= start
= sec
->vma
;
5892 end
+= TO_ADDR (sec
->size
);
5893 bump
= desired_end
- end
;
5894 /* We'd like to increase START by BUMP, but we must heed
5895 alignment so the increase might be less than optimum. */
5897 start
&= ~(((bfd_vma
) 1 << sec
->alignment_power
) - 1);
5898 /* This is now the desired end for the previous section. */
5899 desired_end
= start
;
5902 seg
->phase
= exp_seg_relro_adjust
;
5903 ASSERT (desired_end
>= seg
->base
);
5904 seg
->base
= desired_end
;
5909 lang_size_relro_segment (bfd_boolean
*relax
, bfd_boolean check_regions
)
5911 bfd_boolean do_reset
= FALSE
;
5912 bfd_boolean do_data_relro
;
5913 bfd_vma data_initial_base
, data_relro_end
;
5915 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
5917 do_data_relro
= TRUE
;
5918 data_initial_base
= expld
.dataseg
.base
;
5919 data_relro_end
= lang_size_relro_segment_1 (&expld
.dataseg
);
5923 do_data_relro
= FALSE
;
5924 data_initial_base
= data_relro_end
= 0;
5929 lang_reset_memory_regions ();
5930 one_lang_size_sections_pass (relax
, check_regions
);
5932 /* Assignments to dot, or to output section address in a user
5933 script have increased padding over the original. Revert. */
5934 if (do_data_relro
&& expld
.dataseg
.relro_end
> data_relro_end
)
5936 expld
.dataseg
.base
= data_initial_base
;;
5941 if (!do_data_relro
&& lang_size_segment (&expld
.dataseg
))
5948 lang_size_sections (bfd_boolean
*relax
, bfd_boolean check_regions
)
5950 expld
.phase
= lang_allocating_phase_enum
;
5951 expld
.dataseg
.phase
= exp_seg_none
;
5953 one_lang_size_sections_pass (relax
, check_regions
);
5955 if (expld
.dataseg
.phase
!= exp_seg_end_seen
)
5956 expld
.dataseg
.phase
= exp_seg_done
;
5958 if (expld
.dataseg
.phase
== exp_seg_end_seen
)
5960 bfd_boolean do_reset
5961 = lang_size_relro_segment (relax
, check_regions
);
5965 lang_reset_memory_regions ();
5966 one_lang_size_sections_pass (relax
, check_regions
);
5969 if (link_info
.relro
&& expld
.dataseg
.relro_end
)
5971 link_info
.relro_start
= expld
.dataseg
.base
;
5972 link_info
.relro_end
= expld
.dataseg
.relro_end
;
5977 static lang_output_section_statement_type
*current_section
;
5978 static lang_assignment_statement_type
*current_assign
;
5979 static bfd_boolean prefer_next_section
;
5981 /* Worker function for lang_do_assignments. Recursiveness goes here. */
5984 lang_do_assignments_1 (lang_statement_union_type
*s
,
5985 lang_output_section_statement_type
*current_os
,
5988 bfd_boolean
*found_end
)
5990 for (; s
!= NULL
; s
= s
->header
.next
)
5992 switch (s
->header
.type
)
5994 case lang_constructors_statement_enum
:
5995 dot
= lang_do_assignments_1 (constructor_list
.head
,
5996 current_os
, fill
, dot
, found_end
);
5999 case lang_output_section_statement_enum
:
6001 lang_output_section_statement_type
*os
;
6004 os
= &(s
->output_section_statement
);
6005 os
->after_end
= *found_end
;
6006 if (os
->bfd_section
!= NULL
&& !os
->ignored
)
6008 if ((os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
6010 current_section
= os
;
6011 prefer_next_section
= FALSE
;
6013 dot
= os
->bfd_section
->vma
;
6015 newdot
= lang_do_assignments_1 (os
->children
.head
,
6016 os
, os
->fill
, dot
, found_end
);
6019 if (os
->bfd_section
!= NULL
)
6021 /* .tbss sections effectively have zero size. */
6022 if (!IS_TBSS (os
->bfd_section
)
6023 || bfd_link_relocatable (&link_info
))
6024 dot
+= TO_ADDR (os
->bfd_section
->size
);
6026 if (os
->update_dot_tree
!= NULL
)
6027 exp_fold_tree (os
->update_dot_tree
,
6028 bfd_abs_section_ptr
, &dot
);
6036 case lang_wild_statement_enum
:
6038 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
6039 current_os
, fill
, dot
, found_end
);
6042 case lang_object_symbols_statement_enum
:
6043 case lang_output_statement_enum
:
6044 case lang_target_statement_enum
:
6047 case lang_data_statement_enum
:
6048 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
6049 if (expld
.result
.valid_p
)
6051 s
->data_statement
.value
= expld
.result
.value
;
6052 if (expld
.result
.section
!= NULL
)
6053 s
->data_statement
.value
+= expld
.result
.section
->vma
;
6055 else if (expld
.phase
== lang_final_phase_enum
)
6056 einfo (_("%F%P: invalid data statement\n"));
6059 switch (s
->data_statement
.type
)
6077 if (size
< TO_SIZE ((unsigned) 1))
6078 size
= TO_SIZE ((unsigned) 1);
6079 dot
+= TO_ADDR (size
);
6083 case lang_reloc_statement_enum
:
6084 exp_fold_tree (s
->reloc_statement
.addend_exp
,
6085 bfd_abs_section_ptr
, &dot
);
6086 if (expld
.result
.valid_p
)
6087 s
->reloc_statement
.addend_value
= expld
.result
.value
;
6088 else if (expld
.phase
== lang_final_phase_enum
)
6089 einfo (_("%F%P: invalid reloc statement\n"));
6090 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
6093 case lang_input_section_enum
:
6095 asection
*in
= s
->input_section
.section
;
6097 if ((in
->flags
& SEC_EXCLUDE
) == 0)
6098 dot
+= TO_ADDR (in
->size
);
6102 case lang_input_statement_enum
:
6105 case lang_fill_statement_enum
:
6106 fill
= s
->fill_statement
.fill
;
6109 case lang_assignment_statement_enum
:
6110 current_assign
= &s
->assignment_statement
;
6111 if (current_assign
->exp
->type
.node_class
!= etree_assert
)
6113 const char *p
= current_assign
->exp
->assign
.dst
;
6115 if (current_os
== abs_output_section
&& p
[0] == '.' && p
[1] == 0)
6116 prefer_next_section
= TRUE
;
6120 if (strcmp (p
, "end") == 0)
6123 exp_fold_tree (s
->assignment_statement
.exp
,
6124 (current_os
->bfd_section
!= NULL
6125 ? current_os
->bfd_section
: bfd_und_section_ptr
),
6129 case lang_padding_statement_enum
:
6130 dot
+= TO_ADDR (s
->padding_statement
.size
);
6133 case lang_group_statement_enum
:
6134 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
6135 current_os
, fill
, dot
, found_end
);
6138 case lang_insert_statement_enum
:
6141 case lang_address_statement_enum
:
6153 lang_do_assignments (lang_phase_type phase
)
6155 bfd_boolean found_end
= FALSE
;
6157 current_section
= NULL
;
6158 prefer_next_section
= FALSE
;
6159 expld
.phase
= phase
;
6160 lang_statement_iteration
++;
6161 lang_do_assignments_1 (statement_list
.head
,
6162 abs_output_section
, NULL
, 0, &found_end
);
6165 /* For an assignment statement outside of an output section statement,
6166 choose the best of neighbouring output sections to use for values
6170 section_for_dot (void)
6174 /* Assignments belong to the previous output section, unless there
6175 has been an assignment to "dot", in which case following
6176 assignments belong to the next output section. (The assumption
6177 is that an assignment to "dot" is setting up the address for the
6178 next output section.) Except that past the assignment to "_end"
6179 we always associate with the previous section. This exception is
6180 for targets like SH that define an alloc .stack or other
6181 weirdness after non-alloc sections. */
6182 if (current_section
== NULL
|| prefer_next_section
)
6184 lang_statement_union_type
*stmt
;
6185 lang_output_section_statement_type
*os
;
6187 for (stmt
= (lang_statement_union_type
*) current_assign
;
6189 stmt
= stmt
->header
.next
)
6190 if (stmt
->header
.type
== lang_output_section_statement_enum
)
6193 os
= &stmt
->output_section_statement
;
6196 && (os
->bfd_section
== NULL
6197 || (os
->bfd_section
->flags
& SEC_EXCLUDE
) != 0
6198 || bfd_section_removed_from_list (link_info
.output_bfd
,
6202 if (current_section
== NULL
|| os
== NULL
|| !os
->after_end
)
6205 s
= os
->bfd_section
;
6207 s
= link_info
.output_bfd
->section_last
;
6209 && ((s
->flags
& SEC_ALLOC
) == 0
6210 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6215 return bfd_abs_section_ptr
;
6219 s
= current_section
->bfd_section
;
6221 /* The section may have been stripped. */
6223 && ((s
->flags
& SEC_EXCLUDE
) != 0
6224 || (s
->flags
& SEC_ALLOC
) == 0
6225 || (s
->flags
& SEC_THREAD_LOCAL
) != 0
6226 || bfd_section_removed_from_list (link_info
.output_bfd
, s
)))
6229 s
= link_info
.output_bfd
->sections
;
6231 && ((s
->flags
& SEC_ALLOC
) == 0
6232 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
6237 return bfd_abs_section_ptr
;
6240 /* Array of __start/__stop/.startof./.sizeof/ symbols. */
6242 static struct bfd_link_hash_entry
**start_stop_syms
;
6243 static size_t start_stop_count
= 0;
6244 static size_t start_stop_alloc
= 0;
6246 /* Give start/stop SYMBOL for SEC a preliminary definition, and add it
6247 to start_stop_syms. */
6250 lang_define_start_stop (const char *symbol
, asection
*sec
)
6252 struct bfd_link_hash_entry
*h
;
6254 h
= bfd_define_start_stop (link_info
.output_bfd
, &link_info
, symbol
, sec
);
6257 if (start_stop_count
== start_stop_alloc
)
6259 start_stop_alloc
= 2 * start_stop_alloc
+ 10;
6261 = xrealloc (start_stop_syms
,
6262 start_stop_alloc
* sizeof (*start_stop_syms
));
6264 start_stop_syms
[start_stop_count
++] = h
;
6268 /* Check for input sections whose names match references to
6269 __start_SECNAME or __stop_SECNAME symbols. Give the symbols
6270 preliminary definitions. */
6273 lang_init_start_stop (void)
6277 char leading_char
= bfd_get_symbol_leading_char (link_info
.output_bfd
);
6279 for (abfd
= link_info
.input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
6280 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
6283 const char *secname
= s
->name
;
6285 for (ps
= secname
; *ps
!= '\0'; ps
++)
6286 if (!ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
6290 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6292 symbol
[0] = leading_char
;
6293 sprintf (symbol
+ (leading_char
!= 0), "__start_%s", secname
);
6294 lang_define_start_stop (symbol
, s
);
6296 symbol
[1] = leading_char
;
6297 memcpy (symbol
+ 1 + (leading_char
!= 0), "__stop", 6);
6298 lang_define_start_stop (symbol
+ 1, s
);
6305 /* Iterate over start_stop_syms. */
6308 foreach_start_stop (void (*func
) (struct bfd_link_hash_entry
*))
6312 for (i
= 0; i
< start_stop_count
; ++i
)
6313 func (start_stop_syms
[i
]);
6316 /* __start and __stop symbols are only supposed to be defined by the
6317 linker for orphan sections, but we now extend that to sections that
6318 map to an output section of the same name. The symbols were
6319 defined early for --gc-sections, before we mapped input to output
6320 sections, so undo those that don't satisfy this rule. */
6323 undef_start_stop (struct bfd_link_hash_entry
*h
)
6325 if (h
->ldscript_def
)
6328 if (h
->u
.def
.section
->output_section
== NULL
6329 || h
->u
.def
.section
->output_section
->owner
!= link_info
.output_bfd
6330 || strcmp (h
->u
.def
.section
->name
,
6331 h
->u
.def
.section
->output_section
->name
) != 0)
6333 asection
*sec
= bfd_get_section_by_name (link_info
.output_bfd
,
6334 h
->u
.def
.section
->name
);
6337 /* When there are more than one input sections with the same
6338 section name, SECNAME, linker picks the first one to define
6339 __start_SECNAME and __stop_SECNAME symbols. When the first
6340 input section is removed by comdat group, we need to check
6341 if there is still an output section with section name
6344 for (i
= sec
->map_head
.s
; i
!= NULL
; i
= i
->map_head
.s
)
6345 if (strcmp (h
->u
.def
.section
->name
, i
->name
) == 0)
6347 h
->u
.def
.section
= i
;
6351 h
->type
= bfd_link_hash_undefined
;
6352 h
->u
.undef
.abfd
= NULL
;
6357 lang_undef_start_stop (void)
6359 foreach_start_stop (undef_start_stop
);
6362 /* Check for output sections whose names match references to
6363 .startof.SECNAME or .sizeof.SECNAME symbols. Give the symbols
6364 preliminary definitions. */
6367 lang_init_startof_sizeof (void)
6371 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6373 const char *secname
= s
->name
;
6374 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
6376 sprintf (symbol
, ".startof.%s", secname
);
6377 lang_define_start_stop (symbol
, s
);
6379 memcpy (symbol
+ 1, ".size", 5);
6380 lang_define_start_stop (symbol
+ 1, s
);
6385 /* Set .startof., .sizeof., __start and __stop symbols final values. */
6388 set_start_stop (struct bfd_link_hash_entry
*h
)
6391 || h
->type
!= bfd_link_hash_defined
)
6394 if (h
->root
.string
[0] == '.')
6396 /* .startof. or .sizeof. symbol.
6397 .startof. already has final value. */
6398 if (h
->root
.string
[2] == 'i')
6401 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6402 h
->u
.def
.section
= bfd_abs_section_ptr
;
6407 /* __start or __stop symbol. */
6408 int has_lead
= bfd_get_symbol_leading_char (link_info
.output_bfd
) != 0;
6410 h
->u
.def
.section
= h
->u
.def
.section
->output_section
;
6411 if (h
->root
.string
[4 + has_lead
] == 'o')
6414 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6420 lang_finalize_start_stop (void)
6422 foreach_start_stop (set_start_stop
);
6428 struct bfd_link_hash_entry
*h
;
6431 if ((bfd_link_relocatable (&link_info
) && !link_info
.gc_sections
)
6432 || bfd_link_dll (&link_info
))
6433 warn
= entry_from_cmdline
;
6437 /* Force the user to specify a root when generating a relocatable with
6438 --gc-sections, unless --gc-keep-exported was also given. */
6439 if (bfd_link_relocatable (&link_info
)
6440 && link_info
.gc_sections
6441 && !link_info
.gc_keep_exported
6442 && !(entry_from_cmdline
|| undef_from_cmdline
))
6443 einfo (_("%F%P: gc-sections requires either an entry or "
6444 "an undefined symbol\n"));
6446 if (entry_symbol
.name
== NULL
)
6448 /* No entry has been specified. Look for the default entry, but
6449 don't warn if we don't find it. */
6450 entry_symbol
.name
= entry_symbol_default
;
6454 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
6455 FALSE
, FALSE
, TRUE
);
6457 && (h
->type
== bfd_link_hash_defined
6458 || h
->type
== bfd_link_hash_defweak
)
6459 && h
->u
.def
.section
->output_section
!= NULL
)
6463 val
= (h
->u
.def
.value
6464 + bfd_section_vma (h
->u
.def
.section
->output_section
)
6465 + h
->u
.def
.section
->output_offset
);
6466 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6467 einfo (_("%F%P: %s: can't set start address\n"), entry_symbol
.name
);
6474 /* We couldn't find the entry symbol. Try parsing it as a
6476 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
6479 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6480 einfo (_("%F%P: can't set start address\n"));
6486 /* Can't find the entry symbol, and it's not a number. Use
6487 the first address in the text section. */
6488 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
6492 einfo (_("%P: warning: cannot find entry symbol %s;"
6493 " defaulting to %V\n"),
6495 bfd_section_vma (ts
));
6496 if (!bfd_set_start_address (link_info
.output_bfd
,
6497 bfd_section_vma (ts
)))
6498 einfo (_("%F%P: can't set start address\n"));
6503 einfo (_("%P: warning: cannot find entry symbol %s;"
6504 " not setting start address\n"),
6511 /* This is a small function used when we want to ignore errors from
6515 ignore_bfd_errors (const char *fmt ATTRIBUTE_UNUSED
,
6516 va_list ap ATTRIBUTE_UNUSED
)
6518 /* Don't do anything. */
6521 /* Check that the architecture of all the input files is compatible
6522 with the output file. Also call the backend to let it do any
6523 other checking that is needed. */
6528 lang_input_statement_type
*file
;
6530 const bfd_arch_info_type
*compatible
;
6532 for (file
= &file_chain
.head
->input_statement
;
6536 #ifdef ENABLE_PLUGINS
6537 /* Don't check format of files claimed by plugin. */
6538 if (file
->flags
.claimed
)
6540 #endif /* ENABLE_PLUGINS */
6541 input_bfd
= file
->the_bfd
;
6543 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
6544 command_line
.accept_unknown_input_arch
);
6546 /* In general it is not possible to perform a relocatable
6547 link between differing object formats when the input
6548 file has relocations, because the relocations in the
6549 input format may not have equivalent representations in
6550 the output format (and besides BFD does not translate
6551 relocs for other link purposes than a final link). */
6552 if ((bfd_link_relocatable (&link_info
)
6553 || link_info
.emitrelocations
)
6554 && (compatible
== NULL
6555 || (bfd_get_flavour (input_bfd
)
6556 != bfd_get_flavour (link_info
.output_bfd
)))
6557 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
6559 einfo (_("%F%P: relocatable linking with relocations from"
6560 " format %s (%pB) to format %s (%pB) is not supported\n"),
6561 bfd_get_target (input_bfd
), input_bfd
,
6562 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
6563 /* einfo with %F exits. */
6566 if (compatible
== NULL
)
6568 if (command_line
.warn_mismatch
)
6569 einfo (_("%X%P: %s architecture of input file `%pB'"
6570 " is incompatible with %s output\n"),
6571 bfd_printable_name (input_bfd
), input_bfd
,
6572 bfd_printable_name (link_info
.output_bfd
));
6574 else if (bfd_count_sections (input_bfd
))
6576 /* If the input bfd has no contents, it shouldn't set the
6577 private data of the output bfd. */
6579 bfd_error_handler_type pfn
= NULL
;
6581 /* If we aren't supposed to warn about mismatched input
6582 files, temporarily set the BFD error handler to a
6583 function which will do nothing. We still want to call
6584 bfd_merge_private_bfd_data, since it may set up
6585 information which is needed in the output file. */
6586 if (!command_line
.warn_mismatch
)
6587 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
6588 if (!bfd_merge_private_bfd_data (input_bfd
, &link_info
))
6590 if (command_line
.warn_mismatch
)
6591 einfo (_("%X%P: failed to merge target specific data"
6592 " of file %pB\n"), input_bfd
);
6594 if (!command_line
.warn_mismatch
)
6595 bfd_set_error_handler (pfn
);
6600 /* Look through all the global common symbols and attach them to the
6601 correct section. The -sort-common command line switch may be used
6602 to roughly sort the entries by alignment. */
6607 if (link_info
.inhibit_common_definition
)
6609 if (bfd_link_relocatable (&link_info
)
6610 && !command_line
.force_common_definition
)
6613 if (!config
.sort_common
)
6614 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
6619 if (config
.sort_common
== sort_descending
)
6621 for (power
= 4; power
> 0; power
--)
6622 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6625 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6629 for (power
= 0; power
<= 4; power
++)
6630 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6632 power
= (unsigned int) -1;
6633 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6638 /* Place one common symbol in the correct section. */
6641 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
6643 unsigned int power_of_two
;
6647 if (h
->type
!= bfd_link_hash_common
)
6651 power_of_two
= h
->u
.c
.p
->alignment_power
;
6653 if (config
.sort_common
== sort_descending
6654 && power_of_two
< *(unsigned int *) info
)
6656 else if (config
.sort_common
== sort_ascending
6657 && power_of_two
> *(unsigned int *) info
)
6660 section
= h
->u
.c
.p
->section
;
6661 if (!bfd_define_common_symbol (link_info
.output_bfd
, &link_info
, h
))
6662 einfo (_("%F%P: could not define common symbol `%pT': %E\n"),
6665 if (config
.map_file
!= NULL
)
6667 static bfd_boolean header_printed
;
6672 if (!header_printed
)
6674 minfo (_("\nAllocating common symbols\n"));
6675 minfo (_("Common symbol size file\n\n"));
6676 header_printed
= TRUE
;
6679 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
6680 DMGL_ANSI
| DMGL_PARAMS
);
6683 minfo ("%s", h
->root
.string
);
6684 len
= strlen (h
->root
.string
);
6689 len
= strlen (name
);
6705 if (size
<= 0xffffffff)
6706 sprintf (buf
, "%lx", (unsigned long) size
);
6708 sprintf_vma (buf
, size
);
6718 minfo ("%pB\n", section
->owner
);
6724 /* Handle a single orphan section S, placing the orphan into an appropriate
6725 output section. The effects of the --orphan-handling command line
6726 option are handled here. */
6729 ldlang_place_orphan (asection
*s
)
6731 if (config
.orphan_handling
== orphan_handling_discard
)
6733 lang_output_section_statement_type
*os
;
6734 os
= lang_output_section_statement_lookup (DISCARD_SECTION_NAME
, 0,
6736 if (os
->addr_tree
== NULL
6737 && (bfd_link_relocatable (&link_info
)
6738 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6739 os
->addr_tree
= exp_intop (0);
6740 lang_add_section (&os
->children
, s
, NULL
, os
);
6744 lang_output_section_statement_type
*os
;
6745 const char *name
= s
->name
;
6748 if (config
.orphan_handling
== orphan_handling_error
)
6749 einfo (_("%X%P: error: unplaced orphan section `%pA' from `%pB'\n"),
6752 if (config
.unique_orphan_sections
|| unique_section_p (s
, NULL
))
6753 constraint
= SPECIAL
;
6755 os
= ldemul_place_orphan (s
, name
, constraint
);
6758 os
= lang_output_section_statement_lookup (name
, constraint
, TRUE
);
6759 if (os
->addr_tree
== NULL
6760 && (bfd_link_relocatable (&link_info
)
6761 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6762 os
->addr_tree
= exp_intop (0);
6763 lang_add_section (&os
->children
, s
, NULL
, os
);
6766 if (config
.orphan_handling
== orphan_handling_warn
)
6767 einfo (_("%P: warning: orphan section `%pA' from `%pB' being "
6768 "placed in section `%s'\n"),
6769 s
, s
->owner
, os
->name
);
6773 /* Run through the input files and ensure that every input section has
6774 somewhere to go. If one is found without a destination then create
6775 an input request and place it into the statement tree. */
6778 lang_place_orphans (void)
6780 LANG_FOR_EACH_INPUT_STATEMENT (file
)
6784 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6786 if (s
->output_section
== NULL
)
6788 /* This section of the file is not attached, root
6789 around for a sensible place for it to go. */
6791 if (file
->flags
.just_syms
)
6792 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
6793 else if (lang_discard_section_p (s
))
6794 s
->output_section
= bfd_abs_section_ptr
;
6795 else if (strcmp (s
->name
, "COMMON") == 0)
6797 /* This is a lonely common section which must have
6798 come from an archive. We attach to the section
6799 with the wildcard. */
6800 if (!bfd_link_relocatable (&link_info
)
6801 || command_line
.force_common_definition
)
6803 if (default_common_section
== NULL
)
6804 default_common_section
6805 = lang_output_section_statement_lookup (".bss", 0,
6807 lang_add_section (&default_common_section
->children
, s
,
6808 NULL
, default_common_section
);
6812 ldlang_place_orphan (s
);
6819 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
6821 flagword
*ptr_flags
;
6823 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
6829 /* PR 17900: An exclamation mark in the attributes reverses
6830 the sense of any of the attributes that follow. */
6833 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
6837 *ptr_flags
|= SEC_ALLOC
;
6841 *ptr_flags
|= SEC_READONLY
;
6845 *ptr_flags
|= SEC_DATA
;
6849 *ptr_flags
|= SEC_CODE
;
6854 *ptr_flags
|= SEC_LOAD
;
6858 einfo (_("%F%P: invalid character %c (%d) in flags\n"),
6866 /* Call a function on each real input file. This function will be
6867 called on an archive, but not on the elements. */
6870 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
6872 lang_input_statement_type
*f
;
6874 for (f
= &input_file_chain
.head
->input_statement
;
6876 f
= f
->next_real_file
)
6881 /* Call a function on each real file. The function will be called on
6882 all the elements of an archive which are included in the link, but
6883 will not be called on the archive file itself. */
6886 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
6888 LANG_FOR_EACH_INPUT_STATEMENT (f
)
6896 ldlang_add_file (lang_input_statement_type
*entry
)
6898 lang_statement_append (&file_chain
, entry
, &entry
->next
);
6900 /* The BFD linker needs to have a list of all input BFDs involved in
6902 ASSERT (entry
->the_bfd
->link
.next
== NULL
);
6903 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
6905 *link_info
.input_bfds_tail
= entry
->the_bfd
;
6906 link_info
.input_bfds_tail
= &entry
->the_bfd
->link
.next
;
6907 bfd_set_usrdata (entry
->the_bfd
, entry
);
6908 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
6910 /* Look through the sections and check for any which should not be
6911 included in the link. We need to do this now, so that we can
6912 notice when the backend linker tries to report multiple
6913 definition errors for symbols which are in sections we aren't
6914 going to link. FIXME: It might be better to entirely ignore
6915 symbols which are defined in sections which are going to be
6916 discarded. This would require modifying the backend linker for
6917 each backend which might set the SEC_LINK_ONCE flag. If we do
6918 this, we should probably handle SEC_EXCLUDE in the same way. */
6920 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
6924 lang_add_output (const char *name
, int from_script
)
6926 /* Make -o on command line override OUTPUT in script. */
6927 if (!had_output_filename
|| !from_script
)
6929 output_filename
= name
;
6930 had_output_filename
= TRUE
;
6934 lang_output_section_statement_type
*
6935 lang_enter_output_section_statement (const char *output_section_statement_name
,
6936 etree_type
*address_exp
,
6937 enum section_type sectype
,
6939 etree_type
*subalign
,
6942 int align_with_input
)
6944 lang_output_section_statement_type
*os
;
6946 os
= lang_output_section_statement_lookup (output_section_statement_name
,
6948 current_section
= os
;
6950 if (os
->addr_tree
== NULL
)
6952 os
->addr_tree
= address_exp
;
6954 os
->sectype
= sectype
;
6955 if (sectype
!= noload_section
)
6956 os
->flags
= SEC_NO_FLAGS
;
6958 os
->flags
= SEC_NEVER_LOAD
;
6959 os
->block_value
= 1;
6961 /* Make next things chain into subchain of this. */
6962 push_stat_ptr (&os
->children
);
6964 os
->align_lma_with_input
= align_with_input
== ALIGN_WITH_INPUT
;
6965 if (os
->align_lma_with_input
&& align
!= NULL
)
6966 einfo (_("%F%P:%pS: error: align with input and explicit align specified\n"),
6969 os
->subsection_alignment
= subalign
;
6970 os
->section_alignment
= align
;
6972 os
->load_base
= ebase
;
6979 lang_output_statement_type
*new_stmt
;
6981 new_stmt
= new_stat (lang_output_statement
, stat_ptr
);
6982 new_stmt
->name
= output_filename
;
6985 /* Reset the current counters in the regions. */
6988 lang_reset_memory_regions (void)
6990 lang_memory_region_type
*p
= lang_memory_region_list
;
6992 lang_output_section_statement_type
*os
;
6994 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
6996 p
->current
= p
->origin
;
7000 for (os
= &lang_os_list
.head
->output_section_statement
;
7004 os
->processed_vma
= FALSE
;
7005 os
->processed_lma
= FALSE
;
7008 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
7010 /* Save the last size for possible use by bfd_relax_section. */
7011 o
->rawsize
= o
->size
;
7012 if (!(o
->flags
& SEC_FIXED_SIZE
))
7017 /* Worker for lang_gc_sections_1. */
7020 gc_section_callback (lang_wild_statement_type
*ptr
,
7021 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7023 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
7024 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7025 void *data ATTRIBUTE_UNUSED
)
7027 /* If the wild pattern was marked KEEP, the member sections
7028 should be as well. */
7029 if (ptr
->keep_sections
)
7030 section
->flags
|= SEC_KEEP
;
7033 /* Iterate over sections marking them against GC. */
7036 lang_gc_sections_1 (lang_statement_union_type
*s
)
7038 for (; s
!= NULL
; s
= s
->header
.next
)
7040 switch (s
->header
.type
)
7042 case lang_wild_statement_enum
:
7043 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
7045 case lang_constructors_statement_enum
:
7046 lang_gc_sections_1 (constructor_list
.head
);
7048 case lang_output_section_statement_enum
:
7049 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
7051 case lang_group_statement_enum
:
7052 lang_gc_sections_1 (s
->group_statement
.children
.head
);
7061 lang_gc_sections (void)
7063 /* Keep all sections so marked in the link script. */
7064 lang_gc_sections_1 (statement_list
.head
);
7066 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
7067 the special case of debug info. (See bfd/stabs.c)
7068 Twiddle the flag here, to simplify later linker code. */
7069 if (bfd_link_relocatable (&link_info
))
7071 LANG_FOR_EACH_INPUT_STATEMENT (f
)
7074 #ifdef ENABLE_PLUGINS
7075 if (f
->flags
.claimed
)
7078 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
7079 if ((sec
->flags
& SEC_DEBUGGING
) == 0)
7080 sec
->flags
&= ~SEC_EXCLUDE
;
7084 if (link_info
.gc_sections
)
7085 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
7088 /* Worker for lang_find_relro_sections_1. */
7091 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
7092 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
7094 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
7095 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
7098 /* Discarded, excluded and ignored sections effectively have zero
7100 if (section
->output_section
!= NULL
7101 && section
->output_section
->owner
== link_info
.output_bfd
7102 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
7103 && !IGNORE_SECTION (section
)
7104 && section
->size
!= 0)
7106 bfd_boolean
*has_relro_section
= (bfd_boolean
*) data
;
7107 *has_relro_section
= TRUE
;
7111 /* Iterate over sections for relro sections. */
7114 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
7115 seg_align_type
*seg
,
7116 bfd_boolean
*has_relro_section
)
7118 if (*has_relro_section
)
7121 for (; s
!= NULL
; s
= s
->header
.next
)
7123 if (s
== seg
->relro_end_stat
)
7126 switch (s
->header
.type
)
7128 case lang_wild_statement_enum
:
7129 walk_wild (&s
->wild_statement
,
7130 find_relro_section_callback
,
7133 case lang_constructors_statement_enum
:
7134 lang_find_relro_sections_1 (constructor_list
.head
,
7135 seg
, has_relro_section
);
7137 case lang_output_section_statement_enum
:
7138 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
7139 seg
, has_relro_section
);
7141 case lang_group_statement_enum
:
7142 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
7143 seg
, has_relro_section
);
7152 lang_find_relro_sections (void)
7154 bfd_boolean has_relro_section
= FALSE
;
7156 /* Check all sections in the link script. */
7158 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
7159 &expld
.dataseg
, &has_relro_section
);
7161 if (!has_relro_section
)
7162 link_info
.relro
= FALSE
;
7165 /* Relax all sections until bfd_relax_section gives up. */
7168 lang_relax_sections (bfd_boolean need_layout
)
7170 if (RELAXATION_ENABLED
)
7172 /* We may need more than one relaxation pass. */
7173 int i
= link_info
.relax_pass
;
7175 /* The backend can use it to determine the current pass. */
7176 link_info
.relax_pass
= 0;
7180 /* Keep relaxing until bfd_relax_section gives up. */
7181 bfd_boolean relax_again
;
7183 link_info
.relax_trip
= -1;
7186 link_info
.relax_trip
++;
7188 /* Note: pe-dll.c does something like this also. If you find
7189 you need to change this code, you probably need to change
7190 pe-dll.c also. DJ */
7192 /* Do all the assignments with our current guesses as to
7194 lang_do_assignments (lang_assigning_phase_enum
);
7196 /* We must do this after lang_do_assignments, because it uses
7198 lang_reset_memory_regions ();
7200 /* Perform another relax pass - this time we know where the
7201 globals are, so can make a better guess. */
7202 relax_again
= FALSE
;
7203 lang_size_sections (&relax_again
, FALSE
);
7205 while (relax_again
);
7207 link_info
.relax_pass
++;
7214 /* Final extra sizing to report errors. */
7215 lang_do_assignments (lang_assigning_phase_enum
);
7216 lang_reset_memory_regions ();
7217 lang_size_sections (NULL
, TRUE
);
7221 #ifdef ENABLE_PLUGINS
7222 /* Find the insert point for the plugin's replacement files. We
7223 place them after the first claimed real object file, or if the
7224 first claimed object is an archive member, after the last real
7225 object file immediately preceding the archive. In the event
7226 no objects have been claimed at all, we return the first dummy
7227 object file on the list as the insert point; that works, but
7228 the callee must be careful when relinking the file_chain as it
7229 is not actually on that chain, only the statement_list and the
7230 input_file list; in that case, the replacement files must be
7231 inserted at the head of the file_chain. */
7233 static lang_input_statement_type
*
7234 find_replacements_insert_point (bfd_boolean
*before
)
7236 lang_input_statement_type
*claim1
, *lastobject
;
7237 lastobject
= &input_file_chain
.head
->input_statement
;
7238 for (claim1
= &file_chain
.head
->input_statement
;
7240 claim1
= claim1
->next
)
7242 if (claim1
->flags
.claimed
)
7244 *before
= claim1
->flags
.claim_archive
;
7245 return claim1
->flags
.claim_archive
? lastobject
: claim1
;
7247 /* Update lastobject if this is a real object file. */
7248 if (claim1
->the_bfd
!= NULL
&& claim1
->the_bfd
->my_archive
== NULL
)
7249 lastobject
= claim1
;
7251 /* No files were claimed by the plugin. Choose the last object
7252 file found on the list (maybe the first, dummy entry) as the
7258 /* Find where to insert ADD, an archive element or shared library
7259 added during a rescan. */
7261 static lang_input_statement_type
**
7262 find_rescan_insertion (lang_input_statement_type
*add
)
7264 bfd
*add_bfd
= add
->the_bfd
;
7265 lang_input_statement_type
*f
;
7266 lang_input_statement_type
*last_loaded
= NULL
;
7267 lang_input_statement_type
*before
= NULL
;
7268 lang_input_statement_type
**iter
= NULL
;
7270 if (add_bfd
->my_archive
!= NULL
)
7271 add_bfd
= add_bfd
->my_archive
;
7273 /* First look through the input file chain, to find an object file
7274 before the one we've rescanned. Normal object files always
7275 appear on both the input file chain and the file chain, so this
7276 lets us get quickly to somewhere near the correct place on the
7277 file chain if it is full of archive elements. Archives don't
7278 appear on the file chain, but if an element has been extracted
7279 then their input_statement->next points at it. */
7280 for (f
= &input_file_chain
.head
->input_statement
;
7282 f
= f
->next_real_file
)
7284 if (f
->the_bfd
== add_bfd
)
7286 before
= last_loaded
;
7287 if (f
->next
!= NULL
)
7288 return &f
->next
->next
;
7290 if (f
->the_bfd
!= NULL
&& f
->next
!= NULL
)
7294 for (iter
= before
? &before
->next
: &file_chain
.head
->input_statement
.next
;
7296 iter
= &(*iter
)->next
)
7297 if (!(*iter
)->flags
.claim_archive
7298 && (*iter
)->the_bfd
->my_archive
== NULL
)
7304 /* Insert SRCLIST into DESTLIST after given element by chaining
7305 on FIELD as the next-pointer. (Counterintuitively does not need
7306 a pointer to the actual after-node itself, just its chain field.) */
7309 lang_list_insert_after (lang_statement_list_type
*destlist
,
7310 lang_statement_list_type
*srclist
,
7311 lang_statement_union_type
**field
)
7313 *(srclist
->tail
) = *field
;
7314 *field
= srclist
->head
;
7315 if (destlist
->tail
== field
)
7316 destlist
->tail
= srclist
->tail
;
7319 /* Detach new nodes added to DESTLIST since the time ORIGLIST
7320 was taken as a copy of it and leave them in ORIGLIST. */
7323 lang_list_remove_tail (lang_statement_list_type
*destlist
,
7324 lang_statement_list_type
*origlist
)
7326 union lang_statement_union
**savetail
;
7327 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
7328 ASSERT (origlist
->head
== destlist
->head
);
7329 savetail
= origlist
->tail
;
7330 origlist
->head
= *(savetail
);
7331 origlist
->tail
= destlist
->tail
;
7332 destlist
->tail
= savetail
;
7336 static lang_statement_union_type
**
7337 find_next_input_statement (lang_statement_union_type
**s
)
7339 for ( ; *s
; s
= &(*s
)->header
.next
)
7341 lang_statement_union_type
**t
;
7342 switch ((*s
)->header
.type
)
7344 case lang_input_statement_enum
:
7346 case lang_wild_statement_enum
:
7347 t
= &(*s
)->wild_statement
.children
.head
;
7349 case lang_group_statement_enum
:
7350 t
= &(*s
)->group_statement
.children
.head
;
7352 case lang_output_section_statement_enum
:
7353 t
= &(*s
)->output_section_statement
.children
.head
;
7358 t
= find_next_input_statement (t
);
7364 #endif /* ENABLE_PLUGINS */
7366 /* Add NAME to the list of garbage collection entry points. */
7369 lang_add_gc_name (const char *name
)
7371 struct bfd_sym_chain
*sym
;
7376 sym
= stat_alloc (sizeof (*sym
));
7378 sym
->next
= link_info
.gc_sym_list
;
7380 link_info
.gc_sym_list
= sym
;
7383 /* Check relocations. */
7386 lang_check_relocs (void)
7388 if (link_info
.check_relocs_after_open_input
)
7392 for (abfd
= link_info
.input_bfds
;
7393 abfd
!= (bfd
*) NULL
; abfd
= abfd
->link
.next
)
7394 if (!bfd_link_check_relocs (abfd
, &link_info
))
7396 /* No object output, fail return. */
7397 config
.make_executable
= FALSE
;
7398 /* Note: we do not abort the loop, but rather
7399 continue the scan in case there are other
7400 bad relocations to report. */
7405 /* Look through all output sections looking for places where we can
7406 propagate forward the lma region. */
7409 lang_propagate_lma_regions (void)
7411 lang_output_section_statement_type
*os
;
7413 for (os
= &lang_os_list
.head
->output_section_statement
;
7417 if (os
->prev
!= NULL
7418 && os
->lma_region
== NULL
7419 && os
->load_base
== NULL
7420 && os
->addr_tree
== NULL
7421 && os
->region
== os
->prev
->region
)
7422 os
->lma_region
= os
->prev
->lma_region
;
7429 /* Finalize dynamic list. */
7430 if (link_info
.dynamic_list
)
7431 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
7433 current_target
= default_target
;
7435 /* Open the output file. */
7436 lang_for_each_statement (ldlang_open_output
);
7439 ldemul_create_output_section_statements ();
7441 /* Add to the hash table all undefineds on the command line. */
7442 lang_place_undefineds ();
7444 if (!bfd_section_already_linked_table_init ())
7445 einfo (_("%F%P: can not create hash table: %E\n"));
7447 /* Create a bfd for each input file. */
7448 current_target
= default_target
;
7449 lang_statement_iteration
++;
7450 open_input_bfds (statement_list
.head
, OPEN_BFD_NORMAL
);
7451 /* open_input_bfds also handles assignments, so we can give values
7452 to symbolic origin/length now. */
7453 lang_do_memory_regions ();
7455 #ifdef ENABLE_PLUGINS
7456 if (link_info
.lto_plugin_active
)
7458 lang_statement_list_type added
;
7459 lang_statement_list_type files
, inputfiles
;
7461 /* Now all files are read, let the plugin(s) decide if there
7462 are any more to be added to the link before we call the
7463 emulation's after_open hook. We create a private list of
7464 input statements for this purpose, which we will eventually
7465 insert into the global statement list after the first claimed
7468 /* We need to manipulate all three chains in synchrony. */
7470 inputfiles
= input_file_chain
;
7471 if (plugin_call_all_symbols_read ())
7472 einfo (_("%F%P: %s: plugin reported error after all symbols read\n"),
7473 plugin_error_plugin ());
7474 /* Open any newly added files, updating the file chains. */
7475 plugin_undefs
= link_info
.hash
->undefs_tail
;
7476 open_input_bfds (*added
.tail
, OPEN_BFD_NORMAL
);
7477 if (plugin_undefs
== link_info
.hash
->undefs_tail
)
7478 plugin_undefs
= NULL
;
7479 /* Restore the global list pointer now they have all been added. */
7480 lang_list_remove_tail (stat_ptr
, &added
);
7481 /* And detach the fresh ends of the file lists. */
7482 lang_list_remove_tail (&file_chain
, &files
);
7483 lang_list_remove_tail (&input_file_chain
, &inputfiles
);
7484 /* Were any new files added? */
7485 if (added
.head
!= NULL
)
7487 /* If so, we will insert them into the statement list immediately
7488 after the first input file that was claimed by the plugin,
7489 unless that file was an archive in which case it is inserted
7490 immediately before. */
7492 lang_statement_union_type
**prev
;
7493 plugin_insert
= find_replacements_insert_point (&before
);
7494 /* If a plugin adds input files without having claimed any, we
7495 don't really have a good idea where to place them. Just putting
7496 them at the start or end of the list is liable to leave them
7497 outside the crtbegin...crtend range. */
7498 ASSERT (plugin_insert
!= NULL
);
7499 /* Splice the new statement list into the old one. */
7500 prev
= &plugin_insert
->header
.next
;
7503 prev
= find_next_input_statement (prev
);
7504 if (*prev
!= (void *) plugin_insert
->next_real_file
)
7506 /* We didn't find the expected input statement.
7507 Fall back to adding after plugin_insert. */
7508 prev
= &plugin_insert
->header
.next
;
7511 lang_list_insert_after (stat_ptr
, &added
, prev
);
7512 /* Likewise for the file chains. */
7513 lang_list_insert_after (&input_file_chain
, &inputfiles
,
7514 (void *) &plugin_insert
->next_real_file
);
7515 /* We must be careful when relinking file_chain; we may need to
7516 insert the new files at the head of the list if the insert
7517 point chosen is the dummy first input file. */
7518 if (plugin_insert
->filename
)
7519 lang_list_insert_after (&file_chain
, &files
,
7520 (void *) &plugin_insert
->next
);
7522 lang_list_insert_after (&file_chain
, &files
, &file_chain
.head
);
7524 /* Rescan archives in case new undefined symbols have appeared. */
7526 lang_statement_iteration
++;
7527 open_input_bfds (statement_list
.head
, OPEN_BFD_RESCAN
);
7528 lang_list_remove_tail (&file_chain
, &files
);
7529 while (files
.head
!= NULL
)
7531 lang_input_statement_type
**insert
;
7532 lang_input_statement_type
**iter
, *temp
;
7535 insert
= find_rescan_insertion (&files
.head
->input_statement
);
7536 /* All elements from an archive can be added at once. */
7537 iter
= &files
.head
->input_statement
.next
;
7538 my_arch
= files
.head
->input_statement
.the_bfd
->my_archive
;
7539 if (my_arch
!= NULL
)
7540 for (; *iter
!= NULL
; iter
= &(*iter
)->next
)
7541 if ((*iter
)->the_bfd
->my_archive
!= my_arch
)
7544 *insert
= &files
.head
->input_statement
;
7545 files
.head
= (lang_statement_union_type
*) *iter
;
7547 if (my_arch
!= NULL
)
7549 lang_input_statement_type
*parent
= bfd_usrdata (my_arch
);
7551 parent
->next
= (lang_input_statement_type
*)
7553 - offsetof (lang_input_statement_type
, next
));
7558 #endif /* ENABLE_PLUGINS */
7560 /* Make sure that nobody has tried to add a symbol to this list
7562 ASSERT (link_info
.gc_sym_list
== NULL
);
7564 link_info
.gc_sym_list
= &entry_symbol
;
7566 if (entry_symbol
.name
== NULL
)
7568 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
7570 /* entry_symbol is normally initialied by a ENTRY definition in the
7571 linker script or the -e command line option. But if neither of
7572 these have been used, the target specific backend may still have
7573 provided an entry symbol via a call to lang_default_entry().
7574 Unfortunately this value will not be processed until lang_end()
7575 is called, long after this function has finished. So detect this
7576 case here and add the target's entry symbol to the list of starting
7577 points for garbage collection resolution. */
7578 lang_add_gc_name (entry_symbol_default
);
7581 lang_add_gc_name (link_info
.init_function
);
7582 lang_add_gc_name (link_info
.fini_function
);
7584 ldemul_after_open ();
7585 if (config
.map_file
!= NULL
)
7586 lang_print_asneeded ();
7588 bfd_section_already_linked_table_free ();
7590 /* Make sure that we're not mixing architectures. We call this
7591 after all the input files have been opened, but before we do any
7592 other processing, so that any operations merge_private_bfd_data
7593 does on the output file will be known during the rest of the
7597 /* Handle .exports instead of a version script if we're told to do so. */
7598 if (command_line
.version_exports_section
)
7599 lang_do_version_exports_section ();
7601 /* Build all sets based on the information gathered from the input
7603 ldctor_build_sets ();
7605 /* Give initial values for __start and __stop symbols, so that ELF
7606 gc_sections will keep sections referenced by these symbols. Must
7607 be done before lang_do_assignments below. */
7608 if (config
.build_constructors
)
7609 lang_init_start_stop ();
7611 /* PR 13683: We must rerun the assignments prior to running garbage
7612 collection in order to make sure that all symbol aliases are resolved. */
7613 lang_do_assignments (lang_mark_phase_enum
);
7614 expld
.phase
= lang_first_phase_enum
;
7616 /* Size up the common data. */
7619 /* Remove unreferenced sections if asked to. */
7620 lang_gc_sections ();
7622 /* Check relocations. */
7623 lang_check_relocs ();
7625 ldemul_after_check_relocs ();
7627 /* Update wild statements. */
7628 update_wild_statements (statement_list
.head
);
7630 /* Run through the contours of the script and attach input sections
7631 to the correct output sections. */
7632 lang_statement_iteration
++;
7633 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
7635 /* Start at the statement immediately after the special abs_section
7636 output statement, so that it isn't reordered. */
7637 process_insert_statements (&lang_os_list
.head
->header
.next
);
7639 /* Find any sections not attached explicitly and handle them. */
7640 lang_place_orphans ();
7642 if (!bfd_link_relocatable (&link_info
))
7646 /* Merge SEC_MERGE sections. This has to be done after GC of
7647 sections, so that GCed sections are not merged, but before
7648 assigning dynamic symbols, since removing whole input sections
7650 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
7652 /* Look for a text section and set the readonly attribute in it. */
7653 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
7657 if (config
.text_read_only
)
7658 found
->flags
|= SEC_READONLY
;
7660 found
->flags
&= ~SEC_READONLY
;
7664 /* Copy forward lma regions for output sections in same lma region. */
7665 lang_propagate_lma_regions ();
7667 /* Defining __start/__stop symbols early for --gc-sections to work
7668 around a glibc build problem can result in these symbols being
7669 defined when they should not be. Fix them now. */
7670 if (config
.build_constructors
)
7671 lang_undef_start_stop ();
7673 /* Define .startof./.sizeof. symbols with preliminary values before
7674 dynamic symbols are created. */
7675 if (!bfd_link_relocatable (&link_info
))
7676 lang_init_startof_sizeof ();
7678 /* Do anything special before sizing sections. This is where ELF
7679 and other back-ends size dynamic sections. */
7680 ldemul_before_allocation ();
7682 /* We must record the program headers before we try to fix the
7683 section positions, since they will affect SIZEOF_HEADERS. */
7684 lang_record_phdrs ();
7686 /* Check relro sections. */
7687 if (link_info
.relro
&& !bfd_link_relocatable (&link_info
))
7688 lang_find_relro_sections ();
7690 /* Size up the sections. */
7691 lang_size_sections (NULL
, !RELAXATION_ENABLED
);
7693 /* See if anything special should be done now we know how big
7694 everything is. This is where relaxation is done. */
7695 ldemul_after_allocation ();
7697 /* Fix any __start, __stop, .startof. or .sizeof. symbols. */
7698 lang_finalize_start_stop ();
7700 /* Do all the assignments again, to report errors. Assignment
7701 statements are processed multiple times, updating symbols; In
7702 open_input_bfds, lang_do_assignments, and lang_size_sections.
7703 Since lang_relax_sections calls lang_do_assignments, symbols are
7704 also updated in ldemul_after_allocation. */
7705 lang_do_assignments (lang_final_phase_enum
);
7709 /* Convert absolute symbols to section relative. */
7710 ldexp_finalize_syms ();
7712 /* Make sure that the section addresses make sense. */
7713 if (command_line
.check_section_addresses
)
7714 lang_check_section_addresses ();
7716 /* Check any required symbols are known. */
7717 ldlang_check_require_defined_symbols ();
7722 /* EXPORTED TO YACC */
7725 lang_add_wild (struct wildcard_spec
*filespec
,
7726 struct wildcard_list
*section_list
,
7727 bfd_boolean keep_sections
)
7729 struct wildcard_list
*curr
, *next
;
7730 lang_wild_statement_type
*new_stmt
;
7732 /* Reverse the list as the parser puts it back to front. */
7733 for (curr
= section_list
, section_list
= NULL
;
7735 section_list
= curr
, curr
= next
)
7738 curr
->next
= section_list
;
7741 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
7743 if (strcmp (filespec
->name
, "*") == 0)
7744 filespec
->name
= NULL
;
7745 else if (!wildcardp (filespec
->name
))
7746 lang_has_input_file
= TRUE
;
7749 new_stmt
= new_stat (lang_wild_statement
, stat_ptr
);
7750 new_stmt
->filename
= NULL
;
7751 new_stmt
->filenames_sorted
= FALSE
;
7752 new_stmt
->section_flag_list
= NULL
;
7753 new_stmt
->exclude_name_list
= NULL
;
7754 if (filespec
!= NULL
)
7756 new_stmt
->filename
= filespec
->name
;
7757 new_stmt
->filenames_sorted
= filespec
->sorted
== by_name
;
7758 new_stmt
->section_flag_list
= filespec
->section_flag_list
;
7759 new_stmt
->exclude_name_list
= filespec
->exclude_name_list
;
7761 new_stmt
->section_list
= section_list
;
7762 new_stmt
->keep_sections
= keep_sections
;
7763 lang_list_init (&new_stmt
->children
);
7764 analyze_walk_wild_section_handler (new_stmt
);
7768 lang_section_start (const char *name
, etree_type
*address
,
7769 const segment_type
*segment
)
7771 lang_address_statement_type
*ad
;
7773 ad
= new_stat (lang_address_statement
, stat_ptr
);
7774 ad
->section_name
= name
;
7775 ad
->address
= address
;
7776 ad
->segment
= segment
;
7779 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
7780 because of a -e argument on the command line, or zero if this is
7781 called by ENTRY in a linker script. Command line arguments take
7785 lang_add_entry (const char *name
, bfd_boolean cmdline
)
7787 if (entry_symbol
.name
== NULL
7789 || !entry_from_cmdline
)
7791 entry_symbol
.name
= name
;
7792 entry_from_cmdline
= cmdline
;
7796 /* Set the default start symbol to NAME. .em files should use this,
7797 not lang_add_entry, to override the use of "start" if neither the
7798 linker script nor the command line specifies an entry point. NAME
7799 must be permanently allocated. */
7801 lang_default_entry (const char *name
)
7803 entry_symbol_default
= name
;
7807 lang_add_target (const char *name
)
7809 lang_target_statement_type
*new_stmt
;
7811 new_stmt
= new_stat (lang_target_statement
, stat_ptr
);
7812 new_stmt
->target
= name
;
7816 lang_add_map (const char *name
)
7823 map_option_f
= TRUE
;
7831 lang_add_fill (fill_type
*fill
)
7833 lang_fill_statement_type
*new_stmt
;
7835 new_stmt
= new_stat (lang_fill_statement
, stat_ptr
);
7836 new_stmt
->fill
= fill
;
7840 lang_add_data (int type
, union etree_union
*exp
)
7842 lang_data_statement_type
*new_stmt
;
7844 new_stmt
= new_stat (lang_data_statement
, stat_ptr
);
7845 new_stmt
->exp
= exp
;
7846 new_stmt
->type
= type
;
7849 /* Create a new reloc statement. RELOC is the BFD relocation type to
7850 generate. HOWTO is the corresponding howto structure (we could
7851 look this up, but the caller has already done so). SECTION is the
7852 section to generate a reloc against, or NAME is the name of the
7853 symbol to generate a reloc against. Exactly one of SECTION and
7854 NAME must be NULL. ADDEND is an expression for the addend. */
7857 lang_add_reloc (bfd_reloc_code_real_type reloc
,
7858 reloc_howto_type
*howto
,
7861 union etree_union
*addend
)
7863 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
7867 p
->section
= section
;
7869 p
->addend_exp
= addend
;
7871 p
->addend_value
= 0;
7872 p
->output_section
= NULL
;
7873 p
->output_offset
= 0;
7876 lang_assignment_statement_type
*
7877 lang_add_assignment (etree_type
*exp
)
7879 lang_assignment_statement_type
*new_stmt
;
7881 new_stmt
= new_stat (lang_assignment_statement
, stat_ptr
);
7882 new_stmt
->exp
= exp
;
7887 lang_add_attribute (enum statement_enum attribute
)
7889 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
7893 lang_startup (const char *name
)
7895 if (first_file
->filename
!= NULL
)
7897 einfo (_("%F%P: multiple STARTUP files\n"));
7899 first_file
->filename
= name
;
7900 first_file
->local_sym_name
= name
;
7901 first_file
->flags
.real
= TRUE
;
7905 lang_float (bfd_boolean maybe
)
7907 lang_float_flag
= maybe
;
7911 /* Work out the load- and run-time regions from a script statement, and
7912 store them in *LMA_REGION and *REGION respectively.
7914 MEMSPEC is the name of the run-time region, or the value of
7915 DEFAULT_MEMORY_REGION if the statement didn't specify one.
7916 LMA_MEMSPEC is the name of the load-time region, or null if the
7917 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
7918 had an explicit load address.
7920 It is an error to specify both a load region and a load address. */
7923 lang_get_regions (lang_memory_region_type
**region
,
7924 lang_memory_region_type
**lma_region
,
7925 const char *memspec
,
7926 const char *lma_memspec
,
7927 bfd_boolean have_lma
,
7928 bfd_boolean have_vma
)
7930 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
7932 /* If no runtime region or VMA has been specified, but the load region
7933 has been specified, then use the load region for the runtime region
7935 if (lma_memspec
!= NULL
7937 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
7938 *region
= *lma_region
;
7940 *region
= lang_memory_region_lookup (memspec
, FALSE
);
7942 if (have_lma
&& lma_memspec
!= 0)
7943 einfo (_("%X%P:%pS: section has both a load address and a load region\n"),
7948 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
7949 lang_output_section_phdr_list
*phdrs
,
7950 const char *lma_memspec
)
7952 lang_get_regions (¤t_section
->region
,
7953 ¤t_section
->lma_region
,
7954 memspec
, lma_memspec
,
7955 current_section
->load_base
!= NULL
,
7956 current_section
->addr_tree
!= NULL
);
7958 current_section
->fill
= fill
;
7959 current_section
->phdrs
= phdrs
;
7963 /* Set the output format type. -oformat overrides scripts. */
7966 lang_add_output_format (const char *format
,
7971 if (output_target
== NULL
|| !from_script
)
7973 if (command_line
.endian
== ENDIAN_BIG
7976 else if (command_line
.endian
== ENDIAN_LITTLE
7980 output_target
= format
;
7985 lang_add_insert (const char *where
, int is_before
)
7987 lang_insert_statement_type
*new_stmt
;
7989 new_stmt
= new_stat (lang_insert_statement
, stat_ptr
);
7990 new_stmt
->where
= where
;
7991 new_stmt
->is_before
= is_before
;
7992 saved_script_handle
= previous_script_handle
;
7995 /* Enter a group. This creates a new lang_group_statement, and sets
7996 stat_ptr to build new statements within the group. */
7999 lang_enter_group (void)
8001 lang_group_statement_type
*g
;
8003 g
= new_stat (lang_group_statement
, stat_ptr
);
8004 lang_list_init (&g
->children
);
8005 push_stat_ptr (&g
->children
);
8008 /* Leave a group. This just resets stat_ptr to start writing to the
8009 regular list of statements again. Note that this will not work if
8010 groups can occur inside anything else which can adjust stat_ptr,
8011 but currently they can't. */
8014 lang_leave_group (void)
8019 /* Add a new program header. This is called for each entry in a PHDRS
8020 command in a linker script. */
8023 lang_new_phdr (const char *name
,
8025 bfd_boolean filehdr
,
8030 struct lang_phdr
*n
, **pp
;
8033 n
= stat_alloc (sizeof (struct lang_phdr
));
8036 n
->type
= exp_get_vma (type
, 0, "program header type");
8037 n
->filehdr
= filehdr
;
8042 hdrs
= n
->type
== 1 && (phdrs
|| filehdr
);
8044 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
8047 && !((*pp
)->filehdr
|| (*pp
)->phdrs
))
8049 einfo (_("%X%P:%pS: PHDRS and FILEHDR are not supported"
8050 " when prior PT_LOAD headers lack them\n"), NULL
);
8057 /* Record the program header information in the output BFD. FIXME: We
8058 should not be calling an ELF specific function here. */
8061 lang_record_phdrs (void)
8065 lang_output_section_phdr_list
*last
;
8066 struct lang_phdr
*l
;
8067 lang_output_section_statement_type
*os
;
8070 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
8073 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
8080 for (os
= &lang_os_list
.head
->output_section_statement
;
8084 lang_output_section_phdr_list
*pl
;
8086 if (os
->constraint
< 0)
8094 if (os
->sectype
== noload_section
8095 || os
->bfd_section
== NULL
8096 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
8099 /* Don't add orphans to PT_INTERP header. */
8105 lang_output_section_statement_type
*tmp_os
;
8107 /* If we have not run across a section with a program
8108 header assigned to it yet, then scan forwards to find
8109 one. This prevents inconsistencies in the linker's
8110 behaviour when a script has specified just a single
8111 header and there are sections in that script which are
8112 not assigned to it, and which occur before the first
8113 use of that header. See here for more details:
8114 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
8115 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
8118 last
= tmp_os
->phdrs
;
8122 einfo (_("%F%P: no sections assigned to phdrs\n"));
8127 if (os
->bfd_section
== NULL
)
8130 for (; pl
!= NULL
; pl
= pl
->next
)
8132 if (strcmp (pl
->name
, l
->name
) == 0)
8137 secs
= (asection
**) xrealloc (secs
,
8138 alc
* sizeof (asection
*));
8140 secs
[c
] = os
->bfd_section
;
8147 if (l
->flags
== NULL
)
8150 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
8155 at
= exp_get_vma (l
->at
, 0, "phdr load address");
8157 if (!bfd_record_phdr (link_info
.output_bfd
, l
->type
,
8158 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
8159 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
8160 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
8165 /* Make sure all the phdr assignments succeeded. */
8166 for (os
= &lang_os_list
.head
->output_section_statement
;
8170 lang_output_section_phdr_list
*pl
;
8172 if (os
->constraint
< 0
8173 || os
->bfd_section
== NULL
)
8176 for (pl
= os
->phdrs
;
8179 if (!pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
8180 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
8181 os
->name
, pl
->name
);
8185 /* Record a list of sections which may not be cross referenced. */
8188 lang_add_nocrossref (lang_nocrossref_type
*l
)
8190 struct lang_nocrossrefs
*n
;
8192 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
8193 n
->next
= nocrossref_list
;
8195 n
->onlyfirst
= FALSE
;
8196 nocrossref_list
= n
;
8198 /* Set notice_all so that we get informed about all symbols. */
8199 link_info
.notice_all
= TRUE
;
8202 /* Record a section that cannot be referenced from a list of sections. */
8205 lang_add_nocrossref_to (lang_nocrossref_type
*l
)
8207 lang_add_nocrossref (l
);
8208 nocrossref_list
->onlyfirst
= TRUE
;
8211 /* Overlay handling. We handle overlays with some static variables. */
8213 /* The overlay virtual address. */
8214 static etree_type
*overlay_vma
;
8215 /* And subsection alignment. */
8216 static etree_type
*overlay_subalign
;
8218 /* An expression for the maximum section size seen so far. */
8219 static etree_type
*overlay_max
;
8221 /* A list of all the sections in this overlay. */
8223 struct overlay_list
{
8224 struct overlay_list
*next
;
8225 lang_output_section_statement_type
*os
;
8228 static struct overlay_list
*overlay_list
;
8230 /* Start handling an overlay. */
8233 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
8235 /* The grammar should prevent nested overlays from occurring. */
8236 ASSERT (overlay_vma
== NULL
8237 && overlay_subalign
== NULL
8238 && overlay_max
== NULL
);
8240 overlay_vma
= vma_expr
;
8241 overlay_subalign
= subalign
;
8244 /* Start a section in an overlay. We handle this by calling
8245 lang_enter_output_section_statement with the correct VMA.
8246 lang_leave_overlay sets up the LMA and memory regions. */
8249 lang_enter_overlay_section (const char *name
)
8251 struct overlay_list
*n
;
8254 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
8255 0, overlay_subalign
, 0, 0, 0);
8257 /* If this is the first section, then base the VMA of future
8258 sections on this one. This will work correctly even if `.' is
8259 used in the addresses. */
8260 if (overlay_list
== NULL
)
8261 overlay_vma
= exp_nameop (ADDR
, name
);
8263 /* Remember the section. */
8264 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
8265 n
->os
= current_section
;
8266 n
->next
= overlay_list
;
8269 size
= exp_nameop (SIZEOF
, name
);
8271 /* Arrange to work out the maximum section end address. */
8272 if (overlay_max
== NULL
)
8275 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
8278 /* Finish a section in an overlay. There isn't any special to do
8282 lang_leave_overlay_section (fill_type
*fill
,
8283 lang_output_section_phdr_list
*phdrs
)
8290 name
= current_section
->name
;
8292 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
8293 region and that no load-time region has been specified. It doesn't
8294 really matter what we say here, since lang_leave_overlay will
8296 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
8298 /* Define the magic symbols. */
8300 clean
= (char *) xmalloc (strlen (name
) + 1);
8302 for (s1
= name
; *s1
!= '\0'; s1
++)
8303 if (ISALNUM (*s1
) || *s1
== '_')
8307 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_start_");
8308 sprintf (buf
, "__load_start_%s", clean
);
8309 lang_add_assignment (exp_provide (buf
,
8310 exp_nameop (LOADADDR
, name
),
8313 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_stop_");
8314 sprintf (buf
, "__load_stop_%s", clean
);
8315 lang_add_assignment (exp_provide (buf
,
8317 exp_nameop (LOADADDR
, name
),
8318 exp_nameop (SIZEOF
, name
)),
8324 /* Finish an overlay. If there are any overlay wide settings, this
8325 looks through all the sections in the overlay and sets them. */
8328 lang_leave_overlay (etree_type
*lma_expr
,
8331 const char *memspec
,
8332 lang_output_section_phdr_list
*phdrs
,
8333 const char *lma_memspec
)
8335 lang_memory_region_type
*region
;
8336 lang_memory_region_type
*lma_region
;
8337 struct overlay_list
*l
;
8338 lang_nocrossref_type
*nocrossref
;
8340 lang_get_regions (®ion
, &lma_region
,
8341 memspec
, lma_memspec
,
8342 lma_expr
!= NULL
, FALSE
);
8346 /* After setting the size of the last section, set '.' to end of the
8348 if (overlay_list
!= NULL
)
8350 overlay_list
->os
->update_dot
= 1;
8351 overlay_list
->os
->update_dot_tree
8352 = exp_assign (".", exp_binop ('+', overlay_vma
, overlay_max
), FALSE
);
8358 struct overlay_list
*next
;
8360 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
8363 l
->os
->region
= region
;
8364 l
->os
->lma_region
= lma_region
;
8366 /* The first section has the load address specified in the
8367 OVERLAY statement. The rest are worked out from that.
8368 The base address is not needed (and should be null) if
8369 an LMA region was specified. */
8372 l
->os
->load_base
= lma_expr
;
8373 l
->os
->sectype
= first_overlay_section
;
8375 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
8376 l
->os
->phdrs
= phdrs
;
8380 lang_nocrossref_type
*nc
;
8382 nc
= (lang_nocrossref_type
*) xmalloc (sizeof *nc
);
8383 nc
->name
= l
->os
->name
;
8384 nc
->next
= nocrossref
;
8393 if (nocrossref
!= NULL
)
8394 lang_add_nocrossref (nocrossref
);
8397 overlay_list
= NULL
;
8399 overlay_subalign
= NULL
;
8402 /* Version handling. This is only useful for ELF. */
8404 /* If PREV is NULL, return first version pattern matching particular symbol.
8405 If PREV is non-NULL, return first version pattern matching particular
8406 symbol after PREV (previously returned by lang_vers_match). */
8408 static struct bfd_elf_version_expr
*
8409 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
8410 struct bfd_elf_version_expr
*prev
,
8414 const char *cxx_sym
= sym
;
8415 const char *java_sym
= sym
;
8416 struct bfd_elf_version_expr
*expr
= NULL
;
8417 enum demangling_styles curr_style
;
8419 curr_style
= CURRENT_DEMANGLING_STYLE
;
8420 cplus_demangle_set_style (no_demangling
);
8421 c_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_NO_OPTS
);
8424 cplus_demangle_set_style (curr_style
);
8426 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8428 cxx_sym
= bfd_demangle (link_info
.output_bfd
, sym
,
8429 DMGL_PARAMS
| DMGL_ANSI
);
8433 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8435 java_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_JAVA
);
8440 if (head
->htab
&& (prev
== NULL
|| prev
->literal
))
8442 struct bfd_elf_version_expr e
;
8444 switch (prev
? prev
->mask
: 0)
8447 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
8450 expr
= (struct bfd_elf_version_expr
*)
8451 htab_find ((htab_t
) head
->htab
, &e
);
8452 while (expr
&& strcmp (expr
->pattern
, c_sym
) == 0)
8453 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
8459 case BFD_ELF_VERSION_C_TYPE
:
8460 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
8462 e
.pattern
= cxx_sym
;
8463 expr
= (struct bfd_elf_version_expr
*)
8464 htab_find ((htab_t
) head
->htab
, &e
);
8465 while (expr
&& strcmp (expr
->pattern
, cxx_sym
) == 0)
8466 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
8472 case BFD_ELF_VERSION_CXX_TYPE
:
8473 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
8475 e
.pattern
= java_sym
;
8476 expr
= (struct bfd_elf_version_expr
*)
8477 htab_find ((htab_t
) head
->htab
, &e
);
8478 while (expr
&& strcmp (expr
->pattern
, java_sym
) == 0)
8479 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8490 /* Finally, try the wildcards. */
8491 if (prev
== NULL
|| prev
->literal
)
8492 expr
= head
->remaining
;
8495 for (; expr
; expr
= expr
->next
)
8502 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
8505 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8507 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
8511 if (fnmatch (expr
->pattern
, s
, 0) == 0)
8517 free ((char *) c_sym
);
8519 free ((char *) cxx_sym
);
8520 if (java_sym
!= sym
)
8521 free ((char *) java_sym
);
8525 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
8526 return a pointer to the symbol name with any backslash quotes removed. */
8529 realsymbol (const char *pattern
)
8532 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
8533 char *s
, *symbol
= (char *) xmalloc (strlen (pattern
) + 1);
8535 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
8537 /* It is a glob pattern only if there is no preceding
8541 /* Remove the preceding backslash. */
8548 if (*p
== '?' || *p
== '*' || *p
== '[')
8555 backslash
= *p
== '\\';
8571 /* This is called for each variable name or match expression. NEW_NAME is
8572 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
8573 pattern to be matched against symbol names. */
8575 struct bfd_elf_version_expr
*
8576 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
8577 const char *new_name
,
8579 bfd_boolean literal_p
)
8581 struct bfd_elf_version_expr
*ret
;
8583 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
8587 ret
->literal
= TRUE
;
8588 ret
->pattern
= literal_p
? new_name
: realsymbol (new_name
);
8589 if (ret
->pattern
== NULL
)
8591 ret
->pattern
= new_name
;
8592 ret
->literal
= FALSE
;
8595 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
8596 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
8597 else if (strcasecmp (lang
, "C++") == 0)
8598 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
8599 else if (strcasecmp (lang
, "Java") == 0)
8600 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
8603 einfo (_("%X%P: unknown language `%s' in version information\n"),
8605 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
8608 return ldemul_new_vers_pattern (ret
);
8611 /* This is called for each set of variable names and match
8614 struct bfd_elf_version_tree
*
8615 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
8616 struct bfd_elf_version_expr
*locals
)
8618 struct bfd_elf_version_tree
*ret
;
8620 ret
= (struct bfd_elf_version_tree
*) xcalloc (1, sizeof *ret
);
8621 ret
->globals
.list
= globals
;
8622 ret
->locals
.list
= locals
;
8623 ret
->match
= lang_vers_match
;
8624 ret
->name_indx
= (unsigned int) -1;
8628 /* This static variable keeps track of version indices. */
8630 static int version_index
;
8633 version_expr_head_hash (const void *p
)
8635 const struct bfd_elf_version_expr
*e
=
8636 (const struct bfd_elf_version_expr
*) p
;
8638 return htab_hash_string (e
->pattern
);
8642 version_expr_head_eq (const void *p1
, const void *p2
)
8644 const struct bfd_elf_version_expr
*e1
=
8645 (const struct bfd_elf_version_expr
*) p1
;
8646 const struct bfd_elf_version_expr
*e2
=
8647 (const struct bfd_elf_version_expr
*) p2
;
8649 return strcmp (e1
->pattern
, e2
->pattern
) == 0;
8653 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
8656 struct bfd_elf_version_expr
*e
, *next
;
8657 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
8659 for (e
= head
->list
; e
; e
= e
->next
)
8663 head
->mask
|= e
->mask
;
8668 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
8669 version_expr_head_eq
, NULL
);
8670 list_loc
= &head
->list
;
8671 remaining_loc
= &head
->remaining
;
8672 for (e
= head
->list
; e
; e
= next
)
8678 remaining_loc
= &e
->next
;
8682 void **loc
= htab_find_slot ((htab_t
) head
->htab
, e
, INSERT
);
8686 struct bfd_elf_version_expr
*e1
, *last
;
8688 e1
= (struct bfd_elf_version_expr
*) *loc
;
8692 if (e1
->mask
== e
->mask
)
8700 while (e1
&& strcmp (e1
->pattern
, e
->pattern
) == 0);
8704 /* This is a duplicate. */
8705 /* FIXME: Memory leak. Sometimes pattern is not
8706 xmalloced alone, but in larger chunk of memory. */
8707 /* free (e->pattern); */
8712 e
->next
= last
->next
;
8720 list_loc
= &e
->next
;
8724 *remaining_loc
= NULL
;
8725 *list_loc
= head
->remaining
;
8728 head
->remaining
= head
->list
;
8731 /* This is called when we know the name and dependencies of the
8735 lang_register_vers_node (const char *name
,
8736 struct bfd_elf_version_tree
*version
,
8737 struct bfd_elf_version_deps
*deps
)
8739 struct bfd_elf_version_tree
*t
, **pp
;
8740 struct bfd_elf_version_expr
*e1
;
8745 if (link_info
.version_info
!= NULL
8746 && (name
[0] == '\0' || link_info
.version_info
->name
[0] == '\0'))
8748 einfo (_("%X%P: anonymous version tag cannot be combined"
8749 " with other version tags\n"));
8754 /* Make sure this node has a unique name. */
8755 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8756 if (strcmp (t
->name
, name
) == 0)
8757 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
8759 lang_finalize_version_expr_head (&version
->globals
);
8760 lang_finalize_version_expr_head (&version
->locals
);
8762 /* Check the global and local match names, and make sure there
8763 aren't any duplicates. */
8765 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
8767 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8769 struct bfd_elf_version_expr
*e2
;
8771 if (t
->locals
.htab
&& e1
->literal
)
8773 e2
= (struct bfd_elf_version_expr
*)
8774 htab_find ((htab_t
) t
->locals
.htab
, e1
);
8775 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
8777 if (e1
->mask
== e2
->mask
)
8778 einfo (_("%X%P: duplicate expression `%s'"
8779 " in version information\n"), e1
->pattern
);
8783 else if (!e1
->literal
)
8784 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
8785 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
8786 && e1
->mask
== e2
->mask
)
8787 einfo (_("%X%P: duplicate expression `%s'"
8788 " in version information\n"), e1
->pattern
);
8792 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
8794 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8796 struct bfd_elf_version_expr
*e2
;
8798 if (t
->globals
.htab
&& e1
->literal
)
8800 e2
= (struct bfd_elf_version_expr
*)
8801 htab_find ((htab_t
) t
->globals
.htab
, e1
);
8802 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
8804 if (e1
->mask
== e2
->mask
)
8805 einfo (_("%X%P: duplicate expression `%s'"
8806 " in version information\n"),
8811 else if (!e1
->literal
)
8812 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
8813 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
8814 && e1
->mask
== e2
->mask
)
8815 einfo (_("%X%P: duplicate expression `%s'"
8816 " in version information\n"), e1
->pattern
);
8820 version
->deps
= deps
;
8821 version
->name
= name
;
8822 if (name
[0] != '\0')
8825 version
->vernum
= version_index
;
8828 version
->vernum
= 0;
8830 for (pp
= &link_info
.version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
8835 /* This is called when we see a version dependency. */
8837 struct bfd_elf_version_deps
*
8838 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
8840 struct bfd_elf_version_deps
*ret
;
8841 struct bfd_elf_version_tree
*t
;
8843 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
8846 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8848 if (strcmp (t
->name
, name
) == 0)
8850 ret
->version_needed
= t
;
8855 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
8857 ret
->version_needed
= NULL
;
8862 lang_do_version_exports_section (void)
8864 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
8866 LANG_FOR_EACH_INPUT_STATEMENT (is
)
8868 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
8876 contents
= (char *) xmalloc (len
);
8877 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
8878 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
8881 while (p
< contents
+ len
)
8883 greg
= lang_new_vers_pattern (greg
, p
, NULL
, FALSE
);
8884 p
= strchr (p
, '\0') + 1;
8887 /* Do not free the contents, as we used them creating the regex. */
8889 /* Do not include this section in the link. */
8890 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
8893 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, FALSE
);
8894 lang_register_vers_node (command_line
.version_exports_section
,
8895 lang_new_vers_node (greg
, lreg
), NULL
);
8898 /* Evaluate LENGTH and ORIGIN parts of MEMORY spec */
8901 lang_do_memory_regions (void)
8903 lang_memory_region_type
*r
= lang_memory_region_list
;
8905 for (; r
!= NULL
; r
= r
->next
)
8909 exp_fold_tree_no_dot (r
->origin_exp
);
8910 if (expld
.result
.valid_p
)
8912 r
->origin
= expld
.result
.value
;
8913 r
->current
= r
->origin
;
8916 einfo (_("%F%P: invalid origin for memory region %s\n"),
8921 exp_fold_tree_no_dot (r
->length_exp
);
8922 if (expld
.result
.valid_p
)
8923 r
->length
= expld
.result
.value
;
8925 einfo (_("%F%P: invalid length for memory region %s\n"),
8932 lang_add_unique (const char *name
)
8934 struct unique_sections
*ent
;
8936 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
8937 if (strcmp (ent
->name
, name
) == 0)
8940 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
8941 ent
->name
= xstrdup (name
);
8942 ent
->next
= unique_section_list
;
8943 unique_section_list
= ent
;
8946 /* Append the list of dynamic symbols to the existing one. */
8949 lang_append_dynamic_list (struct bfd_elf_version_expr
*dynamic
)
8951 if (link_info
.dynamic_list
)
8953 struct bfd_elf_version_expr
*tail
;
8954 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
8956 tail
->next
= link_info
.dynamic_list
->head
.list
;
8957 link_info
.dynamic_list
->head
.list
= dynamic
;
8961 struct bfd_elf_dynamic_list
*d
;
8963 d
= (struct bfd_elf_dynamic_list
*) xcalloc (1, sizeof *d
);
8964 d
->head
.list
= dynamic
;
8965 d
->match
= lang_vers_match
;
8966 link_info
.dynamic_list
= d
;
8970 /* Append the list of C++ typeinfo dynamic symbols to the existing
8974 lang_append_dynamic_list_cpp_typeinfo (void)
8976 const char *symbols
[] =
8978 "typeinfo name for*",
8981 struct bfd_elf_version_expr
*dynamic
= NULL
;
8984 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
8985 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
8988 lang_append_dynamic_list (dynamic
);
8991 /* Append the list of C++ operator new and delete dynamic symbols to the
8995 lang_append_dynamic_list_cpp_new (void)
8997 const char *symbols
[] =
9002 struct bfd_elf_version_expr
*dynamic
= NULL
;
9005 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
9006 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
9009 lang_append_dynamic_list (dynamic
);
9012 /* Scan a space and/or comma separated string of features. */
9015 lang_ld_feature (char *str
)
9023 while (*p
== ',' || ISSPACE (*p
))
9028 while (*q
&& *q
!= ',' && !ISSPACE (*q
))
9032 if (strcasecmp (p
, "SANE_EXPR") == 0)
9033 config
.sane_expr
= TRUE
;
9035 einfo (_("%X%P: unknown feature `%s'\n"), p
);
9041 /* Pretty print memory amount. */
9044 lang_print_memory_size (bfd_vma sz
)
9046 if ((sz
& 0x3fffffff) == 0)
9047 printf ("%10" BFD_VMA_FMT
"u GB", sz
>> 30);
9048 else if ((sz
& 0xfffff) == 0)
9049 printf ("%10" BFD_VMA_FMT
"u MB", sz
>> 20);
9050 else if ((sz
& 0x3ff) == 0)
9051 printf ("%10" BFD_VMA_FMT
"u KB", sz
>> 10);
9053 printf (" %10" BFD_VMA_FMT
"u B", sz
);
9056 /* Implement --print-memory-usage: disply per region memory usage. */
9059 lang_print_memory_usage (void)
9061 lang_memory_region_type
*r
;
9063 printf ("Memory region Used Size Region Size %%age Used\n");
9064 for (r
= lang_memory_region_list
; r
->next
!= NULL
; r
= r
->next
)
9066 bfd_vma used_length
= r
->current
- r
->origin
;
9069 printf ("%16s: ",r
->name_list
.name
);
9070 lang_print_memory_size (used_length
);
9071 lang_print_memory_size ((bfd_vma
) r
->length
);
9073 percent
= used_length
* 100.0 / r
->length
;
9075 printf (" %6.2f%%\n", percent
);