1 /* Linker command language support.
2 Copyright (C) 1991-2017 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. */
23 #include "libiberty.h"
24 #include "filenames.h"
25 #include "safe-ctype.h"
45 #endif /* ENABLE_PLUGINS */
48 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
51 /* Convert between addresses in bytes and sizes in octets.
52 For currently supported targets, octets_per_byte is always a power
53 of two, so we can use shifts. */
54 #define TO_ADDR(X) ((X) >> opb_shift)
55 #define TO_SIZE(X) ((X) << opb_shift)
57 /* Local variables. */
58 static struct obstack stat_obstack
;
59 static struct obstack map_obstack
;
61 #define obstack_chunk_alloc xmalloc
62 #define obstack_chunk_free free
63 static const char *entry_symbol_default
= "start";
64 static bfd_boolean placed_commons
= FALSE
;
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 static lang_statement_list_type statement_list
;
72 static lang_statement_list_type
*stat_save
[10];
73 static lang_statement_list_type
**stat_save_ptr
= &stat_save
[0];
74 static struct unique_sections
*unique_section_list
;
75 static struct asneeded_minfo
*asneeded_list_head
;
76 static unsigned int opb_shift
= 0;
78 /* Forward declarations. */
79 static void exp_init_os (etree_type
*);
80 static lang_input_statement_type
*lookup_name (const char *);
81 static void insert_undefined (const char *);
82 static bfd_boolean
sort_def_symbol (struct bfd_link_hash_entry
*, void *);
83 static void print_statement (lang_statement_union_type
*,
84 lang_output_section_statement_type
*);
85 static void print_statement_list (lang_statement_union_type
*,
86 lang_output_section_statement_type
*);
87 static void print_statements (void);
88 static void print_input_section (asection
*, bfd_boolean
);
89 static bfd_boolean
lang_one_common (struct bfd_link_hash_entry
*, void *);
90 static void lang_record_phdrs (void);
91 static void lang_do_version_exports_section (void);
92 static void lang_finalize_version_expr_head
93 (struct bfd_elf_version_expr_head
*);
94 static void lang_do_memory_regions (void);
96 /* Exported variables. */
97 const char *output_target
;
98 lang_output_section_statement_type
*abs_output_section
;
99 lang_statement_list_type lang_output_section_statement
;
100 lang_statement_list_type
*stat_ptr
= &statement_list
;
101 lang_statement_list_type file_chain
= { NULL
, NULL
};
102 lang_statement_list_type input_file_chain
;
103 struct bfd_sym_chain entry_symbol
= { NULL
, NULL
};
104 const char *entry_section
= ".text";
105 struct lang_input_statement_flags input_flags
;
106 bfd_boolean entry_from_cmdline
;
107 bfd_boolean undef_from_cmdline
;
108 bfd_boolean lang_has_input_file
= FALSE
;
109 bfd_boolean had_output_filename
= FALSE
;
110 bfd_boolean lang_float_flag
= FALSE
;
111 bfd_boolean delete_output_file_on_failure
= FALSE
;
112 struct lang_phdr
*lang_phdr_list
;
113 struct lang_nocrossrefs
*nocrossref_list
;
114 struct asneeded_minfo
**asneeded_list_tail
;
116 /* Functions that traverse the linker script and might evaluate
117 DEFINED() need to increment this at the start of the traversal. */
118 int lang_statement_iteration
= 0;
120 /* Return TRUE if the PATTERN argument is a wildcard pattern.
121 Although backslashes are treated specially if a pattern contains
122 wildcards, we do not consider the mere presence of a backslash to
123 be enough to cause the pattern to be treated as a wildcard.
124 That lets us handle DOS filenames more naturally. */
125 #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
127 #define new_stat(x, y) \
128 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
130 #define outside_section_address(q) \
131 ((q)->output_offset + (q)->output_section->vma)
133 #define outside_symbol_address(q) \
134 ((q)->value + outside_section_address (q->section))
136 #define SECTION_NAME_MAP_LENGTH (16)
139 stat_alloc (size_t size
)
141 return obstack_alloc (&stat_obstack
, size
);
145 name_match (const char *pattern
, const char *name
)
147 if (wildcardp (pattern
))
148 return fnmatch (pattern
, name
, 0);
149 return strcmp (pattern
, name
);
152 /* If PATTERN is of the form archive:file, return a pointer to the
153 separator. If not, return NULL. */
156 archive_path (const char *pattern
)
160 if (link_info
.path_separator
== 0)
163 p
= strchr (pattern
, link_info
.path_separator
);
164 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
165 if (p
== NULL
|| link_info
.path_separator
!= ':')
168 /* Assume a match on the second char is part of drive specifier,
169 as in "c:\silly.dos". */
170 if (p
== pattern
+ 1 && ISALPHA (*pattern
))
171 p
= strchr (p
+ 1, link_info
.path_separator
);
176 /* Given that FILE_SPEC results in a non-NULL SEP result from archive_path,
177 return whether F matches FILE_SPEC. */
180 input_statement_is_archive_path (const char *file_spec
, char *sep
,
181 lang_input_statement_type
*f
)
183 bfd_boolean match
= FALSE
;
186 || name_match (sep
+ 1, f
->filename
) == 0)
187 && ((sep
!= file_spec
)
188 == (f
->the_bfd
!= NULL
&& f
->the_bfd
->my_archive
!= NULL
)))
192 if (sep
!= file_spec
)
194 const char *aname
= f
->the_bfd
->my_archive
->filename
;
196 match
= name_match (file_spec
, aname
) == 0;
197 *sep
= link_info
.path_separator
;
204 unique_section_p (const asection
*sec
,
205 const lang_output_section_statement_type
*os
)
207 struct unique_sections
*unam
;
210 if (!link_info
.resolve_section_groups
211 && sec
->owner
!= NULL
212 && bfd_is_group_section (sec
->owner
, sec
))
214 && strcmp (os
->name
, DISCARD_SECTION_NAME
) == 0);
217 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
218 if (name_match (unam
->name
, secnam
) == 0)
224 /* Generic traversal routines for finding matching sections. */
226 /* Return true if FILE matches a pattern in EXCLUDE_LIST, otherwise return
230 walk_wild_file_in_exclude_list (struct name_list
*exclude_list
,
231 lang_input_statement_type
*file
)
233 struct name_list
*list_tmp
;
235 for (list_tmp
= exclude_list
;
237 list_tmp
= list_tmp
->next
)
239 char *p
= archive_path (list_tmp
->name
);
243 if (input_statement_is_archive_path (list_tmp
->name
, p
, file
))
247 else if (name_match (list_tmp
->name
, file
->filename
) == 0)
250 /* FIXME: Perhaps remove the following at some stage? Matching
251 unadorned archives like this was never documented and has
252 been superceded by the archive:path syntax. */
253 else if (file
->the_bfd
!= NULL
254 && file
->the_bfd
->my_archive
!= NULL
255 && name_match (list_tmp
->name
,
256 file
->the_bfd
->my_archive
->filename
) == 0)
263 /* Try processing a section against a wildcard. This just calls
264 the callback unless the filename exclusion list is present
265 and excludes the file. It's hardly ever present so this
266 function is very fast. */
269 walk_wild_consider_section (lang_wild_statement_type
*ptr
,
270 lang_input_statement_type
*file
,
272 struct wildcard_list
*sec
,
276 /* Don't process sections from files which were excluded. */
277 if (walk_wild_file_in_exclude_list (sec
->spec
.exclude_name_list
, file
))
280 (*callback
) (ptr
, sec
, s
, ptr
->section_flag_list
, file
, data
);
283 /* Lowest common denominator routine that can handle everything correctly,
287 walk_wild_section_general (lang_wild_statement_type
*ptr
,
288 lang_input_statement_type
*file
,
293 struct wildcard_list
*sec
;
295 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
297 sec
= ptr
->section_list
;
299 (*callback
) (ptr
, sec
, s
, ptr
->section_flag_list
, file
, data
);
303 bfd_boolean skip
= FALSE
;
305 if (sec
->spec
.name
!= NULL
)
307 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
309 skip
= name_match (sec
->spec
.name
, sname
) != 0;
313 walk_wild_consider_section (ptr
, file
, s
, sec
, callback
, data
);
320 /* Routines to find a single section given its name. If there's more
321 than one section with that name, we report that. */
325 asection
*found_section
;
326 bfd_boolean multiple_sections_found
;
327 } section_iterator_callback_data
;
330 section_iterator_callback (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*s
, void *data
)
332 section_iterator_callback_data
*d
= (section_iterator_callback_data
*) data
;
334 if (d
->found_section
!= NULL
)
336 d
->multiple_sections_found
= TRUE
;
340 d
->found_section
= s
;
345 find_section (lang_input_statement_type
*file
,
346 struct wildcard_list
*sec
,
347 bfd_boolean
*multiple_sections_found
)
349 section_iterator_callback_data cb_data
= { NULL
, FALSE
};
351 bfd_get_section_by_name_if (file
->the_bfd
, sec
->spec
.name
,
352 section_iterator_callback
, &cb_data
);
353 *multiple_sections_found
= cb_data
.multiple_sections_found
;
354 return cb_data
.found_section
;
357 /* Code for handling simple wildcards without going through fnmatch,
358 which can be expensive because of charset translations etc. */
360 /* A simple wild is a literal string followed by a single '*',
361 where the literal part is at least 4 characters long. */
364 is_simple_wild (const char *name
)
366 size_t len
= strcspn (name
, "*?[");
367 return len
>= 4 && name
[len
] == '*' && name
[len
+ 1] == '\0';
371 match_simple_wild (const char *pattern
, const char *name
)
373 /* The first four characters of the pattern are guaranteed valid
374 non-wildcard characters. So we can go faster. */
375 if (pattern
[0] != name
[0] || pattern
[1] != name
[1]
376 || pattern
[2] != name
[2] || pattern
[3] != name
[3])
381 while (*pattern
!= '*')
382 if (*name
++ != *pattern
++)
388 /* Return the numerical value of the init_priority attribute from
389 section name NAME. */
392 get_init_priority (const char *name
)
395 unsigned long init_priority
;
397 /* GCC uses the following section names for the init_priority
398 attribute with numerical values 101 and 65535 inclusive. A
399 lower value means a higher priority.
401 1: .init_array.NNNN/.fini_array.NNNN: Where NNNN is the
402 decimal numerical value of the init_priority attribute.
403 The order of execution in .init_array is forward and
404 .fini_array is backward.
405 2: .ctors.NNNN/.dtors.NNNN: Where NNNN is 65535 minus the
406 decimal numerical value of the init_priority attribute.
407 The order of execution in .ctors is backward and .dtors
410 if (strncmp (name
, ".init_array.", 12) == 0
411 || strncmp (name
, ".fini_array.", 12) == 0)
413 init_priority
= strtoul (name
+ 12, &end
, 10);
414 return *end
? 0 : init_priority
;
416 else if (strncmp (name
, ".ctors.", 7) == 0
417 || strncmp (name
, ".dtors.", 7) == 0)
419 init_priority
= strtoul (name
+ 7, &end
, 10);
420 return *end
? 0 : 65535 - init_priority
;
426 /* Compare sections ASEC and BSEC according to SORT. */
429 compare_section (sort_type sort
, asection
*asec
, asection
*bsec
)
432 unsigned long ainit_priority
, binit_priority
;
439 case by_init_priority
:
441 = get_init_priority (bfd_get_section_name (asec
->owner
, asec
));
443 = get_init_priority (bfd_get_section_name (bsec
->owner
, bsec
));
444 if (ainit_priority
== 0 || binit_priority
== 0)
446 ret
= ainit_priority
- binit_priority
;
452 case by_alignment_name
:
453 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
454 - bfd_section_alignment (asec
->owner
, asec
));
461 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
462 bfd_get_section_name (bsec
->owner
, bsec
));
465 case by_name_alignment
:
466 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
467 bfd_get_section_name (bsec
->owner
, bsec
));
473 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
474 - bfd_section_alignment (asec
->owner
, asec
));
481 /* Build a Binary Search Tree to sort sections, unlike insertion sort
482 used in wild_sort(). BST is considerably faster if the number of
483 of sections are large. */
485 static lang_section_bst_type
**
486 wild_sort_fast (lang_wild_statement_type
*wild
,
487 struct wildcard_list
*sec
,
488 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
491 lang_section_bst_type
**tree
;
494 if (!wild
->filenames_sorted
495 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
497 /* Append at the right end of tree. */
499 tree
= &((*tree
)->right
);
505 /* Find the correct node to append this section. */
506 if (compare_section (sec
->spec
.sorted
, section
, (*tree
)->section
) < 0)
507 tree
= &((*tree
)->left
);
509 tree
= &((*tree
)->right
);
515 /* Use wild_sort_fast to build a BST to sort sections. */
518 output_section_callback_fast (lang_wild_statement_type
*ptr
,
519 struct wildcard_list
*sec
,
521 struct flag_info
*sflag_list ATTRIBUTE_UNUSED
,
522 lang_input_statement_type
*file
,
525 lang_section_bst_type
*node
;
526 lang_section_bst_type
**tree
;
527 lang_output_section_statement_type
*os
;
529 os
= (lang_output_section_statement_type
*) output
;
531 if (unique_section_p (section
, os
))
534 node
= (lang_section_bst_type
*) xmalloc (sizeof (lang_section_bst_type
));
537 node
->section
= section
;
539 tree
= wild_sort_fast (ptr
, sec
, file
, section
);
544 /* Convert a sorted sections' BST back to list form. */
547 output_section_callback_tree_to_list (lang_wild_statement_type
*ptr
,
548 lang_section_bst_type
*tree
,
552 output_section_callback_tree_to_list (ptr
, tree
->left
, output
);
554 lang_add_section (&ptr
->children
, tree
->section
, NULL
,
555 (lang_output_section_statement_type
*) output
);
558 output_section_callback_tree_to_list (ptr
, tree
->right
, output
);
563 /* Specialized, optimized routines for handling different kinds of
567 walk_wild_section_specs1_wild0 (lang_wild_statement_type
*ptr
,
568 lang_input_statement_type
*file
,
572 /* We can just do a hash lookup for the section with the right name.
573 But if that lookup discovers more than one section with the name
574 (should be rare), we fall back to the general algorithm because
575 we would otherwise have to sort the sections to make sure they
576 get processed in the bfd's order. */
577 bfd_boolean multiple_sections_found
;
578 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
579 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
581 if (multiple_sections_found
)
582 walk_wild_section_general (ptr
, file
, callback
, data
);
584 walk_wild_consider_section (ptr
, file
, s0
, sec0
, callback
, data
);
588 walk_wild_section_specs1_wild1 (lang_wild_statement_type
*ptr
,
589 lang_input_statement_type
*file
,
594 struct wildcard_list
*wildsec0
= ptr
->handler_data
[0];
596 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
598 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
599 bfd_boolean skip
= !match_simple_wild (wildsec0
->spec
.name
, sname
);
602 walk_wild_consider_section (ptr
, file
, s
, wildsec0
, callback
, data
);
607 walk_wild_section_specs2_wild1 (lang_wild_statement_type
*ptr
,
608 lang_input_statement_type
*file
,
613 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
614 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
615 bfd_boolean multiple_sections_found
;
616 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
618 if (multiple_sections_found
)
620 walk_wild_section_general (ptr
, file
, callback
, data
);
624 /* Note that if the section was not found, s0 is NULL and
625 we'll simply never succeed the s == s0 test below. */
626 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
628 /* Recall that in this code path, a section cannot satisfy more
629 than one spec, so if s == s0 then it cannot match
632 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
635 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
636 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
639 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
,
646 walk_wild_section_specs3_wild2 (lang_wild_statement_type
*ptr
,
647 lang_input_statement_type
*file
,
652 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
653 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
654 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
655 bfd_boolean multiple_sections_found
;
656 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
658 if (multiple_sections_found
)
660 walk_wild_section_general (ptr
, file
, callback
, data
);
664 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
667 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
670 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
671 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
674 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
, data
);
677 skip
= !match_simple_wild (wildsec2
->spec
.name
, sname
);
679 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
687 walk_wild_section_specs4_wild2 (lang_wild_statement_type
*ptr
,
688 lang_input_statement_type
*file
,
693 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
694 struct wildcard_list
*sec1
= ptr
->handler_data
[1];
695 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
696 struct wildcard_list
*wildsec3
= ptr
->handler_data
[3];
697 bfd_boolean multiple_sections_found
;
698 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
), *s1
;
700 if (multiple_sections_found
)
702 walk_wild_section_general (ptr
, file
, callback
, data
);
706 s1
= find_section (file
, sec1
, &multiple_sections_found
);
707 if (multiple_sections_found
)
709 walk_wild_section_general (ptr
, file
, callback
, data
);
713 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
716 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
719 walk_wild_consider_section (ptr
, file
, s
, sec1
, callback
, data
);
722 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
723 bfd_boolean skip
= !match_simple_wild (wildsec2
->spec
.name
,
727 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
731 skip
= !match_simple_wild (wildsec3
->spec
.name
, sname
);
733 walk_wild_consider_section (ptr
, file
, s
, wildsec3
,
741 walk_wild_section (lang_wild_statement_type
*ptr
,
742 lang_input_statement_type
*file
,
746 if (file
->flags
.just_syms
)
749 (*ptr
->walk_wild_section_handler
) (ptr
, file
, callback
, data
);
752 /* Returns TRUE when name1 is a wildcard spec that might match
753 something name2 can match. We're conservative: we return FALSE
754 only if the prefixes of name1 and name2 are different up to the
755 first wildcard character. */
758 wild_spec_can_overlap (const char *name1
, const char *name2
)
760 size_t prefix1_len
= strcspn (name1
, "?*[");
761 size_t prefix2_len
= strcspn (name2
, "?*[");
762 size_t min_prefix_len
;
764 /* Note that if there is no wildcard character, then we treat the
765 terminating 0 as part of the prefix. Thus ".text" won't match
766 ".text." or ".text.*", for example. */
767 if (name1
[prefix1_len
] == '\0')
769 if (name2
[prefix2_len
] == '\0')
772 min_prefix_len
= prefix1_len
< prefix2_len
? prefix1_len
: prefix2_len
;
774 return memcmp (name1
, name2
, min_prefix_len
) == 0;
777 /* Select specialized code to handle various kinds of wildcard
781 analyze_walk_wild_section_handler (lang_wild_statement_type
*ptr
)
784 int wild_name_count
= 0;
785 struct wildcard_list
*sec
;
789 ptr
->walk_wild_section_handler
= walk_wild_section_general
;
790 ptr
->handler_data
[0] = NULL
;
791 ptr
->handler_data
[1] = NULL
;
792 ptr
->handler_data
[2] = NULL
;
793 ptr
->handler_data
[3] = NULL
;
796 /* Count how many wildcard_specs there are, and how many of those
797 actually use wildcards in the name. Also, bail out if any of the
798 wildcard names are NULL. (Can this actually happen?
799 walk_wild_section used to test for it.) And bail out if any
800 of the wildcards are more complex than a simple string
801 ending in a single '*'. */
802 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
805 if (sec
->spec
.name
== NULL
)
807 if (wildcardp (sec
->spec
.name
))
810 if (!is_simple_wild (sec
->spec
.name
))
815 /* The zero-spec case would be easy to optimize but it doesn't
816 happen in practice. Likewise, more than 4 specs doesn't
817 happen in practice. */
818 if (sec_count
== 0 || sec_count
> 4)
821 /* Check that no two specs can match the same section. */
822 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
824 struct wildcard_list
*sec2
;
825 for (sec2
= sec
->next
; sec2
!= NULL
; sec2
= sec2
->next
)
827 if (wild_spec_can_overlap (sec
->spec
.name
, sec2
->spec
.name
))
832 signature
= (sec_count
<< 8) + wild_name_count
;
836 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild0
;
839 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild1
;
842 ptr
->walk_wild_section_handler
= walk_wild_section_specs2_wild1
;
845 ptr
->walk_wild_section_handler
= walk_wild_section_specs3_wild2
;
848 ptr
->walk_wild_section_handler
= walk_wild_section_specs4_wild2
;
854 /* Now fill the data array with pointers to the specs, first the
855 specs with non-wildcard names, then the specs with wildcard
856 names. It's OK to process the specs in different order from the
857 given order, because we've already determined that no section
858 will match more than one spec. */
860 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
861 if (!wildcardp (sec
->spec
.name
))
862 ptr
->handler_data
[data_counter
++] = sec
;
863 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
864 if (wildcardp (sec
->spec
.name
))
865 ptr
->handler_data
[data_counter
++] = sec
;
868 /* Handle a wild statement for a single file F. */
871 walk_wild_file (lang_wild_statement_type
*s
,
872 lang_input_statement_type
*f
,
876 if (walk_wild_file_in_exclude_list (s
->exclude_name_list
, f
))
879 if (f
->the_bfd
== NULL
880 || !bfd_check_format (f
->the_bfd
, bfd_archive
))
881 walk_wild_section (s
, f
, callback
, data
);
886 /* This is an archive file. We must map each member of the
887 archive separately. */
888 member
= bfd_openr_next_archived_file (f
->the_bfd
, NULL
);
889 while (member
!= NULL
)
891 /* When lookup_name is called, it will call the add_symbols
892 entry point for the archive. For each element of the
893 archive which is included, BFD will call ldlang_add_file,
894 which will set the usrdata field of the member to the
895 lang_input_statement. */
896 if (member
->usrdata
!= NULL
)
898 walk_wild_section (s
,
899 (lang_input_statement_type
*) member
->usrdata
,
903 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
909 walk_wild (lang_wild_statement_type
*s
, callback_t callback
, void *data
)
911 const char *file_spec
= s
->filename
;
914 if (file_spec
== NULL
)
916 /* Perform the iteration over all files in the list. */
917 LANG_FOR_EACH_INPUT_STATEMENT (f
)
919 walk_wild_file (s
, f
, callback
, data
);
922 else if ((p
= archive_path (file_spec
)) != NULL
)
924 LANG_FOR_EACH_INPUT_STATEMENT (f
)
926 if (input_statement_is_archive_path (file_spec
, p
, f
))
927 walk_wild_file (s
, f
, callback
, data
);
930 else if (wildcardp (file_spec
))
932 LANG_FOR_EACH_INPUT_STATEMENT (f
)
934 if (fnmatch (file_spec
, f
->filename
, 0) == 0)
935 walk_wild_file (s
, f
, callback
, data
);
940 lang_input_statement_type
*f
;
942 /* Perform the iteration over a single file. */
943 f
= lookup_name (file_spec
);
945 walk_wild_file (s
, f
, callback
, data
);
949 /* lang_for_each_statement walks the parse tree and calls the provided
950 function for each node, except those inside output section statements
951 with constraint set to -1. */
954 lang_for_each_statement_worker (void (*func
) (lang_statement_union_type
*),
955 lang_statement_union_type
*s
)
957 for (; s
!= NULL
; s
= s
->header
.next
)
961 switch (s
->header
.type
)
963 case lang_constructors_statement_enum
:
964 lang_for_each_statement_worker (func
, constructor_list
.head
);
966 case lang_output_section_statement_enum
:
967 if (s
->output_section_statement
.constraint
!= -1)
968 lang_for_each_statement_worker
969 (func
, s
->output_section_statement
.children
.head
);
971 case lang_wild_statement_enum
:
972 lang_for_each_statement_worker (func
,
973 s
->wild_statement
.children
.head
);
975 case lang_group_statement_enum
:
976 lang_for_each_statement_worker (func
,
977 s
->group_statement
.children
.head
);
979 case lang_data_statement_enum
:
980 case lang_reloc_statement_enum
:
981 case lang_object_symbols_statement_enum
:
982 case lang_output_statement_enum
:
983 case lang_target_statement_enum
:
984 case lang_input_section_enum
:
985 case lang_input_statement_enum
:
986 case lang_assignment_statement_enum
:
987 case lang_padding_statement_enum
:
988 case lang_address_statement_enum
:
989 case lang_fill_statement_enum
:
990 case lang_insert_statement_enum
:
1000 lang_for_each_statement (void (*func
) (lang_statement_union_type
*))
1002 lang_for_each_statement_worker (func
, statement_list
.head
);
1005 /*----------------------------------------------------------------------*/
1008 lang_list_init (lang_statement_list_type
*list
)
1011 list
->tail
= &list
->head
;
1015 push_stat_ptr (lang_statement_list_type
*new_ptr
)
1017 if (stat_save_ptr
>= stat_save
+ sizeof (stat_save
) / sizeof (stat_save
[0]))
1019 *stat_save_ptr
++ = stat_ptr
;
1026 if (stat_save_ptr
<= stat_save
)
1028 stat_ptr
= *--stat_save_ptr
;
1031 /* Build a new statement node for the parse tree. */
1033 static lang_statement_union_type
*
1034 new_statement (enum statement_enum type
,
1036 lang_statement_list_type
*list
)
1038 lang_statement_union_type
*new_stmt
;
1040 new_stmt
= (lang_statement_union_type
*) stat_alloc (size
);
1041 new_stmt
->header
.type
= type
;
1042 new_stmt
->header
.next
= NULL
;
1043 lang_statement_append (list
, new_stmt
, &new_stmt
->header
.next
);
1047 /* Build a new input file node for the language. There are several
1048 ways in which we treat an input file, eg, we only look at symbols,
1049 or prefix it with a -l etc.
1051 We can be supplied with requests for input files more than once;
1052 they may, for example be split over several lines like foo.o(.text)
1053 foo.o(.data) etc, so when asked for a file we check that we haven't
1054 got it already so we don't duplicate the bfd. */
1056 static lang_input_statement_type
*
1057 new_afile (const char *name
,
1058 lang_input_file_enum_type file_type
,
1060 bfd_boolean add_to_list
)
1062 lang_input_statement_type
*p
;
1064 lang_has_input_file
= TRUE
;
1067 p
= (lang_input_statement_type
*) new_stat (lang_input_statement
, stat_ptr
);
1070 p
= (lang_input_statement_type
*)
1071 stat_alloc (sizeof (lang_input_statement_type
));
1072 p
->header
.type
= lang_input_statement_enum
;
1073 p
->header
.next
= NULL
;
1076 memset (&p
->the_bfd
, 0,
1077 sizeof (*p
) - offsetof (lang_input_statement_type
, the_bfd
));
1079 p
->flags
.dynamic
= input_flags
.dynamic
;
1080 p
->flags
.add_DT_NEEDED_for_dynamic
= input_flags
.add_DT_NEEDED_for_dynamic
;
1081 p
->flags
.add_DT_NEEDED_for_regular
= input_flags
.add_DT_NEEDED_for_regular
;
1082 p
->flags
.whole_archive
= input_flags
.whole_archive
;
1083 p
->flags
.sysrooted
= input_flags
.sysrooted
;
1087 case lang_input_file_is_symbols_only_enum
:
1089 p
->local_sym_name
= name
;
1090 p
->flags
.real
= TRUE
;
1091 p
->flags
.just_syms
= TRUE
;
1093 case lang_input_file_is_fake_enum
:
1095 p
->local_sym_name
= name
;
1097 case lang_input_file_is_l_enum
:
1098 if (name
[0] == ':' && name
[1] != '\0')
1100 p
->filename
= name
+ 1;
1101 p
->flags
.full_name_provided
= TRUE
;
1105 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
1106 p
->flags
.maybe_archive
= TRUE
;
1107 p
->flags
.real
= TRUE
;
1108 p
->flags
.search_dirs
= TRUE
;
1110 case lang_input_file_is_marker_enum
:
1112 p
->local_sym_name
= name
;
1113 p
->flags
.search_dirs
= TRUE
;
1115 case lang_input_file_is_search_file_enum
:
1117 p
->local_sym_name
= name
;
1118 p
->flags
.real
= TRUE
;
1119 p
->flags
.search_dirs
= TRUE
;
1121 case lang_input_file_is_file_enum
:
1123 p
->local_sym_name
= name
;
1124 p
->flags
.real
= TRUE
;
1130 lang_statement_append (&input_file_chain
,
1131 (lang_statement_union_type
*) p
,
1132 &p
->next_real_file
);
1136 lang_input_statement_type
*
1137 lang_add_input_file (const char *name
,
1138 lang_input_file_enum_type file_type
,
1142 && (*name
== '=' || CONST_STRNEQ (name
, "$SYSROOT")))
1144 lang_input_statement_type
*ret
;
1145 char *sysrooted_name
1146 = concat (ld_sysroot
,
1147 name
+ (*name
== '=' ? 1 : strlen ("$SYSROOT")),
1148 (const char *) NULL
);
1150 /* We've now forcibly prepended the sysroot, making the input
1151 file independent of the context. Therefore, temporarily
1152 force a non-sysrooted context for this statement, so it won't
1153 get the sysroot prepended again when opened. (N.B. if it's a
1154 script, any child nodes with input files starting with "/"
1155 will be handled as "sysrooted" as they'll be found to be
1156 within the sysroot subdirectory.) */
1157 unsigned int outer_sysrooted
= input_flags
.sysrooted
;
1158 input_flags
.sysrooted
= 0;
1159 ret
= new_afile (sysrooted_name
, file_type
, target
, TRUE
);
1160 input_flags
.sysrooted
= outer_sysrooted
;
1164 return new_afile (name
, file_type
, target
, TRUE
);
1167 struct out_section_hash_entry
1169 struct bfd_hash_entry root
;
1170 lang_statement_union_type s
;
1173 /* The hash table. */
1175 static struct bfd_hash_table output_section_statement_table
;
1177 /* Support routines for the hash table used by lang_output_section_find,
1178 initialize the table, fill in an entry and remove the table. */
1180 static struct bfd_hash_entry
*
1181 output_section_statement_newfunc (struct bfd_hash_entry
*entry
,
1182 struct bfd_hash_table
*table
,
1185 lang_output_section_statement_type
**nextp
;
1186 struct out_section_hash_entry
*ret
;
1190 entry
= (struct bfd_hash_entry
*) bfd_hash_allocate (table
,
1196 entry
= bfd_hash_newfunc (entry
, table
, string
);
1200 ret
= (struct out_section_hash_entry
*) entry
;
1201 memset (&ret
->s
, 0, sizeof (ret
->s
));
1202 ret
->s
.header
.type
= lang_output_section_statement_enum
;
1203 ret
->s
.output_section_statement
.subsection_alignment
= -1;
1204 ret
->s
.output_section_statement
.section_alignment
= -1;
1205 ret
->s
.output_section_statement
.block_value
= 1;
1206 lang_list_init (&ret
->s
.output_section_statement
.children
);
1207 lang_statement_append (stat_ptr
, &ret
->s
, &ret
->s
.header
.next
);
1209 /* For every output section statement added to the list, except the
1210 first one, lang_output_section_statement.tail points to the "next"
1211 field of the last element of the list. */
1212 if (lang_output_section_statement
.head
!= NULL
)
1213 ret
->s
.output_section_statement
.prev
1214 = ((lang_output_section_statement_type
*)
1215 ((char *) lang_output_section_statement
.tail
1216 - offsetof (lang_output_section_statement_type
, next
)));
1218 /* GCC's strict aliasing rules prevent us from just casting the
1219 address, so we store the pointer in a variable and cast that
1221 nextp
= &ret
->s
.output_section_statement
.next
;
1222 lang_statement_append (&lang_output_section_statement
,
1224 (lang_statement_union_type
**) nextp
);
1229 output_section_statement_table_init (void)
1231 if (!bfd_hash_table_init_n (&output_section_statement_table
,
1232 output_section_statement_newfunc
,
1233 sizeof (struct out_section_hash_entry
),
1235 einfo (_("%P%F: can not create hash table: %E\n"));
1239 output_section_statement_table_free (void)
1241 bfd_hash_table_free (&output_section_statement_table
);
1244 /* Build enough state so that the parser can build its tree. */
1249 obstack_begin (&stat_obstack
, 1000);
1251 stat_ptr
= &statement_list
;
1253 output_section_statement_table_init ();
1255 lang_list_init (stat_ptr
);
1257 lang_list_init (&input_file_chain
);
1258 lang_list_init (&lang_output_section_statement
);
1259 lang_list_init (&file_chain
);
1260 first_file
= lang_add_input_file (NULL
, lang_input_file_is_marker_enum
,
1262 abs_output_section
=
1263 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
, 0, TRUE
);
1265 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
1267 asneeded_list_head
= NULL
;
1268 asneeded_list_tail
= &asneeded_list_head
;
1274 output_section_statement_table_free ();
1277 /*----------------------------------------------------------------------
1278 A region is an area of memory declared with the
1279 MEMORY { name:org=exp, len=exp ... }
1282 We maintain a list of all the regions here.
1284 If no regions are specified in the script, then the default is used
1285 which is created when looked up to be the entire data space.
1287 If create is true we are creating a region inside a MEMORY block.
1288 In this case it is probably an error to create a region that has
1289 already been created. If we are not inside a MEMORY block it is
1290 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1291 and so we issue a warning.
1293 Each region has at least one name. The first name is either
1294 DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add
1295 alias names to an existing region within a script with
1296 REGION_ALIAS (alias, region_name). Each name corresponds to at most one
1299 static lang_memory_region_type
*lang_memory_region_list
;
1300 static lang_memory_region_type
**lang_memory_region_list_tail
1301 = &lang_memory_region_list
;
1303 lang_memory_region_type
*
1304 lang_memory_region_lookup (const char *const name
, bfd_boolean create
)
1306 lang_memory_region_name
*n
;
1307 lang_memory_region_type
*r
;
1308 lang_memory_region_type
*new_region
;
1310 /* NAME is NULL for LMA memspecs if no region was specified. */
1314 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1315 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1316 if (strcmp (n
->name
, name
) == 0)
1319 einfo (_("%P:%S: warning: redeclaration of memory region `%s'\n"),
1324 if (!create
&& strcmp (name
, DEFAULT_MEMORY_REGION
))
1325 einfo (_("%P:%S: warning: memory region `%s' not declared\n"),
1328 new_region
= (lang_memory_region_type
*)
1329 stat_alloc (sizeof (lang_memory_region_type
));
1331 new_region
->name_list
.name
= xstrdup (name
);
1332 new_region
->name_list
.next
= NULL
;
1333 new_region
->next
= NULL
;
1334 new_region
->origin_exp
= NULL
;
1335 new_region
->origin
= 0;
1336 new_region
->length_exp
= NULL
;
1337 new_region
->length
= ~(bfd_size_type
) 0;
1338 new_region
->current
= 0;
1339 new_region
->last_os
= NULL
;
1340 new_region
->flags
= 0;
1341 new_region
->not_flags
= 0;
1342 new_region
->had_full_message
= FALSE
;
1344 *lang_memory_region_list_tail
= new_region
;
1345 lang_memory_region_list_tail
= &new_region
->next
;
1351 lang_memory_region_alias (const char *alias
, const char *region_name
)
1353 lang_memory_region_name
*n
;
1354 lang_memory_region_type
*r
;
1355 lang_memory_region_type
*region
;
1357 /* The default region must be unique. This ensures that it is not necessary
1358 to iterate through the name list if someone wants the check if a region is
1359 the default memory region. */
1360 if (strcmp (region_name
, DEFAULT_MEMORY_REGION
) == 0
1361 || strcmp (alias
, DEFAULT_MEMORY_REGION
) == 0)
1362 einfo (_("%F%P:%S: error: alias for default memory region\n"), NULL
);
1364 /* Look for the target region and check if the alias is not already
1367 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1368 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1370 if (region
== NULL
&& strcmp (n
->name
, region_name
) == 0)
1372 if (strcmp (n
->name
, alias
) == 0)
1373 einfo (_("%F%P:%S: error: redefinition of memory region "
1378 /* Check if the target region exists. */
1380 einfo (_("%F%P:%S: error: memory region `%s' "
1381 "for alias `%s' does not exist\n"),
1382 NULL
, region_name
, alias
);
1384 /* Add alias to region name list. */
1385 n
= (lang_memory_region_name
*) stat_alloc (sizeof (lang_memory_region_name
));
1386 n
->name
= xstrdup (alias
);
1387 n
->next
= region
->name_list
.next
;
1388 region
->name_list
.next
= n
;
1391 static lang_memory_region_type
*
1392 lang_memory_default (asection
*section
)
1394 lang_memory_region_type
*p
;
1396 flagword sec_flags
= section
->flags
;
1398 /* Override SEC_DATA to mean a writable section. */
1399 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
1400 sec_flags
|= SEC_DATA
;
1402 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
1404 if ((p
->flags
& sec_flags
) != 0
1405 && (p
->not_flags
& sec_flags
) == 0)
1410 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
1413 /* Get the output section statement directly from the userdata. */
1415 lang_output_section_statement_type
*
1416 lang_output_section_get (const asection
*output_section
)
1418 return get_userdata (output_section
);
1421 /* Find or create an output_section_statement with the given NAME.
1422 If CONSTRAINT is non-zero match one with that constraint, otherwise
1423 match any non-negative constraint. If CREATE, always make a
1424 new output_section_statement for SPECIAL CONSTRAINT. */
1426 lang_output_section_statement_type
*
1427 lang_output_section_statement_lookup (const char *name
,
1431 struct out_section_hash_entry
*entry
;
1433 entry
= ((struct out_section_hash_entry
*)
1434 bfd_hash_lookup (&output_section_statement_table
, name
,
1439 einfo (_("%P%F: failed creating section `%s': %E\n"), name
);
1443 if (entry
->s
.output_section_statement
.name
!= NULL
)
1445 /* We have a section of this name, but it might not have the correct
1447 struct out_section_hash_entry
*last_ent
;
1449 name
= entry
->s
.output_section_statement
.name
;
1450 if (create
&& constraint
== SPECIAL
)
1451 /* Not traversing to the end reverses the order of the second
1452 and subsequent SPECIAL sections in the hash table chain,
1453 but that shouldn't matter. */
1458 if (constraint
== entry
->s
.output_section_statement
.constraint
1460 && entry
->s
.output_section_statement
.constraint
>= 0))
1461 return &entry
->s
.output_section_statement
;
1463 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1465 while (entry
!= NULL
1466 && name
== entry
->s
.output_section_statement
.name
);
1472 = ((struct out_section_hash_entry
*)
1473 output_section_statement_newfunc (NULL
,
1474 &output_section_statement_table
,
1478 einfo (_("%P%F: failed creating section `%s': %E\n"), name
);
1481 entry
->root
= last_ent
->root
;
1482 last_ent
->root
.next
= &entry
->root
;
1485 entry
->s
.output_section_statement
.name
= name
;
1486 entry
->s
.output_section_statement
.constraint
= constraint
;
1487 return &entry
->s
.output_section_statement
;
1490 /* Find the next output_section_statement with the same name as OS.
1491 If CONSTRAINT is non-zero, find one with that constraint otherwise
1492 match any non-negative constraint. */
1494 lang_output_section_statement_type
*
1495 next_matching_output_section_statement (lang_output_section_statement_type
*os
,
1498 /* All output_section_statements are actually part of a
1499 struct out_section_hash_entry. */
1500 struct out_section_hash_entry
*entry
= (struct out_section_hash_entry
*)
1502 - offsetof (struct out_section_hash_entry
, s
.output_section_statement
));
1503 const char *name
= os
->name
;
1505 ASSERT (name
== entry
->root
.string
);
1508 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1510 || name
!= entry
->s
.output_section_statement
.name
)
1513 while (constraint
!= entry
->s
.output_section_statement
.constraint
1515 || entry
->s
.output_section_statement
.constraint
< 0));
1517 return &entry
->s
.output_section_statement
;
1520 /* A variant of lang_output_section_find used by place_orphan.
1521 Returns the output statement that should precede a new output
1522 statement for SEC. If an exact match is found on certain flags,
1525 lang_output_section_statement_type
*
1526 lang_output_section_find_by_flags (const asection
*sec
,
1528 lang_output_section_statement_type
**exact
,
1529 lang_match_sec_type_func match_type
)
1531 lang_output_section_statement_type
*first
, *look
, *found
;
1532 flagword look_flags
, differ
;
1534 /* We know the first statement on this list is *ABS*. May as well
1536 first
= &lang_output_section_statement
.head
->output_section_statement
;
1537 first
= first
->next
;
1539 /* First try for an exact match. */
1541 for (look
= first
; look
; look
= look
->next
)
1543 look_flags
= look
->flags
;
1544 if (look
->bfd_section
!= NULL
)
1546 look_flags
= look
->bfd_section
->flags
;
1547 if (match_type
&& !match_type (link_info
.output_bfd
,
1552 differ
= look_flags
^ sec_flags
;
1553 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1554 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1564 if ((sec_flags
& SEC_CODE
) != 0
1565 && (sec_flags
& SEC_ALLOC
) != 0)
1567 /* Try for a rw code section. */
1568 for (look
= first
; look
; look
= look
->next
)
1570 look_flags
= look
->flags
;
1571 if (look
->bfd_section
!= NULL
)
1573 look_flags
= look
->bfd_section
->flags
;
1574 if (match_type
&& !match_type (link_info
.output_bfd
,
1579 differ
= look_flags
^ sec_flags
;
1580 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1581 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1585 else if ((sec_flags
& SEC_READONLY
) != 0
1586 && (sec_flags
& SEC_ALLOC
) != 0)
1588 /* .rodata can go after .text, .sdata2 after .rodata. */
1589 for (look
= first
; look
; look
= look
->next
)
1591 look_flags
= look
->flags
;
1592 if (look
->bfd_section
!= NULL
)
1594 look_flags
= look
->bfd_section
->flags
;
1595 if (match_type
&& !match_type (link_info
.output_bfd
,
1600 differ
= look_flags
^ sec_flags
;
1601 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1602 | SEC_READONLY
| SEC_SMALL_DATA
))
1603 || (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1605 && !(look_flags
& SEC_SMALL_DATA
)))
1609 else if ((sec_flags
& SEC_THREAD_LOCAL
) != 0
1610 && (sec_flags
& SEC_ALLOC
) != 0)
1612 /* .tdata can go after .data, .tbss after .tdata. Treat .tbss
1613 as if it were a loaded section, and don't use match_type. */
1614 bfd_boolean seen_thread_local
= FALSE
;
1617 for (look
= first
; look
; look
= look
->next
)
1619 look_flags
= look
->flags
;
1620 if (look
->bfd_section
!= NULL
)
1621 look_flags
= look
->bfd_section
->flags
;
1623 differ
= look_flags
^ (sec_flags
| SEC_LOAD
| SEC_HAS_CONTENTS
);
1624 if (!(differ
& (SEC_THREAD_LOCAL
| SEC_ALLOC
)))
1626 /* .tdata and .tbss must be adjacent and in that order. */
1627 if (!(look_flags
& SEC_LOAD
)
1628 && (sec_flags
& SEC_LOAD
))
1629 /* ..so if we're at a .tbss section and we're placing
1630 a .tdata section stop looking and return the
1631 previous section. */
1634 seen_thread_local
= TRUE
;
1636 else if (seen_thread_local
)
1638 else if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
)))
1642 else if ((sec_flags
& SEC_SMALL_DATA
) != 0
1643 && (sec_flags
& SEC_ALLOC
) != 0)
1645 /* .sdata goes after .data, .sbss after .sdata. */
1646 for (look
= first
; look
; look
= look
->next
)
1648 look_flags
= look
->flags
;
1649 if (look
->bfd_section
!= NULL
)
1651 look_flags
= look
->bfd_section
->flags
;
1652 if (match_type
&& !match_type (link_info
.output_bfd
,
1657 differ
= look_flags
^ sec_flags
;
1658 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1659 | SEC_THREAD_LOCAL
))
1660 || ((look_flags
& SEC_SMALL_DATA
)
1661 && !(sec_flags
& SEC_HAS_CONTENTS
)))
1665 else if ((sec_flags
& SEC_HAS_CONTENTS
) != 0
1666 && (sec_flags
& SEC_ALLOC
) != 0)
1668 /* .data goes after .rodata. */
1669 for (look
= first
; look
; look
= look
->next
)
1671 look_flags
= look
->flags
;
1672 if (look
->bfd_section
!= NULL
)
1674 look_flags
= look
->bfd_section
->flags
;
1675 if (match_type
&& !match_type (link_info
.output_bfd
,
1680 differ
= look_flags
^ sec_flags
;
1681 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1682 | SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1686 else if ((sec_flags
& SEC_ALLOC
) != 0)
1688 /* .bss goes after any other alloc section. */
1689 for (look
= first
; look
; look
= look
->next
)
1691 look_flags
= look
->flags
;
1692 if (look
->bfd_section
!= NULL
)
1694 look_flags
= look
->bfd_section
->flags
;
1695 if (match_type
&& !match_type (link_info
.output_bfd
,
1700 differ
= look_flags
^ sec_flags
;
1701 if (!(differ
& SEC_ALLOC
))
1707 /* non-alloc go last. */
1708 for (look
= first
; look
; look
= look
->next
)
1710 look_flags
= look
->flags
;
1711 if (look
->bfd_section
!= NULL
)
1712 look_flags
= look
->bfd_section
->flags
;
1713 differ
= look_flags
^ sec_flags
;
1714 if (!(differ
& SEC_DEBUGGING
))
1720 if (found
|| !match_type
)
1723 return lang_output_section_find_by_flags (sec
, sec_flags
, NULL
, NULL
);
1726 /* Find the last output section before given output statement.
1727 Used by place_orphan. */
1730 output_prev_sec_find (lang_output_section_statement_type
*os
)
1732 lang_output_section_statement_type
*lookup
;
1734 for (lookup
= os
->prev
; lookup
!= NULL
; lookup
= lookup
->prev
)
1736 if (lookup
->constraint
< 0)
1739 if (lookup
->bfd_section
!= NULL
&& lookup
->bfd_section
->owner
!= NULL
)
1740 return lookup
->bfd_section
;
1746 /* Look for a suitable place for a new output section statement. The
1747 idea is to skip over anything that might be inside a SECTIONS {}
1748 statement in a script, before we find another output section
1749 statement. Assignments to "dot" before an output section statement
1750 are assumed to belong to it, except in two cases; The first
1751 assignment to dot, and assignments before non-alloc sections.
1752 Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
1753 similar assignments that set the initial address, or we might
1754 insert non-alloc note sections among assignments setting end of
1757 static lang_statement_union_type
**
1758 insert_os_after (lang_output_section_statement_type
*after
)
1760 lang_statement_union_type
**where
;
1761 lang_statement_union_type
**assign
= NULL
;
1762 bfd_boolean ignore_first
;
1765 = after
== &lang_output_section_statement
.head
->output_section_statement
;
1767 for (where
= &after
->header
.next
;
1769 where
= &(*where
)->header
.next
)
1771 switch ((*where
)->header
.type
)
1773 case lang_assignment_statement_enum
:
1776 lang_assignment_statement_type
*ass
;
1778 ass
= &(*where
)->assignment_statement
;
1779 if (ass
->exp
->type
.node_class
!= etree_assert
1780 && ass
->exp
->assign
.dst
[0] == '.'
1781 && ass
->exp
->assign
.dst
[1] == 0
1785 ignore_first
= FALSE
;
1787 case lang_wild_statement_enum
:
1788 case lang_input_section_enum
:
1789 case lang_object_symbols_statement_enum
:
1790 case lang_fill_statement_enum
:
1791 case lang_data_statement_enum
:
1792 case lang_reloc_statement_enum
:
1793 case lang_padding_statement_enum
:
1794 case lang_constructors_statement_enum
:
1797 case lang_output_section_statement_enum
:
1800 asection
*s
= (*where
)->output_section_statement
.bfd_section
;
1803 || s
->map_head
.s
== NULL
1804 || (s
->flags
& SEC_ALLOC
) != 0)
1808 case lang_input_statement_enum
:
1809 case lang_address_statement_enum
:
1810 case lang_target_statement_enum
:
1811 case lang_output_statement_enum
:
1812 case lang_group_statement_enum
:
1813 case lang_insert_statement_enum
:
1822 lang_output_section_statement_type
*
1823 lang_insert_orphan (asection
*s
,
1824 const char *secname
,
1826 lang_output_section_statement_type
*after
,
1827 struct orphan_save
*place
,
1828 etree_type
*address
,
1829 lang_statement_list_type
*add_child
)
1831 lang_statement_list_type add
;
1832 lang_output_section_statement_type
*os
;
1833 lang_output_section_statement_type
**os_tail
;
1835 /* If we have found an appropriate place for the output section
1836 statements for this orphan, add them to our own private list,
1837 inserting them later into the global statement list. */
1840 lang_list_init (&add
);
1841 push_stat_ptr (&add
);
1844 if (bfd_link_relocatable (&link_info
)
1845 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
1846 address
= exp_intop (0);
1848 os_tail
= ((lang_output_section_statement_type
**)
1849 lang_output_section_statement
.tail
);
1850 os
= lang_enter_output_section_statement (secname
, address
, normal_section
,
1851 NULL
, NULL
, NULL
, constraint
, 0);
1853 if (add_child
== NULL
)
1854 add_child
= &os
->children
;
1855 lang_add_section (add_child
, s
, NULL
, os
);
1857 if (after
&& (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) != 0)
1859 const char *region
= (after
->region
1860 ? after
->region
->name_list
.name
1861 : DEFAULT_MEMORY_REGION
);
1862 const char *lma_region
= (after
->lma_region
1863 ? after
->lma_region
->name_list
.name
1865 lang_leave_output_section_statement (NULL
, region
, after
->phdrs
,
1869 lang_leave_output_section_statement (NULL
, DEFAULT_MEMORY_REGION
, NULL
,
1872 /* Restore the global list pointer. */
1876 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
1878 asection
*snew
, *as
;
1880 snew
= os
->bfd_section
;
1882 /* Shuffle the bfd section list to make the output file look
1883 neater. This is really only cosmetic. */
1884 if (place
->section
== NULL
1885 && after
!= (&lang_output_section_statement
.head
1886 ->output_section_statement
))
1888 asection
*bfd_section
= after
->bfd_section
;
1890 /* If the output statement hasn't been used to place any input
1891 sections (and thus doesn't have an output bfd_section),
1892 look for the closest prior output statement having an
1894 if (bfd_section
== NULL
)
1895 bfd_section
= output_prev_sec_find (after
);
1897 if (bfd_section
!= NULL
&& bfd_section
!= snew
)
1898 place
->section
= &bfd_section
->next
;
1901 if (place
->section
== NULL
)
1902 place
->section
= &link_info
.output_bfd
->sections
;
1904 as
= *place
->section
;
1908 /* Put the section at the end of the list. */
1910 /* Unlink the section. */
1911 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1913 /* Now tack it back on in the right place. */
1914 bfd_section_list_append (link_info
.output_bfd
, snew
);
1916 else if (as
!= snew
&& as
->prev
!= snew
)
1918 /* Unlink the section. */
1919 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1921 /* Now tack it back on in the right place. */
1922 bfd_section_list_insert_before (link_info
.output_bfd
, as
, snew
);
1925 /* Save the end of this list. Further ophans of this type will
1926 follow the one we've just added. */
1927 place
->section
= &snew
->next
;
1929 /* The following is non-cosmetic. We try to put the output
1930 statements in some sort of reasonable order here, because they
1931 determine the final load addresses of the orphan sections.
1932 In addition, placing output statements in the wrong order may
1933 require extra segments. For instance, given a typical
1934 situation of all read-only sections placed in one segment and
1935 following that a segment containing all the read-write
1936 sections, we wouldn't want to place an orphan read/write
1937 section before or amongst the read-only ones. */
1938 if (add
.head
!= NULL
)
1940 lang_output_section_statement_type
*newly_added_os
;
1942 if (place
->stmt
== NULL
)
1944 lang_statement_union_type
**where
= insert_os_after (after
);
1949 place
->os_tail
= &after
->next
;
1953 /* Put it after the last orphan statement we added. */
1954 *add
.tail
= *place
->stmt
;
1955 *place
->stmt
= add
.head
;
1958 /* Fix the global list pointer if we happened to tack our
1959 new list at the tail. */
1960 if (*stat_ptr
->tail
== add
.head
)
1961 stat_ptr
->tail
= add
.tail
;
1963 /* Save the end of this list. */
1964 place
->stmt
= add
.tail
;
1966 /* Do the same for the list of output section statements. */
1967 newly_added_os
= *os_tail
;
1969 newly_added_os
->prev
= (lang_output_section_statement_type
*)
1970 ((char *) place
->os_tail
1971 - offsetof (lang_output_section_statement_type
, next
));
1972 newly_added_os
->next
= *place
->os_tail
;
1973 if (newly_added_os
->next
!= NULL
)
1974 newly_added_os
->next
->prev
= newly_added_os
;
1975 *place
->os_tail
= newly_added_os
;
1976 place
->os_tail
= &newly_added_os
->next
;
1978 /* Fixing the global list pointer here is a little different.
1979 We added to the list in lang_enter_output_section_statement,
1980 trimmed off the new output_section_statment above when
1981 assigning *os_tail = NULL, but possibly added it back in
1982 the same place when assigning *place->os_tail. */
1983 if (*os_tail
== NULL
)
1984 lang_output_section_statement
.tail
1985 = (lang_statement_union_type
**) os_tail
;
1992 lang_print_asneeded (void)
1994 struct asneeded_minfo
*m
;
1996 if (asneeded_list_head
== NULL
)
1999 minfo (_("\nAs-needed library included to satisfy reference by file (symbol)\n\n"));
2001 for (m
= asneeded_list_head
; m
!= NULL
; m
= m
->next
)
2005 minfo ("%s", m
->soname
);
2006 len
= strlen (m
->soname
);
2020 minfo ("%B ", m
->ref
);
2021 minfo ("(%T)\n", m
->name
);
2026 lang_map_flags (flagword flag
)
2028 if (flag
& SEC_ALLOC
)
2031 if (flag
& SEC_CODE
)
2034 if (flag
& SEC_READONLY
)
2037 if (flag
& SEC_DATA
)
2040 if (flag
& SEC_LOAD
)
2047 lang_memory_region_type
*m
;
2048 bfd_boolean dis_header_printed
= FALSE
;
2050 LANG_FOR_EACH_INPUT_STATEMENT (file
)
2054 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
2055 || file
->flags
.just_syms
)
2058 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2059 if ((s
->output_section
== NULL
2060 || s
->output_section
->owner
!= link_info
.output_bfd
)
2061 && (s
->flags
& (SEC_LINKER_CREATED
| SEC_KEEP
)) == 0)
2063 if (!dis_header_printed
)
2065 fprintf (config
.map_file
, _("\nDiscarded input sections\n\n"));
2066 dis_header_printed
= TRUE
;
2069 print_input_section (s
, TRUE
);
2073 minfo (_("\nMemory Configuration\n\n"));
2074 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
2075 _("Name"), _("Origin"), _("Length"), _("Attributes"));
2077 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
2082 fprintf (config
.map_file
, "%-16s ", m
->name_list
.name
);
2084 sprintf_vma (buf
, m
->origin
);
2085 minfo ("0x%s ", buf
);
2093 minfo ("0x%V", m
->length
);
2094 if (m
->flags
|| m
->not_flags
)
2102 lang_map_flags (m
->flags
);
2108 lang_map_flags (m
->not_flags
);
2115 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
2117 if (!link_info
.reduce_memory_overheads
)
2119 obstack_begin (&map_obstack
, 1000);
2120 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
2122 lang_statement_iteration
++;
2123 print_statements ();
2125 ldemul_extra_map_file_text (link_info
.output_bfd
, &link_info
,
2130 sort_def_symbol (struct bfd_link_hash_entry
*hash_entry
,
2131 void *info ATTRIBUTE_UNUSED
)
2133 if ((hash_entry
->type
== bfd_link_hash_defined
2134 || hash_entry
->type
== bfd_link_hash_defweak
)
2135 && hash_entry
->u
.def
.section
->owner
!= link_info
.output_bfd
2136 && hash_entry
->u
.def
.section
->owner
!= NULL
)
2138 input_section_userdata_type
*ud
;
2139 struct map_symbol_def
*def
;
2141 ud
= ((input_section_userdata_type
*)
2142 get_userdata (hash_entry
->u
.def
.section
));
2145 ud
= (input_section_userdata_type
*) stat_alloc (sizeof (*ud
));
2146 get_userdata (hash_entry
->u
.def
.section
) = ud
;
2147 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2148 ud
->map_symbol_def_count
= 0;
2150 else if (!ud
->map_symbol_def_tail
)
2151 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2153 def
= (struct map_symbol_def
*) obstack_alloc (&map_obstack
, sizeof *def
);
2154 def
->entry
= hash_entry
;
2155 *(ud
->map_symbol_def_tail
) = def
;
2156 ud
->map_symbol_def_tail
= &def
->next
;
2157 ud
->map_symbol_def_count
++;
2162 /* Initialize an output section. */
2165 init_os (lang_output_section_statement_type
*s
, flagword flags
)
2167 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
2168 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
2170 if (s
->constraint
!= SPECIAL
)
2171 s
->bfd_section
= bfd_get_section_by_name (link_info
.output_bfd
, s
->name
);
2172 if (s
->bfd_section
== NULL
)
2173 s
->bfd_section
= bfd_make_section_anyway_with_flags (link_info
.output_bfd
,
2175 if (s
->bfd_section
== NULL
)
2177 einfo (_("%P%F: output format %s cannot represent section"
2178 " called %s: %E\n"),
2179 link_info
.output_bfd
->xvec
->name
, s
->name
);
2181 s
->bfd_section
->output_section
= s
->bfd_section
;
2182 s
->bfd_section
->output_offset
= 0;
2184 /* Set the userdata of the output section to the output section
2185 statement to avoid lookup. */
2186 get_userdata (s
->bfd_section
) = s
;
2188 /* If there is a base address, make sure that any sections it might
2189 mention are initialized. */
2190 if (s
->addr_tree
!= NULL
)
2191 exp_init_os (s
->addr_tree
);
2193 if (s
->load_base
!= NULL
)
2194 exp_init_os (s
->load_base
);
2196 /* If supplied an alignment, set it. */
2197 if (s
->section_alignment
!= -1)
2198 s
->bfd_section
->alignment_power
= s
->section_alignment
;
2201 /* Make sure that all output sections mentioned in an expression are
2205 exp_init_os (etree_type
*exp
)
2207 switch (exp
->type
.node_class
)
2211 exp_init_os (exp
->assign
.src
);
2215 exp_init_os (exp
->binary
.lhs
);
2216 exp_init_os (exp
->binary
.rhs
);
2220 exp_init_os (exp
->trinary
.cond
);
2221 exp_init_os (exp
->trinary
.lhs
);
2222 exp_init_os (exp
->trinary
.rhs
);
2226 exp_init_os (exp
->assert_s
.child
);
2230 exp_init_os (exp
->unary
.child
);
2234 switch (exp
->type
.node_code
)
2240 lang_output_section_statement_type
*os
;
2242 os
= lang_output_section_find (exp
->name
.name
);
2243 if (os
!= NULL
&& os
->bfd_section
== NULL
)
2255 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
2257 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
2259 /* If we are only reading symbols from this object, then we want to
2260 discard all sections. */
2261 if (entry
->flags
.just_syms
)
2263 bfd_link_just_syms (abfd
, sec
, &link_info
);
2267 /* Deal with SHF_EXCLUDE ELF sections. */
2268 if (!bfd_link_relocatable (&link_info
)
2269 && (abfd
->flags
& BFD_PLUGIN
) == 0
2270 && (sec
->flags
& (SEC_GROUP
| SEC_KEEP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
2271 sec
->output_section
= bfd_abs_section_ptr
;
2273 if (!(abfd
->flags
& DYNAMIC
))
2274 bfd_section_already_linked (abfd
, sec
, &link_info
);
2277 /* The wild routines.
2279 These expand statements like *(.text) and foo.o to a list of
2280 explicit actions, like foo.o(.text), bar.o(.text) and
2281 foo.o(.text, .data). */
2283 /* Add SECTION to the output section OUTPUT. Do this by creating a
2284 lang_input_section statement which is placed at PTR. */
2287 lang_add_section (lang_statement_list_type
*ptr
,
2289 struct flag_info
*sflag_info
,
2290 lang_output_section_statement_type
*output
)
2292 flagword flags
= section
->flags
;
2294 bfd_boolean discard
;
2295 lang_input_section_type
*new_section
;
2296 bfd
*abfd
= link_info
.output_bfd
;
2298 /* Discard sections marked with SEC_EXCLUDE. */
2299 discard
= (flags
& SEC_EXCLUDE
) != 0;
2301 /* Discard input sections which are assigned to a section named
2302 DISCARD_SECTION_NAME. */
2303 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
2306 /* Discard the group descriptor sections when we're finally placing the
2307 sections from within the group. */
2308 if ((section
->flags
& SEC_GROUP
) == SEC_GROUP
2309 && link_info
.resolve_section_groups
)
2312 /* Discard debugging sections if we are stripping debugging
2314 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
2315 && (flags
& SEC_DEBUGGING
) != 0)
2320 if (section
->output_section
== NULL
)
2322 /* This prevents future calls from assigning this section. */
2323 section
->output_section
= bfd_abs_section_ptr
;
2332 keep
= bfd_lookup_section_flags (&link_info
, sflag_info
, section
);
2337 if (section
->output_section
!= NULL
)
2340 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2341 to an output section, because we want to be able to include a
2342 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2343 section (I don't know why we want to do this, but we do).
2344 build_link_order in ldwrite.c handles this case by turning
2345 the embedded SEC_NEVER_LOAD section into a fill. */
2346 flags
&= ~ SEC_NEVER_LOAD
;
2348 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2349 already been processed. One reason to do this is that on pe
2350 format targets, .text$foo sections go into .text and it's odd
2351 to see .text with SEC_LINK_ONCE set. */
2352 if ((flags
& (SEC_LINK_ONCE
| SEC_GROUP
)) == (SEC_LINK_ONCE
| SEC_GROUP
))
2354 if (link_info
.resolve_section_groups
)
2355 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2357 flags
&= ~(SEC_LINK_DUPLICATES
| SEC_RELOC
);
2359 else if (!bfd_link_relocatable (&link_info
))
2360 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2362 switch (output
->sectype
)
2364 case normal_section
:
2365 case overlay_section
:
2367 case noalloc_section
:
2368 flags
&= ~SEC_ALLOC
;
2370 case noload_section
:
2372 flags
|= SEC_NEVER_LOAD
;
2373 /* Unfortunately GNU ld has managed to evolve two different
2374 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2375 alloc, no contents section. All others get a noload, noalloc
2377 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
2378 flags
&= ~SEC_HAS_CONTENTS
;
2380 flags
&= ~SEC_ALLOC
;
2384 if (output
->bfd_section
== NULL
)
2385 init_os (output
, flags
);
2387 /* If SEC_READONLY is not set in the input section, then clear
2388 it from the output section. */
2389 output
->bfd_section
->flags
&= flags
| ~SEC_READONLY
;
2391 if (output
->bfd_section
->linker_has_input
)
2393 /* Only set SEC_READONLY flag on the first input section. */
2394 flags
&= ~ SEC_READONLY
;
2396 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2397 if ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2398 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2399 || ((flags
& SEC_MERGE
) != 0
2400 && output
->bfd_section
->entsize
!= section
->entsize
))
2402 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2403 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2406 output
->bfd_section
->flags
|= flags
;
2408 if (!output
->bfd_section
->linker_has_input
)
2410 output
->bfd_section
->linker_has_input
= 1;
2411 /* This must happen after flags have been updated. The output
2412 section may have been created before we saw its first input
2413 section, eg. for a data statement. */
2414 bfd_init_private_section_data (section
->owner
, section
,
2415 link_info
.output_bfd
,
2416 output
->bfd_section
,
2418 if ((flags
& SEC_MERGE
) != 0)
2419 output
->bfd_section
->entsize
= section
->entsize
;
2422 if ((flags
& SEC_TIC54X_BLOCK
) != 0
2423 && bfd_get_arch (section
->owner
) == bfd_arch_tic54x
)
2425 /* FIXME: This value should really be obtained from the bfd... */
2426 output
->block_value
= 128;
2429 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2430 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2432 section
->output_section
= output
->bfd_section
;
2434 if (!map_head_is_link_order
)
2436 asection
*s
= output
->bfd_section
->map_tail
.s
;
2437 output
->bfd_section
->map_tail
.s
= section
;
2438 section
->map_head
.s
= NULL
;
2439 section
->map_tail
.s
= s
;
2441 s
->map_head
.s
= section
;
2443 output
->bfd_section
->map_head
.s
= section
;
2446 /* Add a section reference to the list. */
2447 new_section
= new_stat (lang_input_section
, ptr
);
2448 new_section
->section
= section
;
2451 /* Handle wildcard sorting. This returns the lang_input_section which
2452 should follow the one we are going to create for SECTION and FILE,
2453 based on the sorting requirements of WILD. It returns NULL if the
2454 new section should just go at the end of the current list. */
2456 static lang_statement_union_type
*
2457 wild_sort (lang_wild_statement_type
*wild
,
2458 struct wildcard_list
*sec
,
2459 lang_input_statement_type
*file
,
2462 lang_statement_union_type
*l
;
2464 if (!wild
->filenames_sorted
2465 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
2468 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
2470 lang_input_section_type
*ls
;
2472 if (l
->header
.type
!= lang_input_section_enum
)
2474 ls
= &l
->input_section
;
2476 /* Sorting by filename takes precedence over sorting by section
2479 if (wild
->filenames_sorted
)
2481 const char *fn
, *ln
;
2485 /* The PE support for the .idata section as generated by
2486 dlltool assumes that files will be sorted by the name of
2487 the archive and then the name of the file within the
2490 if (file
->the_bfd
!= NULL
2491 && file
->the_bfd
->my_archive
!= NULL
)
2493 fn
= bfd_get_filename (file
->the_bfd
->my_archive
);
2498 fn
= file
->filename
;
2502 if (ls
->section
->owner
->my_archive
!= NULL
)
2504 ln
= bfd_get_filename (ls
->section
->owner
->my_archive
);
2509 ln
= ls
->section
->owner
->filename
;
2513 i
= filename_cmp (fn
, ln
);
2522 fn
= file
->filename
;
2524 ln
= ls
->section
->owner
->filename
;
2526 i
= filename_cmp (fn
, ln
);
2534 /* Here either the files are not sorted by name, or we are
2535 looking at the sections for this file. */
2538 && sec
->spec
.sorted
!= none
2539 && sec
->spec
.sorted
!= by_none
)
2540 if (compare_section (sec
->spec
.sorted
, section
, ls
->section
) < 0)
2547 /* Expand a wild statement for a particular FILE. SECTION may be
2548 NULL, in which case it is a wild card. */
2551 output_section_callback (lang_wild_statement_type
*ptr
,
2552 struct wildcard_list
*sec
,
2554 struct flag_info
*sflag_info
,
2555 lang_input_statement_type
*file
,
2558 lang_statement_union_type
*before
;
2559 lang_output_section_statement_type
*os
;
2561 os
= (lang_output_section_statement_type
*) output
;
2563 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2564 if (unique_section_p (section
, os
))
2567 before
= wild_sort (ptr
, sec
, file
, section
);
2569 /* Here BEFORE points to the lang_input_section which
2570 should follow the one we are about to add. If BEFORE
2571 is NULL, then the section should just go at the end
2572 of the current list. */
2575 lang_add_section (&ptr
->children
, section
, sflag_info
, os
);
2578 lang_statement_list_type list
;
2579 lang_statement_union_type
**pp
;
2581 lang_list_init (&list
);
2582 lang_add_section (&list
, section
, sflag_info
, os
);
2584 /* If we are discarding the section, LIST.HEAD will
2586 if (list
.head
!= NULL
)
2588 ASSERT (list
.head
->header
.next
== NULL
);
2590 for (pp
= &ptr
->children
.head
;
2592 pp
= &(*pp
)->header
.next
)
2593 ASSERT (*pp
!= NULL
);
2595 list
.head
->header
.next
= *pp
;
2601 /* Check if all sections in a wild statement for a particular FILE
2605 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2606 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2608 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
2609 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2612 lang_output_section_statement_type
*os
;
2614 os
= (lang_output_section_statement_type
*) output
;
2616 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2617 if (unique_section_p (section
, os
))
2620 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2621 os
->all_input_readonly
= FALSE
;
2624 /* This is passed a file name which must have been seen already and
2625 added to the statement tree. We will see if it has been opened
2626 already and had its symbols read. If not then we'll read it. */
2628 static lang_input_statement_type
*
2629 lookup_name (const char *name
)
2631 lang_input_statement_type
*search
;
2633 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
2635 search
= (lang_input_statement_type
*) search
->next_real_file
)
2637 /* Use the local_sym_name as the name of the file that has
2638 already been loaded as filename might have been transformed
2639 via the search directory lookup mechanism. */
2640 const char *filename
= search
->local_sym_name
;
2642 if (filename
!= NULL
2643 && filename_cmp (filename
, name
) == 0)
2648 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2649 default_target
, FALSE
);
2651 /* If we have already added this file, or this file is not real
2652 don't add this file. */
2653 if (search
->flags
.loaded
|| !search
->flags
.real
)
2656 if (!load_symbols (search
, NULL
))
2662 /* Save LIST as a list of libraries whose symbols should not be exported. */
2667 struct excluded_lib
*next
;
2669 static struct excluded_lib
*excluded_libs
;
2672 add_excluded_libs (const char *list
)
2674 const char *p
= list
, *end
;
2678 struct excluded_lib
*entry
;
2679 end
= strpbrk (p
, ",:");
2681 end
= p
+ strlen (p
);
2682 entry
= (struct excluded_lib
*) xmalloc (sizeof (*entry
));
2683 entry
->next
= excluded_libs
;
2684 entry
->name
= (char *) xmalloc (end
- p
+ 1);
2685 memcpy (entry
->name
, p
, end
- p
);
2686 entry
->name
[end
- p
] = '\0';
2687 excluded_libs
= entry
;
2695 check_excluded_libs (bfd
*abfd
)
2697 struct excluded_lib
*lib
= excluded_libs
;
2701 int len
= strlen (lib
->name
);
2702 const char *filename
= lbasename (abfd
->filename
);
2704 if (strcmp (lib
->name
, "ALL") == 0)
2706 abfd
->no_export
= TRUE
;
2710 if (filename_ncmp (lib
->name
, filename
, len
) == 0
2711 && (filename
[len
] == '\0'
2712 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
2713 && filename
[len
+ 2] == '\0')))
2715 abfd
->no_export
= TRUE
;
2723 /* Get the symbols for an input file. */
2726 load_symbols (lang_input_statement_type
*entry
,
2727 lang_statement_list_type
*place
)
2731 if (entry
->flags
.loaded
)
2734 ldfile_open_file (entry
);
2736 /* Do not process further if the file was missing. */
2737 if (entry
->flags
.missing_file
)
2740 if (!bfd_check_format (entry
->the_bfd
, bfd_archive
)
2741 && !bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
2744 struct lang_input_statement_flags save_flags
;
2747 err
= bfd_get_error ();
2749 /* See if the emulation has some special knowledge. */
2750 if (ldemul_unrecognized_file (entry
))
2753 if (err
== bfd_error_file_ambiguously_recognized
)
2757 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
2758 einfo (_("%B: matching formats:"), entry
->the_bfd
);
2759 for (p
= matching
; *p
!= NULL
; p
++)
2763 else if (err
!= bfd_error_file_not_recognized
2765 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
2767 bfd_close (entry
->the_bfd
);
2768 entry
->the_bfd
= NULL
;
2770 /* Try to interpret the file as a linker script. */
2771 save_flags
= input_flags
;
2772 ldfile_open_command_file (entry
->filename
);
2774 push_stat_ptr (place
);
2775 input_flags
.add_DT_NEEDED_for_regular
2776 = entry
->flags
.add_DT_NEEDED_for_regular
;
2777 input_flags
.add_DT_NEEDED_for_dynamic
2778 = entry
->flags
.add_DT_NEEDED_for_dynamic
;
2779 input_flags
.whole_archive
= entry
->flags
.whole_archive
;
2780 input_flags
.dynamic
= entry
->flags
.dynamic
;
2782 ldfile_assumed_script
= TRUE
;
2783 parser_input
= input_script
;
2785 ldfile_assumed_script
= FALSE
;
2787 /* missing_file is sticky. sysrooted will already have been
2788 restored when seeing EOF in yyparse, but no harm to restore
2790 save_flags
.missing_file
|= input_flags
.missing_file
;
2791 input_flags
= save_flags
;
2795 entry
->flags
.loaded
= TRUE
;
2800 if (ldemul_recognized_file (entry
))
2803 /* We don't call ldlang_add_file for an archive. Instead, the
2804 add_symbols entry point will call ldlang_add_file, via the
2805 add_archive_element callback, for each element of the archive
2807 switch (bfd_get_format (entry
->the_bfd
))
2813 if (!entry
->flags
.reload
)
2814 ldlang_add_file (entry
);
2815 if (trace_files
|| verbose
)
2816 info_msg ("%I\n", entry
);
2820 check_excluded_libs (entry
->the_bfd
);
2822 if (entry
->flags
.whole_archive
)
2825 bfd_boolean loaded
= TRUE
;
2830 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
2835 if (!bfd_check_format (member
, bfd_object
))
2837 einfo (_("%F%B: member %B in archive is not an object\n"),
2838 entry
->the_bfd
, member
);
2843 if (!(*link_info
.callbacks
2844 ->add_archive_element
) (&link_info
, member
,
2845 "--whole-archive", &subsbfd
))
2848 /* Potentially, the add_archive_element hook may have set a
2849 substitute BFD for us. */
2850 if (!bfd_link_add_symbols (subsbfd
, &link_info
))
2852 einfo (_("%F%B: error adding symbols: %E\n"), member
);
2857 entry
->flags
.loaded
= loaded
;
2863 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
2864 entry
->flags
.loaded
= TRUE
;
2866 einfo (_("%F%B: error adding symbols: %E\n"), entry
->the_bfd
);
2868 return entry
->flags
.loaded
;
2871 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
2872 may be NULL, indicating that it is a wildcard. Separate
2873 lang_input_section statements are created for each part of the
2874 expansion; they are added after the wild statement S. OUTPUT is
2875 the output section. */
2878 wild (lang_wild_statement_type
*s
,
2879 const char *target ATTRIBUTE_UNUSED
,
2880 lang_output_section_statement_type
*output
)
2882 struct wildcard_list
*sec
;
2884 if (s
->handler_data
[0]
2885 && s
->handler_data
[0]->spec
.sorted
== by_name
2886 && !s
->filenames_sorted
)
2888 lang_section_bst_type
*tree
;
2890 walk_wild (s
, output_section_callback_fast
, output
);
2895 output_section_callback_tree_to_list (s
, tree
, output
);
2900 walk_wild (s
, output_section_callback
, output
);
2902 if (default_common_section
== NULL
)
2903 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
2904 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
2906 /* Remember the section that common is going to in case we
2907 later get something which doesn't know where to put it. */
2908 default_common_section
= output
;
2913 /* Return TRUE iff target is the sought target. */
2916 get_target (const bfd_target
*target
, void *data
)
2918 const char *sought
= (const char *) data
;
2920 return strcmp (target
->name
, sought
) == 0;
2923 /* Like strcpy() but convert to lower case as well. */
2926 stricpy (char *dest
, char *src
)
2930 while ((c
= *src
++) != 0)
2931 *dest
++ = TOLOWER (c
);
2936 /* Remove the first occurrence of needle (if any) in haystack
2940 strcut (char *haystack
, char *needle
)
2942 haystack
= strstr (haystack
, needle
);
2948 for (src
= haystack
+ strlen (needle
); *src
;)
2949 *haystack
++ = *src
++;
2955 /* Compare two target format name strings.
2956 Return a value indicating how "similar" they are. */
2959 name_compare (char *first
, char *second
)
2965 copy1
= (char *) xmalloc (strlen (first
) + 1);
2966 copy2
= (char *) xmalloc (strlen (second
) + 1);
2968 /* Convert the names to lower case. */
2969 stricpy (copy1
, first
);
2970 stricpy (copy2
, second
);
2972 /* Remove size and endian strings from the name. */
2973 strcut (copy1
, "big");
2974 strcut (copy1
, "little");
2975 strcut (copy2
, "big");
2976 strcut (copy2
, "little");
2978 /* Return a value based on how many characters match,
2979 starting from the beginning. If both strings are
2980 the same then return 10 * their length. */
2981 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
2982 if (copy1
[result
] == 0)
2994 /* Set by closest_target_match() below. */
2995 static const bfd_target
*winner
;
2997 /* Scan all the valid bfd targets looking for one that has the endianness
2998 requirement that was specified on the command line, and is the nearest
2999 match to the original output target. */
3002 closest_target_match (const bfd_target
*target
, void *data
)
3004 const bfd_target
*original
= (const bfd_target
*) data
;
3006 if (command_line
.endian
== ENDIAN_BIG
3007 && target
->byteorder
!= BFD_ENDIAN_BIG
)
3010 if (command_line
.endian
== ENDIAN_LITTLE
3011 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
3014 /* Must be the same flavour. */
3015 if (target
->flavour
!= original
->flavour
)
3018 /* Ignore generic big and little endian elf vectors. */
3019 if (strcmp (target
->name
, "elf32-big") == 0
3020 || strcmp (target
->name
, "elf64-big") == 0
3021 || strcmp (target
->name
, "elf32-little") == 0
3022 || strcmp (target
->name
, "elf64-little") == 0)
3025 /* If we have not found a potential winner yet, then record this one. */
3032 /* Oh dear, we now have two potential candidates for a successful match.
3033 Compare their names and choose the better one. */
3034 if (name_compare (target
->name
, original
->name
)
3035 > name_compare (winner
->name
, original
->name
))
3038 /* Keep on searching until wqe have checked them all. */
3042 /* Return the BFD target format of the first input file. */
3045 get_first_input_target (void)
3047 char *target
= NULL
;
3049 LANG_FOR_EACH_INPUT_STATEMENT (s
)
3051 if (s
->header
.type
== lang_input_statement_enum
3054 ldfile_open_file (s
);
3056 if (s
->the_bfd
!= NULL
3057 && bfd_check_format (s
->the_bfd
, bfd_object
))
3059 target
= bfd_get_target (s
->the_bfd
);
3071 lang_get_output_target (void)
3075 /* Has the user told us which output format to use? */
3076 if (output_target
!= NULL
)
3077 return output_target
;
3079 /* No - has the current target been set to something other than
3081 if (current_target
!= default_target
&& current_target
!= NULL
)
3082 return current_target
;
3084 /* No - can we determine the format of the first input file? */
3085 target
= get_first_input_target ();
3089 /* Failed - use the default output target. */
3090 return default_target
;
3093 /* Open the output file. */
3096 open_output (const char *name
)
3098 output_target
= lang_get_output_target ();
3100 /* Has the user requested a particular endianness on the command
3102 if (command_line
.endian
!= ENDIAN_UNSET
)
3104 /* Get the chosen target. */
3105 const bfd_target
*target
3106 = bfd_iterate_over_targets (get_target
, (void *) output_target
);
3108 /* If the target is not supported, we cannot do anything. */
3111 enum bfd_endian desired_endian
;
3113 if (command_line
.endian
== ENDIAN_BIG
)
3114 desired_endian
= BFD_ENDIAN_BIG
;
3116 desired_endian
= BFD_ENDIAN_LITTLE
;
3118 /* See if the target has the wrong endianness. This should
3119 not happen if the linker script has provided big and
3120 little endian alternatives, but some scrips don't do
3122 if (target
->byteorder
!= desired_endian
)
3124 /* If it does, then see if the target provides
3125 an alternative with the correct endianness. */
3126 if (target
->alternative_target
!= NULL
3127 && (target
->alternative_target
->byteorder
== desired_endian
))
3128 output_target
= target
->alternative_target
->name
;
3131 /* Try to find a target as similar as possible to
3132 the default target, but which has the desired
3133 endian characteristic. */
3134 bfd_iterate_over_targets (closest_target_match
,
3137 /* Oh dear - we could not find any targets that
3138 satisfy our requirements. */
3140 einfo (_("%P: warning: could not find any targets"
3141 " that match endianness requirement\n"));
3143 output_target
= winner
->name
;
3149 link_info
.output_bfd
= bfd_openw (name
, output_target
);
3151 if (link_info
.output_bfd
== NULL
)
3153 if (bfd_get_error () == bfd_error_invalid_target
)
3154 einfo (_("%P%F: target %s not found\n"), output_target
);
3156 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
3159 delete_output_file_on_failure
= TRUE
;
3161 if (!bfd_set_format (link_info
.output_bfd
, bfd_object
))
3162 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
3163 if (!bfd_set_arch_mach (link_info
.output_bfd
,
3164 ldfile_output_architecture
,
3165 ldfile_output_machine
))
3166 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
3168 link_info
.hash
= bfd_link_hash_table_create (link_info
.output_bfd
);
3169 if (link_info
.hash
== NULL
)
3170 einfo (_("%P%F: can not create hash table: %E\n"));
3172 bfd_set_gp_size (link_info
.output_bfd
, g_switch_value
);
3176 ldlang_open_output (lang_statement_union_type
*statement
)
3178 switch (statement
->header
.type
)
3180 case lang_output_statement_enum
:
3181 ASSERT (link_info
.output_bfd
== NULL
);
3182 open_output (statement
->output_statement
.name
);
3183 ldemul_set_output_arch ();
3184 if (config
.magic_demand_paged
3185 && !bfd_link_relocatable (&link_info
))
3186 link_info
.output_bfd
->flags
|= D_PAGED
;
3188 link_info
.output_bfd
->flags
&= ~D_PAGED
;
3189 if (config
.text_read_only
)
3190 link_info
.output_bfd
->flags
|= WP_TEXT
;
3192 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
3193 if (link_info
.traditional_format
)
3194 link_info
.output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
3196 link_info
.output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
3199 case lang_target_statement_enum
:
3200 current_target
= statement
->target_statement
.target
;
3210 unsigned x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3211 ldfile_output_machine
);
3214 while ((x
& 1) == 0)
3222 /* Open all the input files. */
3226 OPEN_BFD_NORMAL
= 0,
3230 #ifdef ENABLE_PLUGINS
3231 static lang_input_statement_type
*plugin_insert
= NULL
;
3235 open_input_bfds (lang_statement_union_type
*s
, enum open_bfd_mode mode
)
3237 for (; s
!= NULL
; s
= s
->header
.next
)
3239 switch (s
->header
.type
)
3241 case lang_constructors_statement_enum
:
3242 open_input_bfds (constructor_list
.head
, mode
);
3244 case lang_output_section_statement_enum
:
3245 open_input_bfds (s
->output_section_statement
.children
.head
, mode
);
3247 case lang_wild_statement_enum
:
3248 /* Maybe we should load the file's symbols. */
3249 if ((mode
& OPEN_BFD_RESCAN
) == 0
3250 && s
->wild_statement
.filename
3251 && !wildcardp (s
->wild_statement
.filename
)
3252 && !archive_path (s
->wild_statement
.filename
))
3253 lookup_name (s
->wild_statement
.filename
);
3254 open_input_bfds (s
->wild_statement
.children
.head
, mode
);
3256 case lang_group_statement_enum
:
3258 struct bfd_link_hash_entry
*undefs
;
3260 /* We must continually search the entries in the group
3261 until no new symbols are added to the list of undefined
3266 undefs
= link_info
.hash
->undefs_tail
;
3267 open_input_bfds (s
->group_statement
.children
.head
,
3268 mode
| OPEN_BFD_FORCE
);
3270 while (undefs
!= link_info
.hash
->undefs_tail
);
3273 case lang_target_statement_enum
:
3274 current_target
= s
->target_statement
.target
;
3276 case lang_input_statement_enum
:
3277 if (s
->input_statement
.flags
.real
)
3279 lang_statement_union_type
**os_tail
;
3280 lang_statement_list_type add
;
3283 s
->input_statement
.target
= current_target
;
3285 /* If we are being called from within a group, and this
3286 is an archive which has already been searched, then
3287 force it to be researched unless the whole archive
3288 has been loaded already. Do the same for a rescan.
3289 Likewise reload --as-needed shared libs. */
3290 if (mode
!= OPEN_BFD_NORMAL
3291 #ifdef ENABLE_PLUGINS
3292 && ((mode
& OPEN_BFD_RESCAN
) == 0
3293 || plugin_insert
== NULL
)
3295 && s
->input_statement
.flags
.loaded
3296 && (abfd
= s
->input_statement
.the_bfd
) != NULL
3297 && ((bfd_get_format (abfd
) == bfd_archive
3298 && !s
->input_statement
.flags
.whole_archive
)
3299 || (bfd_get_format (abfd
) == bfd_object
3300 && ((abfd
->flags
) & DYNAMIC
) != 0
3301 && s
->input_statement
.flags
.add_DT_NEEDED_for_regular
3302 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3303 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)))
3305 s
->input_statement
.flags
.loaded
= FALSE
;
3306 s
->input_statement
.flags
.reload
= TRUE
;
3309 os_tail
= lang_output_section_statement
.tail
;
3310 lang_list_init (&add
);
3312 if (!load_symbols (&s
->input_statement
, &add
))
3313 config
.make_executable
= FALSE
;
3315 if (add
.head
!= NULL
)
3317 /* If this was a script with output sections then
3318 tack any added statements on to the end of the
3319 list. This avoids having to reorder the output
3320 section statement list. Very likely the user
3321 forgot -T, and whatever we do here will not meet
3322 naive user expectations. */
3323 if (os_tail
!= lang_output_section_statement
.tail
)
3325 einfo (_("%P: warning: %s contains output sections;"
3326 " did you forget -T?\n"),
3327 s
->input_statement
.filename
);
3328 *stat_ptr
->tail
= add
.head
;
3329 stat_ptr
->tail
= add
.tail
;
3333 *add
.tail
= s
->header
.next
;
3334 s
->header
.next
= add
.head
;
3338 #ifdef ENABLE_PLUGINS
3339 /* If we have found the point at which a plugin added new
3340 files, clear plugin_insert to enable archive rescan. */
3341 if (&s
->input_statement
== plugin_insert
)
3342 plugin_insert
= NULL
;
3345 case lang_assignment_statement_enum
:
3346 if (s
->assignment_statement
.exp
->type
.node_class
!= etree_assert
3347 && s
->assignment_statement
.exp
->assign
.defsym
)
3348 /* This is from a --defsym on the command line. */
3349 exp_fold_tree_no_dot (s
->assignment_statement
.exp
);
3356 /* Exit if any of the files were missing. */
3357 if (input_flags
.missing_file
)
3361 /* Add the supplied name to the symbol table as an undefined reference.
3362 This is a two step process as the symbol table doesn't even exist at
3363 the time the ld command line is processed. First we put the name
3364 on a list, then, once the output file has been opened, transfer the
3365 name to the symbol table. */
3367 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3369 #define ldlang_undef_chain_list_head entry_symbol.next
3372 ldlang_add_undef (const char *const name
, bfd_boolean cmdline
)
3374 ldlang_undef_chain_list_type
*new_undef
;
3376 undef_from_cmdline
= undef_from_cmdline
|| cmdline
;
3377 new_undef
= (ldlang_undef_chain_list_type
*) stat_alloc (sizeof (*new_undef
));
3378 new_undef
->next
= ldlang_undef_chain_list_head
;
3379 ldlang_undef_chain_list_head
= new_undef
;
3381 new_undef
->name
= xstrdup (name
);
3383 if (link_info
.output_bfd
!= NULL
)
3384 insert_undefined (new_undef
->name
);
3387 /* Insert NAME as undefined in the symbol table. */
3390 insert_undefined (const char *name
)
3392 struct bfd_link_hash_entry
*h
;
3394 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
3396 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3397 if (h
->type
== bfd_link_hash_new
)
3399 h
->type
= bfd_link_hash_undefined
;
3400 h
->u
.undef
.abfd
= NULL
;
3401 if (is_elf_hash_table (link_info
.hash
))
3402 ((struct elf_link_hash_entry
*) h
)->mark
= 1;
3403 bfd_link_add_undef (link_info
.hash
, h
);
3407 /* Run through the list of undefineds created above and place them
3408 into the linker hash table as undefined symbols belonging to the
3412 lang_place_undefineds (void)
3414 ldlang_undef_chain_list_type
*ptr
;
3416 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3417 insert_undefined (ptr
->name
);
3420 /* Structure used to build the list of symbols that the user has required
3423 struct require_defined_symbol
3426 struct require_defined_symbol
*next
;
3429 /* The list of symbols that the user has required be defined. */
3431 static struct require_defined_symbol
*require_defined_symbol_list
;
3433 /* Add a new symbol NAME to the list of symbols that are required to be
3437 ldlang_add_require_defined (const char *const name
)
3439 struct require_defined_symbol
*ptr
;
3441 ldlang_add_undef (name
, TRUE
);
3442 ptr
= (struct require_defined_symbol
*) stat_alloc (sizeof (*ptr
));
3443 ptr
->next
= require_defined_symbol_list
;
3444 ptr
->name
= strdup (name
);
3445 require_defined_symbol_list
= ptr
;
3448 /* Check that all symbols the user required to be defined, are defined,
3449 raise an error if we find a symbol that is not defined. */
3452 ldlang_check_require_defined_symbols (void)
3454 struct require_defined_symbol
*ptr
;
3456 for (ptr
= require_defined_symbol_list
; ptr
!= NULL
; ptr
= ptr
->next
)
3458 struct bfd_link_hash_entry
*h
;
3460 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
,
3461 FALSE
, FALSE
, TRUE
);
3463 || (h
->type
!= bfd_link_hash_defined
3464 && h
->type
!= bfd_link_hash_defweak
))
3465 einfo(_("%P%X: required symbol `%s' not defined\n"), ptr
->name
);
3469 /* Check for all readonly or some readwrite sections. */
3472 check_input_sections
3473 (lang_statement_union_type
*s
,
3474 lang_output_section_statement_type
*output_section_statement
)
3476 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
3478 switch (s
->header
.type
)
3480 case lang_wild_statement_enum
:
3481 walk_wild (&s
->wild_statement
, check_section_callback
,
3482 output_section_statement
);
3483 if (!output_section_statement
->all_input_readonly
)
3486 case lang_constructors_statement_enum
:
3487 check_input_sections (constructor_list
.head
,
3488 output_section_statement
);
3489 if (!output_section_statement
->all_input_readonly
)
3492 case lang_group_statement_enum
:
3493 check_input_sections (s
->group_statement
.children
.head
,
3494 output_section_statement
);
3495 if (!output_section_statement
->all_input_readonly
)
3504 /* Update wildcard statements if needed. */
3507 update_wild_statements (lang_statement_union_type
*s
)
3509 struct wildcard_list
*sec
;
3511 switch (sort_section
)
3521 for (; s
!= NULL
; s
= s
->header
.next
)
3523 switch (s
->header
.type
)
3528 case lang_wild_statement_enum
:
3529 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
3532 switch (sec
->spec
.sorted
)
3535 sec
->spec
.sorted
= sort_section
;
3538 if (sort_section
== by_alignment
)
3539 sec
->spec
.sorted
= by_name_alignment
;
3542 if (sort_section
== by_name
)
3543 sec
->spec
.sorted
= by_alignment_name
;
3551 case lang_constructors_statement_enum
:
3552 update_wild_statements (constructor_list
.head
);
3555 case lang_output_section_statement_enum
:
3556 /* Don't sort .init/.fini sections. */
3557 if (strcmp (s
->output_section_statement
.name
, ".init") != 0
3558 && strcmp (s
->output_section_statement
.name
, ".fini") != 0)
3559 update_wild_statements
3560 (s
->output_section_statement
.children
.head
);
3563 case lang_group_statement_enum
:
3564 update_wild_statements (s
->group_statement
.children
.head
);
3572 /* Open input files and attach to output sections. */
3575 map_input_to_output_sections
3576 (lang_statement_union_type
*s
, const char *target
,
3577 lang_output_section_statement_type
*os
)
3579 for (; s
!= NULL
; s
= s
->header
.next
)
3581 lang_output_section_statement_type
*tos
;
3584 switch (s
->header
.type
)
3586 case lang_wild_statement_enum
:
3587 wild (&s
->wild_statement
, target
, os
);
3589 case lang_constructors_statement_enum
:
3590 map_input_to_output_sections (constructor_list
.head
,
3594 case lang_output_section_statement_enum
:
3595 tos
= &s
->output_section_statement
;
3596 if (tos
->constraint
!= 0)
3598 if (tos
->constraint
!= ONLY_IF_RW
3599 && tos
->constraint
!= ONLY_IF_RO
)
3601 tos
->all_input_readonly
= TRUE
;
3602 check_input_sections (tos
->children
.head
, tos
);
3603 if (tos
->all_input_readonly
!= (tos
->constraint
== ONLY_IF_RO
))
3605 tos
->constraint
= -1;
3609 map_input_to_output_sections (tos
->children
.head
,
3613 case lang_output_statement_enum
:
3615 case lang_target_statement_enum
:
3616 target
= s
->target_statement
.target
;
3618 case lang_group_statement_enum
:
3619 map_input_to_output_sections (s
->group_statement
.children
.head
,
3623 case lang_data_statement_enum
:
3624 /* Make sure that any sections mentioned in the expression
3626 exp_init_os (s
->data_statement
.exp
);
3627 /* The output section gets CONTENTS, ALLOC and LOAD, but
3628 these may be overridden by the script. */
3629 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
;
3630 switch (os
->sectype
)
3632 case normal_section
:
3633 case overlay_section
:
3635 case noalloc_section
:
3636 flags
= SEC_HAS_CONTENTS
;
3638 case noload_section
:
3639 if (bfd_get_flavour (link_info
.output_bfd
)
3640 == bfd_target_elf_flavour
)
3641 flags
= SEC_NEVER_LOAD
| SEC_ALLOC
;
3643 flags
= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
;
3646 if (os
->bfd_section
== NULL
)
3647 init_os (os
, flags
);
3649 os
->bfd_section
->flags
|= flags
;
3651 case lang_input_section_enum
:
3653 case lang_fill_statement_enum
:
3654 case lang_object_symbols_statement_enum
:
3655 case lang_reloc_statement_enum
:
3656 case lang_padding_statement_enum
:
3657 case lang_input_statement_enum
:
3658 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3661 case lang_assignment_statement_enum
:
3662 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3665 /* Make sure that any sections mentioned in the assignment
3667 exp_init_os (s
->assignment_statement
.exp
);
3669 case lang_address_statement_enum
:
3670 /* Mark the specified section with the supplied address.
3671 If this section was actually a segment marker, then the
3672 directive is ignored if the linker script explicitly
3673 processed the segment marker. Originally, the linker
3674 treated segment directives (like -Ttext on the
3675 command-line) as section directives. We honor the
3676 section directive semantics for backwards compatibility;
3677 linker scripts that do not specifically check for
3678 SEGMENT_START automatically get the old semantics. */
3679 if (!s
->address_statement
.segment
3680 || !s
->address_statement
.segment
->used
)
3682 const char *name
= s
->address_statement
.section_name
;
3684 /* Create the output section statement here so that
3685 orphans with a set address will be placed after other
3686 script sections. If we let the orphan placement code
3687 place them in amongst other sections then the address
3688 will affect following script sections, which is
3689 likely to surprise naive users. */
3690 tos
= lang_output_section_statement_lookup (name
, 0, TRUE
);
3691 tos
->addr_tree
= s
->address_statement
.address
;
3692 if (tos
->bfd_section
== NULL
)
3696 case lang_insert_statement_enum
:
3702 /* An insert statement snips out all the linker statements from the
3703 start of the list and places them after the output section
3704 statement specified by the insert. This operation is complicated
3705 by the fact that we keep a doubly linked list of output section
3706 statements as well as the singly linked list of all statements. */
3709 process_insert_statements (void)
3711 lang_statement_union_type
**s
;
3712 lang_output_section_statement_type
*first_os
= NULL
;
3713 lang_output_section_statement_type
*last_os
= NULL
;
3714 lang_output_section_statement_type
*os
;
3716 /* "start of list" is actually the statement immediately after
3717 the special abs_section output statement, so that it isn't
3719 s
= &lang_output_section_statement
.head
;
3720 while (*(s
= &(*s
)->header
.next
) != NULL
)
3722 if ((*s
)->header
.type
== lang_output_section_statement_enum
)
3724 /* Keep pointers to the first and last output section
3725 statement in the sequence we may be about to move. */
3726 os
= &(*s
)->output_section_statement
;
3728 ASSERT (last_os
== NULL
|| last_os
->next
== os
);
3731 /* Set constraint negative so that lang_output_section_find
3732 won't match this output section statement. At this
3733 stage in linking constraint has values in the range
3734 [-1, ONLY_IN_RW]. */
3735 last_os
->constraint
= -2 - last_os
->constraint
;
3736 if (first_os
== NULL
)
3739 else if ((*s
)->header
.type
== lang_insert_statement_enum
)
3741 lang_insert_statement_type
*i
= &(*s
)->insert_statement
;
3742 lang_output_section_statement_type
*where
;
3743 lang_statement_union_type
**ptr
;
3744 lang_statement_union_type
*first
;
3746 where
= lang_output_section_find (i
->where
);
3747 if (where
!= NULL
&& i
->is_before
)
3750 where
= where
->prev
;
3751 while (where
!= NULL
&& where
->constraint
< 0);
3755 einfo (_("%F%P: %s not found for insert\n"), i
->where
);
3759 /* Deal with reordering the output section statement list. */
3760 if (last_os
!= NULL
)
3762 asection
*first_sec
, *last_sec
;
3763 struct lang_output_section_statement_struct
**next
;
3765 /* Snip out the output sections we are moving. */
3766 first_os
->prev
->next
= last_os
->next
;
3767 if (last_os
->next
== NULL
)
3769 next
= &first_os
->prev
->next
;
3770 lang_output_section_statement
.tail
3771 = (lang_statement_union_type
**) next
;
3774 last_os
->next
->prev
= first_os
->prev
;
3775 /* Add them in at the new position. */
3776 last_os
->next
= where
->next
;
3777 if (where
->next
== NULL
)
3779 next
= &last_os
->next
;
3780 lang_output_section_statement
.tail
3781 = (lang_statement_union_type
**) next
;
3784 where
->next
->prev
= last_os
;
3785 first_os
->prev
= where
;
3786 where
->next
= first_os
;
3788 /* Move the bfd sections in the same way. */
3791 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
3793 os
->constraint
= -2 - os
->constraint
;
3794 if (os
->bfd_section
!= NULL
3795 && os
->bfd_section
->owner
!= NULL
)
3797 last_sec
= os
->bfd_section
;
3798 if (first_sec
== NULL
)
3799 first_sec
= last_sec
;
3804 if (last_sec
!= NULL
)
3806 asection
*sec
= where
->bfd_section
;
3808 sec
= output_prev_sec_find (where
);
3810 /* The place we want to insert must come after the
3811 sections we are moving. So if we find no
3812 section or if the section is the same as our
3813 last section, then no move is needed. */
3814 if (sec
!= NULL
&& sec
!= last_sec
)
3816 /* Trim them off. */
3817 if (first_sec
->prev
!= NULL
)
3818 first_sec
->prev
->next
= last_sec
->next
;
3820 link_info
.output_bfd
->sections
= last_sec
->next
;
3821 if (last_sec
->next
!= NULL
)
3822 last_sec
->next
->prev
= first_sec
->prev
;
3824 link_info
.output_bfd
->section_last
= first_sec
->prev
;
3826 last_sec
->next
= sec
->next
;
3827 if (sec
->next
!= NULL
)
3828 sec
->next
->prev
= last_sec
;
3830 link_info
.output_bfd
->section_last
= last_sec
;
3831 first_sec
->prev
= sec
;
3832 sec
->next
= first_sec
;
3840 ptr
= insert_os_after (where
);
3841 /* Snip everything after the abs_section output statement we
3842 know is at the start of the list, up to and including
3843 the insert statement we are currently processing. */
3844 first
= lang_output_section_statement
.head
->header
.next
;
3845 lang_output_section_statement
.head
->header
.next
= (*s
)->header
.next
;
3846 /* Add them back where they belong. */
3849 statement_list
.tail
= s
;
3851 s
= &lang_output_section_statement
.head
;
3855 /* Undo constraint twiddling. */
3856 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
3858 os
->constraint
= -2 - os
->constraint
;
3864 /* An output section might have been removed after its statement was
3865 added. For example, ldemul_before_allocation can remove dynamic
3866 sections if they turn out to be not needed. Clean them up here. */
3869 strip_excluded_output_sections (void)
3871 lang_output_section_statement_type
*os
;
3873 /* Run lang_size_sections (if not already done). */
3874 if (expld
.phase
!= lang_mark_phase_enum
)
3876 expld
.phase
= lang_mark_phase_enum
;
3877 expld
.dataseg
.phase
= exp_dataseg_none
;
3878 one_lang_size_sections_pass (NULL
, FALSE
);
3879 lang_reset_memory_regions ();
3882 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
3886 asection
*output_section
;
3887 bfd_boolean exclude
;
3889 if (os
->constraint
< 0)
3892 output_section
= os
->bfd_section
;
3893 if (output_section
== NULL
)
3896 exclude
= (output_section
->rawsize
== 0
3897 && (output_section
->flags
& SEC_KEEP
) == 0
3898 && !bfd_section_removed_from_list (link_info
.output_bfd
,
3901 /* Some sections have not yet been sized, notably .gnu.version,
3902 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
3903 input sections, so don't drop output sections that have such
3904 input sections unless they are also marked SEC_EXCLUDE. */
3905 if (exclude
&& output_section
->map_head
.s
!= NULL
)
3909 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
3910 if ((s
->flags
& SEC_EXCLUDE
) == 0
3911 && ((s
->flags
& SEC_LINKER_CREATED
) != 0
3912 || link_info
.emitrelocations
))
3921 /* We don't set bfd_section to NULL since bfd_section of the
3922 removed output section statement may still be used. */
3923 if (!os
->update_dot
)
3925 output_section
->flags
|= SEC_EXCLUDE
;
3926 bfd_section_list_remove (link_info
.output_bfd
, output_section
);
3927 link_info
.output_bfd
->section_count
--;
3932 /* Called from ldwrite to clear out asection.map_head and
3933 asection.map_tail for use as link_orders in ldwrite.
3934 FIXME: Except for sh64elf.em which starts creating link_orders in
3935 its after_allocation routine so needs to call it early. */
3938 lang_clear_os_map (void)
3940 lang_output_section_statement_type
*os
;
3942 if (map_head_is_link_order
)
3945 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
3949 asection
*output_section
;
3951 if (os
->constraint
< 0)
3954 output_section
= os
->bfd_section
;
3955 if (output_section
== NULL
)
3958 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
3959 output_section
->map_head
.link_order
= NULL
;
3960 output_section
->map_tail
.link_order
= NULL
;
3963 /* Stop future calls to lang_add_section from messing with map_head
3964 and map_tail link_order fields. */
3965 map_head_is_link_order
= TRUE
;
3969 print_output_section_statement
3970 (lang_output_section_statement_type
*output_section_statement
)
3972 asection
*section
= output_section_statement
->bfd_section
;
3975 if (output_section_statement
!= abs_output_section
)
3977 minfo ("\n%s", output_section_statement
->name
);
3979 if (section
!= NULL
)
3981 print_dot
= section
->vma
;
3983 len
= strlen (output_section_statement
->name
);
3984 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
3989 while (len
< SECTION_NAME_MAP_LENGTH
)
3995 minfo ("0x%V %W", section
->vma
, TO_ADDR (section
->size
));
3997 if (section
->vma
!= section
->lma
)
3998 minfo (_(" load address 0x%V"), section
->lma
);
4000 if (output_section_statement
->update_dot_tree
!= NULL
)
4001 exp_fold_tree (output_section_statement
->update_dot_tree
,
4002 bfd_abs_section_ptr
, &print_dot
);
4008 print_statement_list (output_section_statement
->children
.head
,
4009 output_section_statement
);
4013 print_assignment (lang_assignment_statement_type
*assignment
,
4014 lang_output_section_statement_type
*output_section
)
4021 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4024 if (assignment
->exp
->type
.node_class
== etree_assert
)
4027 tree
= assignment
->exp
->assert_s
.child
;
4031 const char *dst
= assignment
->exp
->assign
.dst
;
4033 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
4035 expld
.assign_name
= dst
;
4036 tree
= assignment
->exp
->assign
.src
;
4039 osec
= output_section
->bfd_section
;
4041 osec
= bfd_abs_section_ptr
;
4043 if (assignment
->exp
->type
.node_class
!= etree_provide
)
4044 exp_fold_tree (tree
, osec
, &print_dot
);
4046 expld
.result
.valid_p
= FALSE
;
4048 if (expld
.result
.valid_p
)
4052 if (assignment
->exp
->type
.node_class
== etree_assert
4054 || expld
.assign_name
!= NULL
)
4056 value
= expld
.result
.value
;
4058 if (expld
.result
.section
!= NULL
)
4059 value
+= expld
.result
.section
->vma
;
4061 minfo ("0x%V", value
);
4067 struct bfd_link_hash_entry
*h
;
4069 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
4070 FALSE
, FALSE
, TRUE
);
4073 value
= h
->u
.def
.value
;
4074 value
+= h
->u
.def
.section
->output_section
->vma
;
4075 value
+= h
->u
.def
.section
->output_offset
;
4077 minfo ("[0x%V]", value
);
4080 minfo ("[unresolved]");
4085 if (assignment
->exp
->type
.node_class
== etree_provide
)
4086 minfo ("[!provide]");
4093 expld
.assign_name
= NULL
;
4096 exp_print_tree (assignment
->exp
);
4101 print_input_statement (lang_input_statement_type
*statm
)
4103 if (statm
->filename
!= NULL
4104 && (statm
->the_bfd
== NULL
4105 || (statm
->the_bfd
->flags
& BFD_LINKER_CREATED
) == 0))
4106 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
4109 /* Print all symbols defined in a particular section. This is called
4110 via bfd_link_hash_traverse, or by print_all_symbols. */
4113 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
4115 asection
*sec
= (asection
*) ptr
;
4117 if ((hash_entry
->type
== bfd_link_hash_defined
4118 || hash_entry
->type
== bfd_link_hash_defweak
)
4119 && sec
== hash_entry
->u
.def
.section
)
4123 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4126 (hash_entry
->u
.def
.value
4127 + hash_entry
->u
.def
.section
->output_offset
4128 + hash_entry
->u
.def
.section
->output_section
->vma
));
4130 minfo (" %T\n", hash_entry
->root
.string
);
4137 hash_entry_addr_cmp (const void *a
, const void *b
)
4139 const struct bfd_link_hash_entry
*l
= *(const struct bfd_link_hash_entry
**)a
;
4140 const struct bfd_link_hash_entry
*r
= *(const struct bfd_link_hash_entry
**)b
;
4142 if (l
->u
.def
.value
< r
->u
.def
.value
)
4144 else if (l
->u
.def
.value
> r
->u
.def
.value
)
4151 print_all_symbols (asection
*sec
)
4153 input_section_userdata_type
*ud
4154 = (input_section_userdata_type
*) get_userdata (sec
);
4155 struct map_symbol_def
*def
;
4156 struct bfd_link_hash_entry
**entries
;
4162 *ud
->map_symbol_def_tail
= 0;
4164 /* Sort the symbols by address. */
4165 entries
= (struct bfd_link_hash_entry
**)
4166 obstack_alloc (&map_obstack
,
4167 ud
->map_symbol_def_count
* sizeof (*entries
));
4169 for (i
= 0, def
= ud
->map_symbol_def_head
; def
; def
= def
->next
, i
++)
4170 entries
[i
] = def
->entry
;
4172 qsort (entries
, ud
->map_symbol_def_count
, sizeof (*entries
),
4173 hash_entry_addr_cmp
);
4175 /* Print the symbols. */
4176 for (i
= 0; i
< ud
->map_symbol_def_count
; i
++)
4177 print_one_symbol (entries
[i
], sec
);
4179 obstack_free (&map_obstack
, entries
);
4182 /* Print information about an input section to the map file. */
4185 print_input_section (asection
*i
, bfd_boolean is_discarded
)
4187 bfd_size_type size
= i
->size
;
4194 minfo ("%s", i
->name
);
4196 len
= 1 + strlen (i
->name
);
4197 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4202 while (len
< SECTION_NAME_MAP_LENGTH
)
4208 if (i
->output_section
!= NULL
4209 && i
->output_section
->owner
== link_info
.output_bfd
)
4210 addr
= i
->output_section
->vma
+ i
->output_offset
;
4218 minfo ("0x%V %W %B\n", addr
, size
, i
->owner
);
4220 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
4222 len
= SECTION_NAME_MAP_LENGTH
+ 3;
4234 minfo (_("%W (size before relaxing)\n"), i
->rawsize
);
4237 if (i
->output_section
!= NULL
4238 && i
->output_section
->owner
== link_info
.output_bfd
)
4240 if (link_info
.reduce_memory_overheads
)
4241 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, i
);
4243 print_all_symbols (i
);
4245 /* Update print_dot, but make sure that we do not move it
4246 backwards - this could happen if we have overlays and a
4247 later overlay is shorter than an earier one. */
4248 if (addr
+ TO_ADDR (size
) > print_dot
)
4249 print_dot
= addr
+ TO_ADDR (size
);
4254 print_fill_statement (lang_fill_statement_type
*fill
)
4258 fputs (" FILL mask 0x", config
.map_file
);
4259 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
4260 fprintf (config
.map_file
, "%02x", *p
);
4261 fputs ("\n", config
.map_file
);
4265 print_data_statement (lang_data_statement_type
*data
)
4273 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4276 addr
= data
->output_offset
;
4277 if (data
->output_section
!= NULL
)
4278 addr
+= data
->output_section
->vma
;
4306 if (size
< TO_SIZE ((unsigned) 1))
4307 size
= TO_SIZE ((unsigned) 1);
4308 minfo ("0x%V %W %s 0x%v", addr
, TO_ADDR (size
), name
, data
->value
);
4310 if (data
->exp
->type
.node_class
!= etree_value
)
4313 exp_print_tree (data
->exp
);
4318 print_dot
= addr
+ TO_ADDR (size
);
4321 /* Print an address statement. These are generated by options like
4325 print_address_statement (lang_address_statement_type
*address
)
4327 minfo (_("Address of section %s set to "), address
->section_name
);
4328 exp_print_tree (address
->address
);
4332 /* Print a reloc statement. */
4335 print_reloc_statement (lang_reloc_statement_type
*reloc
)
4342 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4345 addr
= reloc
->output_offset
;
4346 if (reloc
->output_section
!= NULL
)
4347 addr
+= reloc
->output_section
->vma
;
4349 size
= bfd_get_reloc_size (reloc
->howto
);
4351 minfo ("0x%V %W RELOC %s ", addr
, TO_ADDR (size
), reloc
->howto
->name
);
4353 if (reloc
->name
!= NULL
)
4354 minfo ("%s+", reloc
->name
);
4356 minfo ("%s+", reloc
->section
->name
);
4358 exp_print_tree (reloc
->addend_exp
);
4362 print_dot
= addr
+ TO_ADDR (size
);
4366 print_padding_statement (lang_padding_statement_type
*s
)
4374 len
= sizeof " *fill*" - 1;
4375 while (len
< SECTION_NAME_MAP_LENGTH
)
4381 addr
= s
->output_offset
;
4382 if (s
->output_section
!= NULL
)
4383 addr
+= s
->output_section
->vma
;
4384 minfo ("0x%V %W ", addr
, TO_ADDR (s
->size
));
4386 if (s
->fill
->size
!= 0)
4390 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
4391 fprintf (config
.map_file
, "%02x", *p
);
4396 print_dot
= addr
+ TO_ADDR (s
->size
);
4400 print_wild_statement (lang_wild_statement_type
*w
,
4401 lang_output_section_statement_type
*os
)
4403 struct wildcard_list
*sec
;
4407 if (w
->exclude_name_list
)
4410 minfo ("EXCLUDE_FILE(%s", w
->exclude_name_list
->name
);
4411 for (tmp
= w
->exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4412 minfo (" %s", tmp
->name
);
4416 if (w
->filenames_sorted
)
4418 if (w
->filename
!= NULL
)
4419 minfo ("%s", w
->filename
);
4422 if (w
->filenames_sorted
)
4426 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
4428 if (sec
->spec
.sorted
)
4430 if (sec
->spec
.exclude_name_list
!= NULL
)
4433 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
4434 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4435 minfo (" %s", tmp
->name
);
4438 if (sec
->spec
.name
!= NULL
)
4439 minfo ("%s", sec
->spec
.name
);
4442 if (sec
->spec
.sorted
)
4451 print_statement_list (w
->children
.head
, os
);
4454 /* Print a group statement. */
4457 print_group (lang_group_statement_type
*s
,
4458 lang_output_section_statement_type
*os
)
4460 fprintf (config
.map_file
, "START GROUP\n");
4461 print_statement_list (s
->children
.head
, os
);
4462 fprintf (config
.map_file
, "END GROUP\n");
4465 /* Print the list of statements in S.
4466 This can be called for any statement type. */
4469 print_statement_list (lang_statement_union_type
*s
,
4470 lang_output_section_statement_type
*os
)
4474 print_statement (s
, os
);
4479 /* Print the first statement in statement list S.
4480 This can be called for any statement type. */
4483 print_statement (lang_statement_union_type
*s
,
4484 lang_output_section_statement_type
*os
)
4486 switch (s
->header
.type
)
4489 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
4492 case lang_constructors_statement_enum
:
4493 if (constructor_list
.head
!= NULL
)
4495 if (constructors_sorted
)
4496 minfo (" SORT (CONSTRUCTORS)\n");
4498 minfo (" CONSTRUCTORS\n");
4499 print_statement_list (constructor_list
.head
, os
);
4502 case lang_wild_statement_enum
:
4503 print_wild_statement (&s
->wild_statement
, os
);
4505 case lang_address_statement_enum
:
4506 print_address_statement (&s
->address_statement
);
4508 case lang_object_symbols_statement_enum
:
4509 minfo (" CREATE_OBJECT_SYMBOLS\n");
4511 case lang_fill_statement_enum
:
4512 print_fill_statement (&s
->fill_statement
);
4514 case lang_data_statement_enum
:
4515 print_data_statement (&s
->data_statement
);
4517 case lang_reloc_statement_enum
:
4518 print_reloc_statement (&s
->reloc_statement
);
4520 case lang_input_section_enum
:
4521 print_input_section (s
->input_section
.section
, FALSE
);
4523 case lang_padding_statement_enum
:
4524 print_padding_statement (&s
->padding_statement
);
4526 case lang_output_section_statement_enum
:
4527 print_output_section_statement (&s
->output_section_statement
);
4529 case lang_assignment_statement_enum
:
4530 print_assignment (&s
->assignment_statement
, os
);
4532 case lang_target_statement_enum
:
4533 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
4535 case lang_output_statement_enum
:
4536 minfo ("OUTPUT(%s", s
->output_statement
.name
);
4537 if (output_target
!= NULL
)
4538 minfo (" %s", output_target
);
4541 case lang_input_statement_enum
:
4542 print_input_statement (&s
->input_statement
);
4544 case lang_group_statement_enum
:
4545 print_group (&s
->group_statement
, os
);
4547 case lang_insert_statement_enum
:
4548 minfo ("INSERT %s %s\n",
4549 s
->insert_statement
.is_before
? "BEFORE" : "AFTER",
4550 s
->insert_statement
.where
);
4556 print_statements (void)
4558 print_statement_list (statement_list
.head
, abs_output_section
);
4561 /* Print the first N statements in statement list S to STDERR.
4562 If N == 0, nothing is printed.
4563 If N < 0, the entire list is printed.
4564 Intended to be called from GDB. */
4567 dprint_statement (lang_statement_union_type
*s
, int n
)
4569 FILE *map_save
= config
.map_file
;
4571 config
.map_file
= stderr
;
4574 print_statement_list (s
, abs_output_section
);
4577 while (s
&& --n
>= 0)
4579 print_statement (s
, abs_output_section
);
4584 config
.map_file
= map_save
;
4588 insert_pad (lang_statement_union_type
**ptr
,
4590 bfd_size_type alignment_needed
,
4591 asection
*output_section
,
4594 static fill_type zero_fill
;
4595 lang_statement_union_type
*pad
= NULL
;
4597 if (ptr
!= &statement_list
.head
)
4598 pad
= ((lang_statement_union_type
*)
4599 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
4601 && pad
->header
.type
== lang_padding_statement_enum
4602 && pad
->padding_statement
.output_section
== output_section
)
4604 /* Use the existing pad statement. */
4606 else if ((pad
= *ptr
) != NULL
4607 && pad
->header
.type
== lang_padding_statement_enum
4608 && pad
->padding_statement
.output_section
== output_section
)
4610 /* Use the existing pad statement. */
4614 /* Make a new padding statement, linked into existing chain. */
4615 pad
= (lang_statement_union_type
*)
4616 stat_alloc (sizeof (lang_padding_statement_type
));
4617 pad
->header
.next
= *ptr
;
4619 pad
->header
.type
= lang_padding_statement_enum
;
4620 pad
->padding_statement
.output_section
= output_section
;
4623 pad
->padding_statement
.fill
= fill
;
4625 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
4626 pad
->padding_statement
.size
= alignment_needed
;
4627 output_section
->size
= TO_SIZE (dot
+ TO_ADDR (alignment_needed
)
4628 - output_section
->vma
);
4631 /* Work out how much this section will move the dot point. */
4635 (lang_statement_union_type
**this_ptr
,
4636 lang_output_section_statement_type
*output_section_statement
,
4640 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
4641 asection
*i
= is
->section
;
4642 asection
*o
= output_section_statement
->bfd_section
;
4644 if (i
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
4645 i
->output_offset
= i
->vma
- o
->vma
;
4646 else if (((i
->flags
& SEC_EXCLUDE
) != 0)
4647 || output_section_statement
->ignored
)
4648 i
->output_offset
= dot
- o
->vma
;
4651 bfd_size_type alignment_needed
;
4653 /* Align this section first to the input sections requirement,
4654 then to the output section's requirement. If this alignment
4655 is greater than any seen before, then record it too. Perform
4656 the alignment by inserting a magic 'padding' statement. */
4658 if (output_section_statement
->subsection_alignment
!= -1)
4659 i
->alignment_power
= output_section_statement
->subsection_alignment
;
4661 if (o
->alignment_power
< i
->alignment_power
)
4662 o
->alignment_power
= i
->alignment_power
;
4664 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
4666 if (alignment_needed
!= 0)
4668 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
4669 dot
+= alignment_needed
;
4672 /* Remember where in the output section this input section goes. */
4673 i
->output_offset
= dot
- o
->vma
;
4675 /* Mark how big the output section must be to contain this now. */
4676 dot
+= TO_ADDR (i
->size
);
4677 o
->size
= TO_SIZE (dot
- o
->vma
);
4690 sort_sections_by_lma (const void *arg1
, const void *arg2
)
4692 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
4693 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
4695 if (sec1
->lma
< sec2
->lma
)
4697 else if (sec1
->lma
> sec2
->lma
)
4699 else if (sec1
->id
< sec2
->id
)
4701 else if (sec1
->id
> sec2
->id
)
4708 sort_sections_by_vma (const void *arg1
, const void *arg2
)
4710 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
4711 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
4713 if (sec1
->vma
< sec2
->vma
)
4715 else if (sec1
->vma
> sec2
->vma
)
4717 else if (sec1
->id
< sec2
->id
)
4719 else if (sec1
->id
> sec2
->id
)
4725 #define IS_TBSS(s) \
4726 ((s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == SEC_THREAD_LOCAL)
4728 #define IGNORE_SECTION(s) \
4729 ((s->flags & SEC_ALLOC) == 0 || IS_TBSS (s))
4731 /* Check to see if any allocated sections overlap with other allocated
4732 sections. This can happen if a linker script specifies the output
4733 section addresses of the two sections. Also check whether any memory
4734 region has overflowed. */
4737 lang_check_section_addresses (void)
4740 struct check_sec
*sections
;
4745 bfd_vma p_start
= 0;
4747 lang_memory_region_type
*m
;
4748 bfd_boolean overlays
;
4750 /* Detect address space overflow on allocated sections. */
4751 addr_mask
= ((bfd_vma
) 1 <<
4752 (bfd_arch_bits_per_address (link_info
.output_bfd
) - 1)) - 1;
4753 addr_mask
= (addr_mask
<< 1) + 1;
4754 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
4755 if ((s
->flags
& SEC_ALLOC
) != 0)
4757 s_end
= (s
->vma
+ s
->size
) & addr_mask
;
4758 if (s_end
!= 0 && s_end
< (s
->vma
& addr_mask
))
4759 einfo (_("%X%P: section %s VMA wraps around address space\n"),
4763 s_end
= (s
->lma
+ s
->size
) & addr_mask
;
4764 if (s_end
!= 0 && s_end
< (s
->lma
& addr_mask
))
4765 einfo (_("%X%P: section %s LMA wraps around address space\n"),
4770 if (bfd_count_sections (link_info
.output_bfd
) <= 1)
4773 count
= bfd_count_sections (link_info
.output_bfd
);
4774 sections
= XNEWVEC (struct check_sec
, count
);
4776 /* Scan all sections in the output list. */
4778 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
4780 if (IGNORE_SECTION (s
)
4784 sections
[count
].sec
= s
;
4785 sections
[count
].warned
= FALSE
;
4795 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_lma
);
4797 /* First check section LMAs. There should be no overlap of LMAs on
4798 loadable sections, even with overlays. */
4799 for (p
= NULL
, i
= 0; i
< count
; i
++)
4801 s
= sections
[i
].sec
;
4802 if ((s
->flags
& SEC_LOAD
) != 0)
4805 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
4807 /* Look for an overlap. We have sorted sections by lma, so
4808 we know that s_start >= p_start. Besides the obvious
4809 case of overlap when the current section starts before
4810 the previous one ends, we also must have overlap if the
4811 previous section wraps around the address space. */
4813 && (s_start
<= p_end
4814 || p_end
< p_start
))
4816 einfo (_("%X%P: section %s LMA [%V,%V]"
4817 " overlaps section %s LMA [%V,%V]\n"),
4818 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
4819 sections
[i
].warned
= TRUE
;
4827 /* If any non-zero size allocated section (excluding tbss) starts at
4828 exactly the same VMA as another such section, then we have
4829 overlays. Overlays generated by the OVERLAY keyword will have
4830 this property. It is possible to intentionally generate overlays
4831 that fail this test, but it would be unusual. */
4832 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_vma
);
4834 p_start
= sections
[0].sec
->vma
;
4835 for (i
= 1; i
< count
; i
++)
4837 s_start
= sections
[i
].sec
->vma
;
4838 if (p_start
== s_start
)
4846 /* Now check section VMAs if no overlays were detected. */
4849 for (p
= NULL
, i
= 0; i
< count
; i
++)
4851 s
= sections
[i
].sec
;
4853 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
4856 && !sections
[i
].warned
4857 && (s_start
<= p_end
4858 || p_end
< p_start
))
4859 einfo (_("%X%P: section %s VMA [%V,%V]"
4860 " overlaps section %s VMA [%V,%V]\n"),
4861 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
4870 /* If any memory region has overflowed, report by how much.
4871 We do not issue this diagnostic for regions that had sections
4872 explicitly placed outside their bounds; os_region_check's
4873 diagnostics are adequate for that case.
4875 FIXME: It is conceivable that m->current - (m->origin + m->length)
4876 might overflow a 32-bit integer. There is, alas, no way to print
4877 a bfd_vma quantity in decimal. */
4878 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
4879 if (m
->had_full_message
)
4880 einfo (_("%X%P: region `%s' overflowed by %ld bytes\n"),
4881 m
->name_list
.name
, (long)(m
->current
- (m
->origin
+ m
->length
)));
4884 /* Make sure the new address is within the region. We explicitly permit the
4885 current address to be at the exact end of the region when the address is
4886 non-zero, in case the region is at the end of addressable memory and the
4887 calculation wraps around. */
4890 os_region_check (lang_output_section_statement_type
*os
,
4891 lang_memory_region_type
*region
,
4895 if ((region
->current
< region
->origin
4896 || (region
->current
- region
->origin
> region
->length
))
4897 && ((region
->current
!= region
->origin
+ region
->length
)
4902 einfo (_("%X%P: address 0x%v of %B section `%s'"
4903 " is not within region `%s'\n"),
4905 os
->bfd_section
->owner
,
4906 os
->bfd_section
->name
,
4907 region
->name_list
.name
);
4909 else if (!region
->had_full_message
)
4911 region
->had_full_message
= TRUE
;
4913 einfo (_("%X%P: %B section `%s' will not fit in region `%s'\n"),
4914 os
->bfd_section
->owner
,
4915 os
->bfd_section
->name
,
4916 region
->name_list
.name
);
4921 /* Set the sizes for all the output sections. */
4924 lang_size_sections_1
4925 (lang_statement_union_type
**prev
,
4926 lang_output_section_statement_type
*output_section_statement
,
4930 bfd_boolean check_regions
)
4932 lang_statement_union_type
*s
;
4934 /* Size up the sections from their constituent parts. */
4935 for (s
= *prev
; s
!= NULL
; s
= s
->header
.next
)
4937 switch (s
->header
.type
)
4939 case lang_output_section_statement_enum
:
4941 bfd_vma newdot
, after
, dotdelta
;
4942 lang_output_section_statement_type
*os
;
4943 lang_memory_region_type
*r
;
4944 int section_alignment
= 0;
4946 os
= &s
->output_section_statement
;
4947 if (os
->constraint
== -1)
4950 /* FIXME: We shouldn't need to zero section vmas for ld -r
4951 here, in lang_insert_orphan, or in the default linker scripts.
4952 This is covering for coff backend linker bugs. See PR6945. */
4953 if (os
->addr_tree
== NULL
4954 && bfd_link_relocatable (&link_info
)
4955 && (bfd_get_flavour (link_info
.output_bfd
)
4956 == bfd_target_coff_flavour
))
4957 os
->addr_tree
= exp_intop (0);
4958 if (os
->addr_tree
!= NULL
)
4960 os
->processed_vma
= FALSE
;
4961 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
4963 if (expld
.result
.valid_p
)
4965 dot
= expld
.result
.value
;
4966 if (expld
.result
.section
!= NULL
)
4967 dot
+= expld
.result
.section
->vma
;
4969 else if (expld
.phase
!= lang_mark_phase_enum
)
4970 einfo (_("%F%S: non constant or forward reference"
4971 " address expression for section %s\n"),
4972 os
->addr_tree
, os
->name
);
4975 if (os
->bfd_section
== NULL
)
4976 /* This section was removed or never actually created. */
4979 /* If this is a COFF shared library section, use the size and
4980 address from the input section. FIXME: This is COFF
4981 specific; it would be cleaner if there were some other way
4982 to do this, but nothing simple comes to mind. */
4983 if (((bfd_get_flavour (link_info
.output_bfd
)
4984 == bfd_target_ecoff_flavour
)
4985 || (bfd_get_flavour (link_info
.output_bfd
)
4986 == bfd_target_coff_flavour
))
4987 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
4991 if (os
->children
.head
== NULL
4992 || os
->children
.head
->header
.next
!= NULL
4993 || (os
->children
.head
->header
.type
4994 != lang_input_section_enum
))
4995 einfo (_("%P%X: Internal error on COFF shared library"
4996 " section %s\n"), os
->name
);
4998 input
= os
->children
.head
->input_section
.section
;
4999 bfd_set_section_vma (os
->bfd_section
->owner
,
5001 bfd_section_vma (input
->owner
, input
));
5002 os
->bfd_section
->size
= input
->size
;
5008 if (bfd_is_abs_section (os
->bfd_section
))
5010 /* No matter what happens, an abs section starts at zero. */
5011 ASSERT (os
->bfd_section
->vma
== 0);
5015 if (os
->addr_tree
== NULL
)
5017 /* No address specified for this section, get one
5018 from the region specification. */
5019 if (os
->region
== NULL
5020 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
5021 && os
->region
->name_list
.name
[0] == '*'
5022 && strcmp (os
->region
->name_list
.name
,
5023 DEFAULT_MEMORY_REGION
) == 0))
5025 os
->region
= lang_memory_default (os
->bfd_section
);
5028 /* If a loadable section is using the default memory
5029 region, and some non default memory regions were
5030 defined, issue an error message. */
5032 && !IGNORE_SECTION (os
->bfd_section
)
5033 && !bfd_link_relocatable (&link_info
)
5035 && strcmp (os
->region
->name_list
.name
,
5036 DEFAULT_MEMORY_REGION
) == 0
5037 && lang_memory_region_list
!= NULL
5038 && (strcmp (lang_memory_region_list
->name_list
.name
,
5039 DEFAULT_MEMORY_REGION
) != 0
5040 || lang_memory_region_list
->next
!= NULL
)
5041 && expld
.phase
!= lang_mark_phase_enum
)
5043 /* By default this is an error rather than just a
5044 warning because if we allocate the section to the
5045 default memory region we can end up creating an
5046 excessively large binary, or even seg faulting when
5047 attempting to perform a negative seek. See
5048 sources.redhat.com/ml/binutils/2003-04/msg00423.html
5049 for an example of this. This behaviour can be
5050 overridden by the using the --no-check-sections
5052 if (command_line
.check_section_addresses
)
5053 einfo (_("%P%F: error: no memory region specified"
5054 " for loadable section `%s'\n"),
5055 bfd_get_section_name (link_info
.output_bfd
,
5058 einfo (_("%P: warning: no memory region specified"
5059 " for loadable section `%s'\n"),
5060 bfd_get_section_name (link_info
.output_bfd
,
5064 newdot
= os
->region
->current
;
5065 section_alignment
= os
->bfd_section
->alignment_power
;
5068 section_alignment
= os
->section_alignment
;
5070 /* Align to what the section needs. */
5071 if (section_alignment
> 0)
5073 bfd_vma savedot
= newdot
;
5074 newdot
= align_power (newdot
, section_alignment
);
5076 dotdelta
= newdot
- savedot
;
5078 && (config
.warn_section_align
5079 || os
->addr_tree
!= NULL
)
5080 && expld
.phase
!= lang_mark_phase_enum
)
5081 einfo (_("%P: warning: changing start of section"
5082 " %s by %lu bytes\n"),
5083 os
->name
, (unsigned long) dotdelta
);
5086 bfd_set_section_vma (0, os
->bfd_section
, newdot
);
5088 os
->bfd_section
->output_offset
= 0;
5091 lang_size_sections_1 (&os
->children
.head
, os
,
5092 os
->fill
, newdot
, relax
, check_regions
);
5094 os
->processed_vma
= TRUE
;
5096 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5097 /* Except for some special linker created sections,
5098 no output section should change from zero size
5099 after strip_excluded_output_sections. A non-zero
5100 size on an ignored section indicates that some
5101 input section was not sized early enough. */
5102 ASSERT (os
->bfd_section
->size
== 0);
5105 dot
= os
->bfd_section
->vma
;
5107 /* Put the section within the requested block size, or
5108 align at the block boundary. */
5110 + TO_ADDR (os
->bfd_section
->size
)
5111 + os
->block_value
- 1)
5112 & - (bfd_vma
) os
->block_value
);
5114 os
->bfd_section
->size
= TO_SIZE (after
- os
->bfd_section
->vma
);
5117 /* Set section lma. */
5120 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
5124 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
5125 os
->bfd_section
->lma
= lma
;
5127 else if (os
->lma_region
!= NULL
)
5129 bfd_vma lma
= os
->lma_region
->current
;
5131 if (os
->align_lma_with_input
)
5135 /* When LMA_REGION is the same as REGION, align the LMA
5136 as we did for the VMA, possibly including alignment
5137 from the bfd section. If a different region, then
5138 only align according to the value in the output
5140 if (os
->lma_region
!= os
->region
)
5141 section_alignment
= os
->section_alignment
;
5142 if (section_alignment
> 0)
5143 lma
= align_power (lma
, section_alignment
);
5145 os
->bfd_section
->lma
= lma
;
5147 else if (r
->last_os
!= NULL
5148 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5153 last
= r
->last_os
->output_section_statement
.bfd_section
;
5155 /* A backwards move of dot should be accompanied by
5156 an explicit assignment to the section LMA (ie.
5157 os->load_base set) because backwards moves can
5158 create overlapping LMAs. */
5160 && os
->bfd_section
->size
!= 0
5161 && dot
+ TO_ADDR (os
->bfd_section
->size
) <= last
->vma
)
5163 /* If dot moved backwards then leave lma equal to
5164 vma. This is the old default lma, which might
5165 just happen to work when the backwards move is
5166 sufficiently large. Nag if this changes anything,
5167 so people can fix their linker scripts. */
5169 if (last
->vma
!= last
->lma
)
5170 einfo (_("%P: warning: dot moved backwards "
5171 "before `%s'\n"), os
->name
);
5175 /* If this is an overlay, set the current lma to that
5176 at the end of the previous section. */
5177 if (os
->sectype
== overlay_section
)
5178 lma
= last
->lma
+ TO_ADDR (last
->size
);
5180 /* Otherwise, keep the same lma to vma relationship
5181 as the previous section. */
5183 lma
= dot
+ last
->lma
- last
->vma
;
5185 if (section_alignment
> 0)
5186 lma
= align_power (lma
, section_alignment
);
5187 os
->bfd_section
->lma
= lma
;
5190 os
->processed_lma
= TRUE
;
5192 /* Keep track of normal sections using the default
5193 lma region. We use this to set the lma for
5194 following sections. Overlays or other linker
5195 script assignment to lma might mean that the
5196 default lma == vma is incorrect.
5197 To avoid warnings about dot moving backwards when using
5198 -Ttext, don't start tracking sections until we find one
5199 of non-zero size or with lma set differently to vma.
5200 Do this tracking before we short-cut the loop so that we
5201 track changes for the case where the section size is zero,
5202 but the lma is set differently to the vma. This is
5203 important, if an orphan section is placed after an
5204 otherwise empty output section that has an explicit lma
5205 set, we want that lma reflected in the orphans lma. */
5206 if (!IGNORE_SECTION (os
->bfd_section
)
5207 && (os
->bfd_section
->size
!= 0
5208 || (r
->last_os
== NULL
5209 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
5210 || (r
->last_os
!= NULL
5211 && dot
>= (r
->last_os
->output_section_statement
5212 .bfd_section
->vma
)))
5213 && os
->lma_region
== NULL
5214 && !bfd_link_relocatable (&link_info
))
5217 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5220 /* .tbss sections effectively have zero size. */
5221 if (!IS_TBSS (os
->bfd_section
)
5222 || bfd_link_relocatable (&link_info
))
5223 dotdelta
= TO_ADDR (os
->bfd_section
->size
);
5228 if (os
->update_dot_tree
!= 0)
5229 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5231 /* Update dot in the region ?
5232 We only do this if the section is going to be allocated,
5233 since unallocated sections do not contribute to the region's
5234 overall size in memory. */
5235 if (os
->region
!= NULL
5236 && (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)))
5238 os
->region
->current
= dot
;
5241 /* Make sure the new address is within the region. */
5242 os_region_check (os
, os
->region
, os
->addr_tree
,
5243 os
->bfd_section
->vma
);
5245 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
5246 && ((os
->bfd_section
->flags
& SEC_LOAD
)
5247 || os
->align_lma_with_input
))
5249 os
->lma_region
->current
= os
->bfd_section
->lma
+ dotdelta
;
5252 os_region_check (os
, os
->lma_region
, NULL
,
5253 os
->bfd_section
->lma
);
5259 case lang_constructors_statement_enum
:
5260 dot
= lang_size_sections_1 (&constructor_list
.head
,
5261 output_section_statement
,
5262 fill
, dot
, relax
, check_regions
);
5265 case lang_data_statement_enum
:
5267 unsigned int size
= 0;
5269 s
->data_statement
.output_offset
=
5270 dot
- output_section_statement
->bfd_section
->vma
;
5271 s
->data_statement
.output_section
=
5272 output_section_statement
->bfd_section
;
5274 /* We might refer to provided symbols in the expression, and
5275 need to mark them as needed. */
5276 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5278 switch (s
->data_statement
.type
)
5296 if (size
< TO_SIZE ((unsigned) 1))
5297 size
= TO_SIZE ((unsigned) 1);
5298 dot
+= TO_ADDR (size
);
5299 output_section_statement
->bfd_section
->size
5300 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5305 case lang_reloc_statement_enum
:
5309 s
->reloc_statement
.output_offset
=
5310 dot
- output_section_statement
->bfd_section
->vma
;
5311 s
->reloc_statement
.output_section
=
5312 output_section_statement
->bfd_section
;
5313 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
5314 dot
+= TO_ADDR (size
);
5315 output_section_statement
->bfd_section
->size
5316 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5320 case lang_wild_statement_enum
:
5321 dot
= lang_size_sections_1 (&s
->wild_statement
.children
.head
,
5322 output_section_statement
,
5323 fill
, dot
, relax
, check_regions
);
5326 case lang_object_symbols_statement_enum
:
5327 link_info
.create_object_symbols_section
=
5328 output_section_statement
->bfd_section
;
5331 case lang_output_statement_enum
:
5332 case lang_target_statement_enum
:
5335 case lang_input_section_enum
:
5339 i
= s
->input_section
.section
;
5344 if (!bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
5345 einfo (_("%P%F: can't relax section: %E\n"));
5349 dot
= size_input_section (prev
, output_section_statement
,
5354 case lang_input_statement_enum
:
5357 case lang_fill_statement_enum
:
5358 s
->fill_statement
.output_section
=
5359 output_section_statement
->bfd_section
;
5361 fill
= s
->fill_statement
.fill
;
5364 case lang_assignment_statement_enum
:
5366 bfd_vma newdot
= dot
;
5367 etree_type
*tree
= s
->assignment_statement
.exp
;
5369 expld
.dataseg
.relro
= exp_dataseg_relro_none
;
5371 exp_fold_tree (tree
,
5372 output_section_statement
->bfd_section
,
5375 if (expld
.dataseg
.relro
== exp_dataseg_relro_start
)
5377 if (!expld
.dataseg
.relro_start_stat
)
5378 expld
.dataseg
.relro_start_stat
= s
;
5381 ASSERT (expld
.dataseg
.relro_start_stat
== s
);
5384 else if (expld
.dataseg
.relro
== exp_dataseg_relro_end
)
5386 if (!expld
.dataseg
.relro_end_stat
)
5387 expld
.dataseg
.relro_end_stat
= s
;
5390 ASSERT (expld
.dataseg
.relro_end_stat
== s
);
5393 expld
.dataseg
.relro
= exp_dataseg_relro_none
;
5395 /* This symbol may be relative to this section. */
5396 if ((tree
->type
.node_class
== etree_provided
5397 || tree
->type
.node_class
== etree_assign
)
5398 && (tree
->assign
.dst
[0] != '.'
5399 || tree
->assign
.dst
[1] != '\0'))
5400 output_section_statement
->update_dot
= 1;
5402 if (!output_section_statement
->ignored
)
5404 if (output_section_statement
== abs_output_section
)
5406 /* If we don't have an output section, then just adjust
5407 the default memory address. */
5408 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
5409 FALSE
)->current
= newdot
;
5411 else if (newdot
!= dot
)
5413 /* Insert a pad after this statement. We can't
5414 put the pad before when relaxing, in case the
5415 assignment references dot. */
5416 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
5417 output_section_statement
->bfd_section
, dot
);
5419 /* Don't neuter the pad below when relaxing. */
5422 /* If dot is advanced, this implies that the section
5423 should have space allocated to it, unless the
5424 user has explicitly stated that the section
5425 should not be allocated. */
5426 if (output_section_statement
->sectype
!= noalloc_section
5427 && (output_section_statement
->sectype
!= noload_section
5428 || (bfd_get_flavour (link_info
.output_bfd
)
5429 == bfd_target_elf_flavour
)))
5430 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
5437 case lang_padding_statement_enum
:
5438 /* If this is the first time lang_size_sections is called,
5439 we won't have any padding statements. If this is the
5440 second or later passes when relaxing, we should allow
5441 padding to shrink. If padding is needed on this pass, it
5442 will be added back in. */
5443 s
->padding_statement
.size
= 0;
5445 /* Make sure output_offset is valid. If relaxation shrinks
5446 the section and this pad isn't needed, it's possible to
5447 have output_offset larger than the final size of the
5448 section. bfd_set_section_contents will complain even for
5449 a pad size of zero. */
5450 s
->padding_statement
.output_offset
5451 = dot
- output_section_statement
->bfd_section
->vma
;
5454 case lang_group_statement_enum
:
5455 dot
= lang_size_sections_1 (&s
->group_statement
.children
.head
,
5456 output_section_statement
,
5457 fill
, dot
, relax
, check_regions
);
5460 case lang_insert_statement_enum
:
5463 /* We can only get here when relaxing is turned on. */
5464 case lang_address_statement_enum
:
5471 prev
= &s
->header
.next
;
5476 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
5477 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
5478 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
5479 segments. We are allowed an opportunity to override this decision. */
5482 ldlang_override_segment_assignment (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5483 bfd
*abfd ATTRIBUTE_UNUSED
,
5484 asection
*current_section
,
5485 asection
*previous_section
,
5486 bfd_boolean new_segment
)
5488 lang_output_section_statement_type
*cur
;
5489 lang_output_section_statement_type
*prev
;
5491 /* The checks below are only necessary when the BFD library has decided
5492 that the two sections ought to be placed into the same segment. */
5496 /* Paranoia checks. */
5497 if (current_section
== NULL
|| previous_section
== NULL
)
5500 /* If this flag is set, the target never wants code and non-code
5501 sections comingled in the same segment. */
5502 if (config
.separate_code
5503 && ((current_section
->flags
^ previous_section
->flags
) & SEC_CODE
))
5506 /* Find the memory regions associated with the two sections.
5507 We call lang_output_section_find() here rather than scanning the list
5508 of output sections looking for a matching section pointer because if
5509 we have a large number of sections then a hash lookup is faster. */
5510 cur
= lang_output_section_find (current_section
->name
);
5511 prev
= lang_output_section_find (previous_section
->name
);
5513 /* More paranoia. */
5514 if (cur
== NULL
|| prev
== NULL
)
5517 /* If the regions are different then force the sections to live in
5518 different segments. See the email thread starting at the following
5519 URL for the reasons why this is necessary:
5520 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
5521 return cur
->region
!= prev
->region
;
5525 one_lang_size_sections_pass (bfd_boolean
*relax
, bfd_boolean check_regions
)
5527 lang_statement_iteration
++;
5528 lang_size_sections_1 (&statement_list
.head
, abs_output_section
,
5529 0, 0, relax
, check_regions
);
5533 lang_size_sections (bfd_boolean
*relax
, bfd_boolean check_regions
)
5535 expld
.phase
= lang_allocating_phase_enum
;
5536 expld
.dataseg
.phase
= exp_dataseg_none
;
5538 one_lang_size_sections_pass (relax
, check_regions
);
5539 if (expld
.dataseg
.phase
== exp_dataseg_end_seen
5540 && link_info
.relro
&& expld
.dataseg
.relro_end
)
5542 bfd_vma initial_base
, relro_end
, desired_end
;
5545 /* Compute the expected PT_GNU_RELRO segment end. */
5546 relro_end
= ((expld
.dataseg
.relro_end
+ expld
.dataseg
.pagesize
- 1)
5547 & ~(expld
.dataseg
.pagesize
- 1));
5549 /* Adjust by the offset arg of DATA_SEGMENT_RELRO_END. */
5550 desired_end
= relro_end
- expld
.dataseg
.relro_offset
;
5552 /* For sections in the relro segment.. */
5553 for (sec
= link_info
.output_bfd
->section_last
; sec
; sec
= sec
->prev
)
5554 if ((sec
->flags
& SEC_ALLOC
) != 0
5555 && sec
->vma
>= expld
.dataseg
.base
5556 && sec
->vma
< expld
.dataseg
.relro_end
- expld
.dataseg
.relro_offset
)
5558 /* Where do we want to put this section so that it ends as
5560 bfd_vma start
, end
, bump
;
5562 end
= start
= sec
->vma
;
5564 end
+= TO_ADDR (sec
->size
);
5565 bump
= desired_end
- end
;
5566 /* We'd like to increase START by BUMP, but we must heed
5567 alignment so the increase might be less than optimum. */
5569 start
&= ~(((bfd_vma
) 1 << sec
->alignment_power
) - 1);
5570 /* This is now the desired end for the previous section. */
5571 desired_end
= start
;
5574 expld
.dataseg
.phase
= exp_dataseg_relro_adjust
;
5575 ASSERT (desired_end
>= expld
.dataseg
.base
);
5576 initial_base
= expld
.dataseg
.base
;
5577 expld
.dataseg
.base
= desired_end
;
5578 lang_reset_memory_regions ();
5579 one_lang_size_sections_pass (relax
, check_regions
);
5581 if (expld
.dataseg
.relro_end
> relro_end
)
5583 /* Assignments to dot, or to output section address in a
5584 user script have increased padding over the original.
5586 expld
.dataseg
.base
= initial_base
;
5587 lang_reset_memory_regions ();
5588 one_lang_size_sections_pass (relax
, check_regions
);
5591 link_info
.relro_start
= expld
.dataseg
.base
;
5592 link_info
.relro_end
= expld
.dataseg
.relro_end
;
5594 else if (expld
.dataseg
.phase
== exp_dataseg_end_seen
)
5596 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
5597 a page could be saved in the data segment. */
5598 bfd_vma first
, last
;
5600 first
= -expld
.dataseg
.base
& (expld
.dataseg
.pagesize
- 1);
5601 last
= expld
.dataseg
.end
& (expld
.dataseg
.pagesize
- 1);
5603 && ((expld
.dataseg
.base
& ~(expld
.dataseg
.pagesize
- 1))
5604 != (expld
.dataseg
.end
& ~(expld
.dataseg
.pagesize
- 1)))
5605 && first
+ last
<= expld
.dataseg
.pagesize
)
5607 expld
.dataseg
.phase
= exp_dataseg_adjust
;
5608 lang_reset_memory_regions ();
5609 one_lang_size_sections_pass (relax
, check_regions
);
5612 expld
.dataseg
.phase
= exp_dataseg_done
;
5615 expld
.dataseg
.phase
= exp_dataseg_done
;
5618 static lang_output_section_statement_type
*current_section
;
5619 static lang_assignment_statement_type
*current_assign
;
5620 static bfd_boolean prefer_next_section
;
5622 /* Worker function for lang_do_assignments. Recursiveness goes here. */
5625 lang_do_assignments_1 (lang_statement_union_type
*s
,
5626 lang_output_section_statement_type
*current_os
,
5629 bfd_boolean
*found_end
)
5631 for (; s
!= NULL
; s
= s
->header
.next
)
5633 switch (s
->header
.type
)
5635 case lang_constructors_statement_enum
:
5636 dot
= lang_do_assignments_1 (constructor_list
.head
,
5637 current_os
, fill
, dot
, found_end
);
5640 case lang_output_section_statement_enum
:
5642 lang_output_section_statement_type
*os
;
5645 os
= &(s
->output_section_statement
);
5646 os
->after_end
= *found_end
;
5647 if (os
->bfd_section
!= NULL
&& !os
->ignored
)
5649 if ((os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5651 current_section
= os
;
5652 prefer_next_section
= FALSE
;
5654 dot
= os
->bfd_section
->vma
;
5656 newdot
= lang_do_assignments_1 (os
->children
.head
,
5657 os
, os
->fill
, dot
, found_end
);
5660 if (os
->bfd_section
!= NULL
)
5662 /* .tbss sections effectively have zero size. */
5663 if (!IS_TBSS (os
->bfd_section
)
5664 || bfd_link_relocatable (&link_info
))
5665 dot
+= TO_ADDR (os
->bfd_section
->size
);
5667 if (os
->update_dot_tree
!= NULL
)
5668 exp_fold_tree (os
->update_dot_tree
,
5669 bfd_abs_section_ptr
, &dot
);
5677 case lang_wild_statement_enum
:
5679 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
5680 current_os
, fill
, dot
, found_end
);
5683 case lang_object_symbols_statement_enum
:
5684 case lang_output_statement_enum
:
5685 case lang_target_statement_enum
:
5688 case lang_data_statement_enum
:
5689 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5690 if (expld
.result
.valid_p
)
5692 s
->data_statement
.value
= expld
.result
.value
;
5693 if (expld
.result
.section
!= NULL
)
5694 s
->data_statement
.value
+= expld
.result
.section
->vma
;
5696 else if (expld
.phase
== lang_final_phase_enum
)
5697 einfo (_("%F%P: invalid data statement\n"));
5700 switch (s
->data_statement
.type
)
5718 if (size
< TO_SIZE ((unsigned) 1))
5719 size
= TO_SIZE ((unsigned) 1);
5720 dot
+= TO_ADDR (size
);
5724 case lang_reloc_statement_enum
:
5725 exp_fold_tree (s
->reloc_statement
.addend_exp
,
5726 bfd_abs_section_ptr
, &dot
);
5727 if (expld
.result
.valid_p
)
5728 s
->reloc_statement
.addend_value
= expld
.result
.value
;
5729 else if (expld
.phase
== lang_final_phase_enum
)
5730 einfo (_("%F%P: invalid reloc statement\n"));
5731 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
5734 case lang_input_section_enum
:
5736 asection
*in
= s
->input_section
.section
;
5738 if ((in
->flags
& SEC_EXCLUDE
) == 0)
5739 dot
+= TO_ADDR (in
->size
);
5743 case lang_input_statement_enum
:
5746 case lang_fill_statement_enum
:
5747 fill
= s
->fill_statement
.fill
;
5750 case lang_assignment_statement_enum
:
5751 current_assign
= &s
->assignment_statement
;
5752 if (current_assign
->exp
->type
.node_class
!= etree_assert
)
5754 const char *p
= current_assign
->exp
->assign
.dst
;
5756 if (current_os
== abs_output_section
&& p
[0] == '.' && p
[1] == 0)
5757 prefer_next_section
= TRUE
;
5761 if (strcmp (p
, "end") == 0)
5764 exp_fold_tree (s
->assignment_statement
.exp
,
5765 (current_os
->bfd_section
!= NULL
5766 ? current_os
->bfd_section
: bfd_und_section_ptr
),
5770 case lang_padding_statement_enum
:
5771 dot
+= TO_ADDR (s
->padding_statement
.size
);
5774 case lang_group_statement_enum
:
5775 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
5776 current_os
, fill
, dot
, found_end
);
5779 case lang_insert_statement_enum
:
5782 case lang_address_statement_enum
:
5794 lang_do_assignments (lang_phase_type phase
)
5796 bfd_boolean found_end
= FALSE
;
5798 current_section
= NULL
;
5799 prefer_next_section
= FALSE
;
5800 expld
.phase
= phase
;
5801 lang_statement_iteration
++;
5802 lang_do_assignments_1 (statement_list
.head
,
5803 abs_output_section
, NULL
, 0, &found_end
);
5806 /* For an assignment statement outside of an output section statement,
5807 choose the best of neighbouring output sections to use for values
5811 section_for_dot (void)
5815 /* Assignments belong to the previous output section, unless there
5816 has been an assignment to "dot", in which case following
5817 assignments belong to the next output section. (The assumption
5818 is that an assignment to "dot" is setting up the address for the
5819 next output section.) Except that past the assignment to "_end"
5820 we always associate with the previous section. This exception is
5821 for targets like SH that define an alloc .stack or other
5822 weirdness after non-alloc sections. */
5823 if (current_section
== NULL
|| prefer_next_section
)
5825 lang_statement_union_type
*stmt
;
5826 lang_output_section_statement_type
*os
;
5828 for (stmt
= (lang_statement_union_type
*) current_assign
;
5830 stmt
= stmt
->header
.next
)
5831 if (stmt
->header
.type
== lang_output_section_statement_enum
)
5834 os
= &stmt
->output_section_statement
;
5837 && (os
->bfd_section
== NULL
5838 || (os
->bfd_section
->flags
& SEC_EXCLUDE
) != 0
5839 || bfd_section_removed_from_list (link_info
.output_bfd
,
5843 if (current_section
== NULL
|| os
== NULL
|| !os
->after_end
)
5846 s
= os
->bfd_section
;
5848 s
= link_info
.output_bfd
->section_last
;
5850 && ((s
->flags
& SEC_ALLOC
) == 0
5851 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
5856 return bfd_abs_section_ptr
;
5860 s
= current_section
->bfd_section
;
5862 /* The section may have been stripped. */
5864 && ((s
->flags
& SEC_EXCLUDE
) != 0
5865 || (s
->flags
& SEC_ALLOC
) == 0
5866 || (s
->flags
& SEC_THREAD_LOCAL
) != 0
5867 || bfd_section_removed_from_list (link_info
.output_bfd
, s
)))
5870 s
= link_info
.output_bfd
->sections
;
5872 && ((s
->flags
& SEC_ALLOC
) == 0
5873 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
5878 return bfd_abs_section_ptr
;
5881 /* Array of __start/__stop/.startof./.sizeof/ symbols. */
5883 static struct bfd_link_hash_entry
**start_stop_syms
;
5884 static size_t start_stop_count
= 0;
5885 static size_t start_stop_alloc
= 0;
5887 /* Give start/stop SYMBOL for SEC a preliminary definition, and add it
5888 to start_stop_syms. */
5891 lang_define_start_stop (const char *symbol
, asection
*sec
)
5893 struct bfd_link_hash_entry
*h
;
5895 h
= bfd_define_start_stop (link_info
.output_bfd
, &link_info
, symbol
, sec
);
5898 if (start_stop_count
== start_stop_alloc
)
5900 start_stop_alloc
= 2 * start_stop_alloc
+ 10;
5902 = xrealloc (start_stop_syms
,
5903 start_stop_alloc
* sizeof (*start_stop_syms
));
5905 start_stop_syms
[start_stop_count
++] = h
;
5909 /* Check for input sections whose names match references to
5910 __start_SECNAME or __stop_SECNAME symbols. Give the symbols
5911 preliminary definitions. */
5914 lang_init_start_stop (void)
5918 char leading_char
= bfd_get_symbol_leading_char (link_info
.output_bfd
);
5920 for (abfd
= link_info
.input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
5921 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
5924 const char *secname
= s
->name
;
5926 for (ps
= secname
; *ps
!= '\0'; ps
++)
5927 if (!ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
5931 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
5933 symbol
[0] = leading_char
;
5934 sprintf (symbol
+ (leading_char
!= 0), "__start_%s", secname
);
5935 lang_define_start_stop (symbol
, s
);
5937 symbol
[1] = leading_char
;
5938 memcpy (symbol
+ 1 + (leading_char
!= 0), "__stop", 6);
5939 lang_define_start_stop (symbol
+ 1, s
);
5946 /* Iterate over start_stop_syms. */
5949 foreach_start_stop (void (*func
) (struct bfd_link_hash_entry
*))
5953 for (i
= 0; i
< start_stop_count
; ++i
)
5954 func (start_stop_syms
[i
]);
5957 /* __start and __stop symbols are only supposed to be defined by the
5958 linker for orphan sections, but we now extend that to sections that
5959 map to an output section of the same name. The symbols were
5960 defined early for --gc-sections, before we mapped input to output
5961 sections, so undo those that don't satisfy this rule. */
5964 undef_start_stop (struct bfd_link_hash_entry
*h
)
5966 if (h
->ldscript_def
)
5969 if (h
->u
.def
.section
->output_section
== NULL
5970 || h
->u
.def
.section
->output_section
->owner
!= link_info
.output_bfd
5971 || strcmp (h
->u
.def
.section
->name
,
5972 h
->u
.def
.section
->output_section
->name
) != 0)
5974 h
->type
= bfd_link_hash_undefined
;
5975 h
->u
.undef
.abfd
= NULL
;
5980 lang_undef_start_stop (void)
5982 foreach_start_stop (undef_start_stop
);
5985 /* Check for output sections whose names match references to
5986 .startof.SECNAME or .sizeof.SECNAME symbols. Give the symbols
5987 preliminary definitions. */
5990 lang_init_startof_sizeof (void)
5994 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5996 const char *secname
= s
->name
;
5997 char *symbol
= (char *) xmalloc (10 + strlen (secname
));
5999 sprintf (symbol
, ".startof.%s", secname
);
6000 lang_define_start_stop (symbol
, s
);
6002 memcpy (symbol
+ 1, ".size", 5);
6003 lang_define_start_stop (symbol
+ 1, s
);
6008 /* Set .startof., .sizeof., __start and __stop symbols final values. */
6011 set_start_stop (struct bfd_link_hash_entry
*h
)
6014 || h
->type
!= bfd_link_hash_defined
)
6017 if (h
->root
.string
[0] == '.')
6019 /* .startof. or .sizeof. symbol.
6020 .startof. already has final value. */
6021 if (h
->root
.string
[2] == 'i')
6024 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6025 h
->u
.def
.section
= bfd_abs_section_ptr
;
6030 /* __start or __stop symbol. */
6031 int has_lead
= bfd_get_symbol_leading_char (link_info
.output_bfd
) != 0;
6033 h
->u
.def
.section
= h
->u
.def
.section
->output_section
;
6034 if (h
->root
.string
[4 + has_lead
] == 'o')
6037 h
->u
.def
.value
= TO_ADDR (h
->u
.def
.section
->size
);
6043 lang_finalize_start_stop (void)
6045 foreach_start_stop (set_start_stop
);
6051 struct bfd_link_hash_entry
*h
;
6054 if ((bfd_link_relocatable (&link_info
) && !link_info
.gc_sections
)
6055 || bfd_link_dll (&link_info
))
6056 warn
= entry_from_cmdline
;
6060 /* Force the user to specify a root when generating a relocatable with
6062 if (link_info
.gc_sections
&& bfd_link_relocatable (&link_info
)
6063 && !(entry_from_cmdline
|| undef_from_cmdline
))
6064 einfo (_("%P%F: gc-sections requires either an entry or "
6065 "an undefined symbol\n"));
6067 if (entry_symbol
.name
== NULL
)
6069 /* No entry has been specified. Look for the default entry, but
6070 don't warn if we don't find it. */
6071 entry_symbol
.name
= entry_symbol_default
;
6075 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
6076 FALSE
, FALSE
, TRUE
);
6078 && (h
->type
== bfd_link_hash_defined
6079 || h
->type
== bfd_link_hash_defweak
)
6080 && h
->u
.def
.section
->output_section
!= NULL
)
6084 val
= (h
->u
.def
.value
6085 + bfd_get_section_vma (link_info
.output_bfd
,
6086 h
->u
.def
.section
->output_section
)
6087 + h
->u
.def
.section
->output_offset
);
6088 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6089 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
.name
);
6096 /* We couldn't find the entry symbol. Try parsing it as a
6098 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
6101 if (!bfd_set_start_address (link_info
.output_bfd
, val
))
6102 einfo (_("%P%F: can't set start address\n"));
6108 /* Can't find the entry symbol, and it's not a number. Use
6109 the first address in the text section. */
6110 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
6114 einfo (_("%P: warning: cannot find entry symbol %s;"
6115 " defaulting to %V\n"),
6117 bfd_get_section_vma (link_info
.output_bfd
, ts
));
6118 if (!(bfd_set_start_address
6119 (link_info
.output_bfd
,
6120 bfd_get_section_vma (link_info
.output_bfd
, ts
))))
6121 einfo (_("%P%F: can't set start address\n"));
6126 einfo (_("%P: warning: cannot find entry symbol %s;"
6127 " not setting start address\n"),
6134 /* This is a small function used when we want to ignore errors from
6138 ignore_bfd_errors (const char *fmt ATTRIBUTE_UNUSED
,
6139 va_list ap ATTRIBUTE_UNUSED
)
6141 /* Don't do anything. */
6144 /* Check that the architecture of all the input files is compatible
6145 with the output file. Also call the backend to let it do any
6146 other checking that is needed. */
6151 lang_statement_union_type
*file
;
6153 const bfd_arch_info_type
*compatible
;
6155 for (file
= file_chain
.head
; file
!= NULL
; file
= file
->input_statement
.next
)
6157 #ifdef ENABLE_PLUGINS
6158 /* Don't check format of files claimed by plugin. */
6159 if (file
->input_statement
.flags
.claimed
)
6161 #endif /* ENABLE_PLUGINS */
6162 input_bfd
= file
->input_statement
.the_bfd
;
6164 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
6165 command_line
.accept_unknown_input_arch
);
6167 /* In general it is not possible to perform a relocatable
6168 link between differing object formats when the input
6169 file has relocations, because the relocations in the
6170 input format may not have equivalent representations in
6171 the output format (and besides BFD does not translate
6172 relocs for other link purposes than a final link). */
6173 if ((bfd_link_relocatable (&link_info
)
6174 || link_info
.emitrelocations
)
6175 && (compatible
== NULL
6176 || (bfd_get_flavour (input_bfd
)
6177 != bfd_get_flavour (link_info
.output_bfd
)))
6178 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
6180 einfo (_("%P%F: Relocatable linking with relocations from"
6181 " format %s (%B) to format %s (%B) is not supported\n"),
6182 bfd_get_target (input_bfd
), input_bfd
,
6183 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
6184 /* einfo with %F exits. */
6187 if (compatible
== NULL
)
6189 if (command_line
.warn_mismatch
)
6190 einfo (_("%P%X: %s architecture of input file `%B'"
6191 " is incompatible with %s output\n"),
6192 bfd_printable_name (input_bfd
), input_bfd
,
6193 bfd_printable_name (link_info
.output_bfd
));
6195 else if (bfd_count_sections (input_bfd
))
6197 /* If the input bfd has no contents, it shouldn't set the
6198 private data of the output bfd. */
6200 bfd_error_handler_type pfn
= NULL
;
6202 /* If we aren't supposed to warn about mismatched input
6203 files, temporarily set the BFD error handler to a
6204 function which will do nothing. We still want to call
6205 bfd_merge_private_bfd_data, since it may set up
6206 information which is needed in the output file. */
6207 if (!command_line
.warn_mismatch
)
6208 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
6209 if (!bfd_merge_private_bfd_data (input_bfd
, &link_info
))
6211 if (command_line
.warn_mismatch
)
6212 einfo (_("%P%X: failed to merge target specific data"
6213 " of file %B\n"), input_bfd
);
6215 if (!command_line
.warn_mismatch
)
6216 bfd_set_error_handler (pfn
);
6221 /* Look through all the global common symbols and attach them to the
6222 correct section. The -sort-common command line switch may be used
6223 to roughly sort the entries by alignment. */
6228 if (command_line
.inhibit_common_definition
)
6230 if (bfd_link_relocatable (&link_info
)
6231 && !command_line
.force_common_definition
)
6234 if (!config
.sort_common
)
6235 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
6240 if (config
.sort_common
== sort_descending
)
6242 for (power
= 4; power
> 0; power
--)
6243 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6246 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6250 for (power
= 0; power
<= 4; power
++)
6251 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6253 power
= (unsigned int) -1;
6254 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6259 /* Place one common symbol in the correct section. */
6262 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
6264 unsigned int power_of_two
;
6268 if (h
->type
!= bfd_link_hash_common
)
6272 power_of_two
= h
->u
.c
.p
->alignment_power
;
6274 if (config
.sort_common
== sort_descending
6275 && power_of_two
< *(unsigned int *) info
)
6277 else if (config
.sort_common
== sort_ascending
6278 && power_of_two
> *(unsigned int *) info
)
6281 section
= h
->u
.c
.p
->section
;
6282 if (!bfd_define_common_symbol (link_info
.output_bfd
, &link_info
, h
))
6283 einfo (_("%P%F: Could not define common symbol `%T': %E\n"),
6286 if (config
.map_file
!= NULL
)
6288 static bfd_boolean header_printed
;
6293 if (!header_printed
)
6295 minfo (_("\nAllocating common symbols\n"));
6296 minfo (_("Common symbol size file\n\n"));
6297 header_printed
= TRUE
;
6300 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
6301 DMGL_ANSI
| DMGL_PARAMS
);
6304 minfo ("%s", h
->root
.string
);
6305 len
= strlen (h
->root
.string
);
6310 len
= strlen (name
);
6326 if (size
<= 0xffffffff)
6327 sprintf (buf
, "%lx", (unsigned long) size
);
6329 sprintf_vma (buf
, size
);
6339 minfo ("%B\n", section
->owner
);
6345 /* Handle a single orphan section S, placing the orphan into an appropriate
6346 output section. The effects of the --orphan-handling command line
6347 option are handled here. */
6350 ldlang_place_orphan (asection
*s
)
6352 if (config
.orphan_handling
== orphan_handling_discard
)
6354 lang_output_section_statement_type
*os
;
6355 os
= lang_output_section_statement_lookup (DISCARD_SECTION_NAME
, 0,
6357 if (os
->addr_tree
== NULL
6358 && (bfd_link_relocatable (&link_info
)
6359 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6360 os
->addr_tree
= exp_intop (0);
6361 lang_add_section (&os
->children
, s
, NULL
, os
);
6365 lang_output_section_statement_type
*os
;
6366 const char *name
= s
->name
;
6369 if (config
.orphan_handling
== orphan_handling_error
)
6370 einfo ("%X%P: error: unplaced orphan section `%A' from `%B'.\n",
6373 if (config
.unique_orphan_sections
|| unique_section_p (s
, NULL
))
6374 constraint
= SPECIAL
;
6376 os
= ldemul_place_orphan (s
, name
, constraint
);
6379 os
= lang_output_section_statement_lookup (name
, constraint
, TRUE
);
6380 if (os
->addr_tree
== NULL
6381 && (bfd_link_relocatable (&link_info
)
6382 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6383 os
->addr_tree
= exp_intop (0);
6384 lang_add_section (&os
->children
, s
, NULL
, os
);
6387 if (config
.orphan_handling
== orphan_handling_warn
)
6388 einfo ("%P: warning: orphan section `%A' from `%B' being "
6389 "placed in section `%s'.\n",
6390 s
, s
->owner
, os
->name
);
6394 /* Run through the input files and ensure that every input section has
6395 somewhere to go. If one is found without a destination then create
6396 an input request and place it into the statement tree. */
6399 lang_place_orphans (void)
6401 LANG_FOR_EACH_INPUT_STATEMENT (file
)
6405 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6407 if (s
->output_section
== NULL
)
6409 /* This section of the file is not attached, root
6410 around for a sensible place for it to go. */
6412 if (file
->flags
.just_syms
)
6413 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
6414 else if ((s
->flags
& SEC_EXCLUDE
) != 0)
6415 s
->output_section
= bfd_abs_section_ptr
;
6416 else if (strcmp (s
->name
, "COMMON") == 0)
6418 /* This is a lonely common section which must have
6419 come from an archive. We attach to the section
6420 with the wildcard. */
6421 if (!bfd_link_relocatable (&link_info
)
6422 || command_line
.force_common_definition
)
6424 if (default_common_section
== NULL
)
6425 default_common_section
6426 = lang_output_section_statement_lookup (".bss", 0,
6428 lang_add_section (&default_common_section
->children
, s
,
6429 NULL
, default_common_section
);
6433 ldlang_place_orphan (s
);
6440 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
6442 flagword
*ptr_flags
;
6444 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
6450 /* PR 17900: An exclamation mark in the attributes reverses
6451 the sense of any of the attributes that follow. */
6454 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
6458 *ptr_flags
|= SEC_ALLOC
;
6462 *ptr_flags
|= SEC_READONLY
;
6466 *ptr_flags
|= SEC_DATA
;
6470 *ptr_flags
|= SEC_CODE
;
6475 *ptr_flags
|= SEC_LOAD
;
6479 einfo (_("%P%F: invalid character %c (%d) in flags\n"),
6487 /* Call a function on each input file. This function will be called
6488 on an archive, but not on the elements. */
6491 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
6493 lang_input_statement_type
*f
;
6495 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
6497 f
= (lang_input_statement_type
*) f
->next_real_file
)
6501 /* Call a function on each file. The function will be called on all
6502 the elements of an archive which are included in the link, but will
6503 not be called on the archive file itself. */
6506 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
6508 LANG_FOR_EACH_INPUT_STATEMENT (f
)
6515 ldlang_add_file (lang_input_statement_type
*entry
)
6517 lang_statement_append (&file_chain
,
6518 (lang_statement_union_type
*) entry
,
6521 /* The BFD linker needs to have a list of all input BFDs involved in
6523 ASSERT (entry
->the_bfd
->link
.next
== NULL
);
6524 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
6526 *link_info
.input_bfds_tail
= entry
->the_bfd
;
6527 link_info
.input_bfds_tail
= &entry
->the_bfd
->link
.next
;
6528 entry
->the_bfd
->usrdata
= entry
;
6529 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
6531 /* Look through the sections and check for any which should not be
6532 included in the link. We need to do this now, so that we can
6533 notice when the backend linker tries to report multiple
6534 definition errors for symbols which are in sections we aren't
6535 going to link. FIXME: It might be better to entirely ignore
6536 symbols which are defined in sections which are going to be
6537 discarded. This would require modifying the backend linker for
6538 each backend which might set the SEC_LINK_ONCE flag. If we do
6539 this, we should probably handle SEC_EXCLUDE in the same way. */
6541 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
6545 lang_add_output (const char *name
, int from_script
)
6547 /* Make -o on command line override OUTPUT in script. */
6548 if (!had_output_filename
|| !from_script
)
6550 output_filename
= name
;
6551 had_output_filename
= TRUE
;
6564 for (l
= 0; l
< 32; l
++)
6566 if (i
>= (unsigned int) x
)
6574 lang_output_section_statement_type
*
6575 lang_enter_output_section_statement (const char *output_section_statement_name
,
6576 etree_type
*address_exp
,
6577 enum section_type sectype
,
6579 etree_type
*subalign
,
6582 int align_with_input
)
6584 lang_output_section_statement_type
*os
;
6586 os
= lang_output_section_statement_lookup (output_section_statement_name
,
6588 current_section
= os
;
6590 if (os
->addr_tree
== NULL
)
6592 os
->addr_tree
= address_exp
;
6594 os
->sectype
= sectype
;
6595 if (sectype
!= noload_section
)
6596 os
->flags
= SEC_NO_FLAGS
;
6598 os
->flags
= SEC_NEVER_LOAD
;
6599 os
->block_value
= 1;
6601 /* Make next things chain into subchain of this. */
6602 push_stat_ptr (&os
->children
);
6604 os
->align_lma_with_input
= align_with_input
== ALIGN_WITH_INPUT
;
6605 if (os
->align_lma_with_input
&& align
!= NULL
)
6606 einfo (_("%F%P:%S: error: align with input and explicit align specified\n"),
6609 os
->subsection_alignment
=
6610 topower (exp_get_value_int (subalign
, -1, "subsection alignment"));
6611 os
->section_alignment
=
6612 topower (exp_get_value_int (align
, -1, "section alignment"));
6614 os
->load_base
= ebase
;
6621 lang_output_statement_type
*new_stmt
;
6623 new_stmt
= new_stat (lang_output_statement
, stat_ptr
);
6624 new_stmt
->name
= output_filename
;
6627 /* Reset the current counters in the regions. */
6630 lang_reset_memory_regions (void)
6632 lang_memory_region_type
*p
= lang_memory_region_list
;
6634 lang_output_section_statement_type
*os
;
6636 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
6638 p
->current
= p
->origin
;
6642 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
6646 os
->processed_vma
= FALSE
;
6647 os
->processed_lma
= FALSE
;
6650 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6652 /* Save the last size for possible use by bfd_relax_section. */
6653 o
->rawsize
= o
->size
;
6658 /* Worker for lang_gc_sections_1. */
6661 gc_section_callback (lang_wild_statement_type
*ptr
,
6662 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
6664 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
6665 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
6666 void *data ATTRIBUTE_UNUSED
)
6668 /* If the wild pattern was marked KEEP, the member sections
6669 should be as well. */
6670 if (ptr
->keep_sections
)
6671 section
->flags
|= SEC_KEEP
;
6674 /* Iterate over sections marking them against GC. */
6677 lang_gc_sections_1 (lang_statement_union_type
*s
)
6679 for (; s
!= NULL
; s
= s
->header
.next
)
6681 switch (s
->header
.type
)
6683 case lang_wild_statement_enum
:
6684 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
6686 case lang_constructors_statement_enum
:
6687 lang_gc_sections_1 (constructor_list
.head
);
6689 case lang_output_section_statement_enum
:
6690 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
6692 case lang_group_statement_enum
:
6693 lang_gc_sections_1 (s
->group_statement
.children
.head
);
6702 lang_gc_sections (void)
6704 /* Keep all sections so marked in the link script. */
6705 lang_gc_sections_1 (statement_list
.head
);
6707 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
6708 the special case of debug info. (See bfd/stabs.c)
6709 Twiddle the flag here, to simplify later linker code. */
6710 if (bfd_link_relocatable (&link_info
))
6712 LANG_FOR_EACH_INPUT_STATEMENT (f
)
6715 #ifdef ENABLE_PLUGINS
6716 if (f
->flags
.claimed
)
6719 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6720 if ((sec
->flags
& SEC_DEBUGGING
) == 0)
6721 sec
->flags
&= ~SEC_EXCLUDE
;
6725 if (link_info
.gc_sections
)
6726 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
6729 /* Worker for lang_find_relro_sections_1. */
6732 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
6733 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
6735 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
6736 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
6739 /* Discarded, excluded and ignored sections effectively have zero
6741 if (section
->output_section
!= NULL
6742 && section
->output_section
->owner
== link_info
.output_bfd
6743 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
6744 && !IGNORE_SECTION (section
)
6745 && section
->size
!= 0)
6747 bfd_boolean
*has_relro_section
= (bfd_boolean
*) data
;
6748 *has_relro_section
= TRUE
;
6752 /* Iterate over sections for relro sections. */
6755 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
6756 bfd_boolean
*has_relro_section
)
6758 if (*has_relro_section
)
6761 for (; s
!= NULL
; s
= s
->header
.next
)
6763 if (s
== expld
.dataseg
.relro_end_stat
)
6766 switch (s
->header
.type
)
6768 case lang_wild_statement_enum
:
6769 walk_wild (&s
->wild_statement
,
6770 find_relro_section_callback
,
6773 case lang_constructors_statement_enum
:
6774 lang_find_relro_sections_1 (constructor_list
.head
,
6777 case lang_output_section_statement_enum
:
6778 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
6781 case lang_group_statement_enum
:
6782 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
6792 lang_find_relro_sections (void)
6794 bfd_boolean has_relro_section
= FALSE
;
6796 /* Check all sections in the link script. */
6798 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
6799 &has_relro_section
);
6801 if (!has_relro_section
)
6802 link_info
.relro
= FALSE
;
6805 /* Relax all sections until bfd_relax_section gives up. */
6808 lang_relax_sections (bfd_boolean need_layout
)
6810 if (RELAXATION_ENABLED
)
6812 /* We may need more than one relaxation pass. */
6813 int i
= link_info
.relax_pass
;
6815 /* The backend can use it to determine the current pass. */
6816 link_info
.relax_pass
= 0;
6820 /* Keep relaxing until bfd_relax_section gives up. */
6821 bfd_boolean relax_again
;
6823 link_info
.relax_trip
= -1;
6826 link_info
.relax_trip
++;
6828 /* Note: pe-dll.c does something like this also. If you find
6829 you need to change this code, you probably need to change
6830 pe-dll.c also. DJ */
6832 /* Do all the assignments with our current guesses as to
6834 lang_do_assignments (lang_assigning_phase_enum
);
6836 /* We must do this after lang_do_assignments, because it uses
6838 lang_reset_memory_regions ();
6840 /* Perform another relax pass - this time we know where the
6841 globals are, so can make a better guess. */
6842 relax_again
= FALSE
;
6843 lang_size_sections (&relax_again
, FALSE
);
6845 while (relax_again
);
6847 link_info
.relax_pass
++;
6854 /* Final extra sizing to report errors. */
6855 lang_do_assignments (lang_assigning_phase_enum
);
6856 lang_reset_memory_regions ();
6857 lang_size_sections (NULL
, TRUE
);
6861 #ifdef ENABLE_PLUGINS
6862 /* Find the insert point for the plugin's replacement files. We
6863 place them after the first claimed real object file, or if the
6864 first claimed object is an archive member, after the last real
6865 object file immediately preceding the archive. In the event
6866 no objects have been claimed at all, we return the first dummy
6867 object file on the list as the insert point; that works, but
6868 the callee must be careful when relinking the file_chain as it
6869 is not actually on that chain, only the statement_list and the
6870 input_file list; in that case, the replacement files must be
6871 inserted at the head of the file_chain. */
6873 static lang_input_statement_type
*
6874 find_replacements_insert_point (void)
6876 lang_input_statement_type
*claim1
, *lastobject
;
6877 lastobject
= &input_file_chain
.head
->input_statement
;
6878 for (claim1
= &file_chain
.head
->input_statement
;
6880 claim1
= &claim1
->next
->input_statement
)
6882 if (claim1
->flags
.claimed
)
6883 return claim1
->flags
.claim_archive
? lastobject
: claim1
;
6884 /* Update lastobject if this is a real object file. */
6885 if (claim1
->the_bfd
!= NULL
&& claim1
->the_bfd
->my_archive
== NULL
)
6886 lastobject
= claim1
;
6888 /* No files were claimed by the plugin. Choose the last object
6889 file found on the list (maybe the first, dummy entry) as the
6894 /* Insert SRCLIST into DESTLIST after given element by chaining
6895 on FIELD as the next-pointer. (Counterintuitively does not need
6896 a pointer to the actual after-node itself, just its chain field.) */
6899 lang_list_insert_after (lang_statement_list_type
*destlist
,
6900 lang_statement_list_type
*srclist
,
6901 lang_statement_union_type
**field
)
6903 *(srclist
->tail
) = *field
;
6904 *field
= srclist
->head
;
6905 if (destlist
->tail
== field
)
6906 destlist
->tail
= srclist
->tail
;
6909 /* Detach new nodes added to DESTLIST since the time ORIGLIST
6910 was taken as a copy of it and leave them in ORIGLIST. */
6913 lang_list_remove_tail (lang_statement_list_type
*destlist
,
6914 lang_statement_list_type
*origlist
)
6916 union lang_statement_union
**savetail
;
6917 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
6918 ASSERT (origlist
->head
== destlist
->head
);
6919 savetail
= origlist
->tail
;
6920 origlist
->head
= *(savetail
);
6921 origlist
->tail
= destlist
->tail
;
6922 destlist
->tail
= savetail
;
6925 #endif /* ENABLE_PLUGINS */
6927 /* Add NAME to the list of garbage collection entry points. */
6930 lang_add_gc_name (const char *name
)
6932 struct bfd_sym_chain
*sym
;
6937 sym
= (struct bfd_sym_chain
*) stat_alloc (sizeof (*sym
));
6939 sym
->next
= link_info
.gc_sym_list
;
6941 link_info
.gc_sym_list
= sym
;
6944 /* Check relocations. */
6947 lang_check_relocs (void)
6949 if (link_info
.check_relocs_after_open_input
)
6953 for (abfd
= link_info
.input_bfds
;
6954 abfd
!= (bfd
*) NULL
; abfd
= abfd
->link
.next
)
6955 if (!bfd_link_check_relocs (abfd
, &link_info
))
6957 /* No object output, fail return. */
6958 config
.make_executable
= FALSE
;
6959 /* Note: we do not abort the loop, but rather
6960 continue the scan in case there are other
6961 bad relocations to report. */
6966 /* Look through all output sections looking for places where we can
6967 propagate forward the lma region. */
6970 lang_propagate_lma_regions (void)
6972 lang_output_section_statement_type
*os
;
6974 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
6978 if (os
->prev
!= NULL
6979 && os
->lma_region
== NULL
6980 && os
->load_base
== NULL
6981 && os
->addr_tree
== NULL
6982 && os
->region
== os
->prev
->region
)
6983 os
->lma_region
= os
->prev
->lma_region
;
6990 /* Finalize dynamic list. */
6991 if (link_info
.dynamic_list
)
6992 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
6994 current_target
= default_target
;
6996 /* Open the output file. */
6997 lang_for_each_statement (ldlang_open_output
);
7000 ldemul_create_output_section_statements ();
7002 /* Add to the hash table all undefineds on the command line. */
7003 lang_place_undefineds ();
7005 if (!bfd_section_already_linked_table_init ())
7006 einfo (_("%P%F: Failed to create hash table\n"));
7008 /* Create a bfd for each input file. */
7009 current_target
= default_target
;
7010 open_input_bfds (statement_list
.head
, OPEN_BFD_NORMAL
);
7012 #ifdef ENABLE_PLUGINS
7013 if (link_info
.lto_plugin_active
)
7015 lang_statement_list_type added
;
7016 lang_statement_list_type files
, inputfiles
;
7018 /* Now all files are read, let the plugin(s) decide if there
7019 are any more to be added to the link before we call the
7020 emulation's after_open hook. We create a private list of
7021 input statements for this purpose, which we will eventually
7022 insert into the global statement list after the first claimed
7025 /* We need to manipulate all three chains in synchrony. */
7027 inputfiles
= input_file_chain
;
7028 if (plugin_call_all_symbols_read ())
7029 einfo (_("%P%F: %s: plugin reported error after all symbols read\n"),
7030 plugin_error_plugin ());
7031 /* Open any newly added files, updating the file chains. */
7032 open_input_bfds (*added
.tail
, OPEN_BFD_NORMAL
);
7033 /* Restore the global list pointer now they have all been added. */
7034 lang_list_remove_tail (stat_ptr
, &added
);
7035 /* And detach the fresh ends of the file lists. */
7036 lang_list_remove_tail (&file_chain
, &files
);
7037 lang_list_remove_tail (&input_file_chain
, &inputfiles
);
7038 /* Were any new files added? */
7039 if (added
.head
!= NULL
)
7041 /* If so, we will insert them into the statement list immediately
7042 after the first input file that was claimed by the plugin. */
7043 plugin_insert
= find_replacements_insert_point ();
7044 /* If a plugin adds input files without having claimed any, we
7045 don't really have a good idea where to place them. Just putting
7046 them at the start or end of the list is liable to leave them
7047 outside the crtbegin...crtend range. */
7048 ASSERT (plugin_insert
!= NULL
);
7049 /* Splice the new statement list into the old one. */
7050 lang_list_insert_after (stat_ptr
, &added
,
7051 &plugin_insert
->header
.next
);
7052 /* Likewise for the file chains. */
7053 lang_list_insert_after (&input_file_chain
, &inputfiles
,
7054 &plugin_insert
->next_real_file
);
7055 /* We must be careful when relinking file_chain; we may need to
7056 insert the new files at the head of the list if the insert
7057 point chosen is the dummy first input file. */
7058 if (plugin_insert
->filename
)
7059 lang_list_insert_after (&file_chain
, &files
, &plugin_insert
->next
);
7061 lang_list_insert_after (&file_chain
, &files
, &file_chain
.head
);
7063 /* Rescan archives in case new undefined symbols have appeared. */
7064 open_input_bfds (statement_list
.head
, OPEN_BFD_RESCAN
);
7067 #endif /* ENABLE_PLUGINS */
7069 /* Make sure that nobody has tried to add a symbol to this list
7071 ASSERT (link_info
.gc_sym_list
== NULL
);
7073 link_info
.gc_sym_list
= &entry_symbol
;
7075 if (entry_symbol
.name
== NULL
)
7077 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
7079 /* entry_symbol is normally initialied by a ENTRY definition in the
7080 linker script or the -e command line option. But if neither of
7081 these have been used, the target specific backend may still have
7082 provided an entry symbol via a call to lang_default_entry().
7083 Unfortunately this value will not be processed until lang_end()
7084 is called, long after this function has finished. So detect this
7085 case here and add the target's entry symbol to the list of starting
7086 points for garbage collection resolution. */
7087 lang_add_gc_name (entry_symbol_default
);
7090 lang_add_gc_name (link_info
.init_function
);
7091 lang_add_gc_name (link_info
.fini_function
);
7093 ldemul_after_open ();
7094 if (config
.map_file
!= NULL
)
7095 lang_print_asneeded ();
7097 bfd_section_already_linked_table_free ();
7099 /* Make sure that we're not mixing architectures. We call this
7100 after all the input files have been opened, but before we do any
7101 other processing, so that any operations merge_private_bfd_data
7102 does on the output file will be known during the rest of the
7106 /* Handle .exports instead of a version script if we're told to do so. */
7107 if (command_line
.version_exports_section
)
7108 lang_do_version_exports_section ();
7110 /* Build all sets based on the information gathered from the input
7112 ldctor_build_sets ();
7114 /* Give initial values for __start and __stop symbols, so that ELF
7115 gc_sections will keep sections referenced by these symbols. Must
7116 be done before lang_do_assignments below. */
7117 if (config
.build_constructors
)
7118 lang_init_start_stop ();
7120 /* PR 13683: We must rerun the assignments prior to running garbage
7121 collection in order to make sure that all symbol aliases are resolved. */
7122 lang_do_assignments (lang_mark_phase_enum
);
7124 lang_do_memory_regions();
7125 expld
.phase
= lang_first_phase_enum
;
7127 /* Size up the common data. */
7130 /* Remove unreferenced sections if asked to. */
7131 lang_gc_sections ();
7133 /* Check relocations. */
7134 lang_check_relocs ();
7136 /* Update wild statements. */
7137 update_wild_statements (statement_list
.head
);
7139 /* Run through the contours of the script and attach input sections
7140 to the correct output sections. */
7141 lang_statement_iteration
++;
7142 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
7144 process_insert_statements ();
7146 /* Find any sections not attached explicitly and handle them. */
7147 lang_place_orphans ();
7149 if (!bfd_link_relocatable (&link_info
))
7153 /* Merge SEC_MERGE sections. This has to be done after GC of
7154 sections, so that GCed sections are not merged, but before
7155 assigning dynamic symbols, since removing whole input sections
7157 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
7159 /* Look for a text section and set the readonly attribute in it. */
7160 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
7164 if (config
.text_read_only
)
7165 found
->flags
|= SEC_READONLY
;
7167 found
->flags
&= ~SEC_READONLY
;
7171 /* Copy forward lma regions for output sections in same lma region. */
7172 lang_propagate_lma_regions ();
7174 /* Defining __start/__stop symbols early for --gc-sections to work
7175 around a glibc build problem can result in these symbols being
7176 defined when they should not be. Fix them now. */
7177 if (config
.build_constructors
)
7178 lang_undef_start_stop ();
7180 /* Define .startof./.sizeof. symbols with preliminary values before
7181 dynamic symbols are created. */
7182 if (!bfd_link_relocatable (&link_info
))
7183 lang_init_startof_sizeof ();
7185 /* Do anything special before sizing sections. This is where ELF
7186 and other back-ends size dynamic sections. */
7187 ldemul_before_allocation ();
7189 /* We must record the program headers before we try to fix the
7190 section positions, since they will affect SIZEOF_HEADERS. */
7191 lang_record_phdrs ();
7193 /* Check relro sections. */
7194 if (link_info
.relro
&& !bfd_link_relocatable (&link_info
))
7195 lang_find_relro_sections ();
7197 /* Size up the sections. */
7198 lang_size_sections (NULL
, !RELAXATION_ENABLED
);
7200 /* See if anything special should be done now we know how big
7201 everything is. This is where relaxation is done. */
7202 ldemul_after_allocation ();
7204 /* Fix any __start, __stop, .startof. or .sizeof. symbols. */
7205 lang_finalize_start_stop ();
7207 /* Do all the assignments, now that we know the final resting places
7208 of all the symbols. */
7209 lang_do_assignments (lang_final_phase_enum
);
7213 /* Convert absolute symbols to section relative. */
7214 ldexp_finalize_syms ();
7216 /* Make sure that the section addresses make sense. */
7217 if (command_line
.check_section_addresses
)
7218 lang_check_section_addresses ();
7220 /* Check any required symbols are known. */
7221 ldlang_check_require_defined_symbols ();
7226 /* EXPORTED TO YACC */
7229 lang_add_wild (struct wildcard_spec
*filespec
,
7230 struct wildcard_list
*section_list
,
7231 bfd_boolean keep_sections
)
7233 struct wildcard_list
*curr
, *next
;
7234 lang_wild_statement_type
*new_stmt
;
7236 /* Reverse the list as the parser puts it back to front. */
7237 for (curr
= section_list
, section_list
= NULL
;
7239 section_list
= curr
, curr
= next
)
7241 if (curr
->spec
.name
!= NULL
&& strcmp (curr
->spec
.name
, "COMMON") == 0)
7242 placed_commons
= TRUE
;
7245 curr
->next
= section_list
;
7248 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
7250 if (strcmp (filespec
->name
, "*") == 0)
7251 filespec
->name
= NULL
;
7252 else if (!wildcardp (filespec
->name
))
7253 lang_has_input_file
= TRUE
;
7256 new_stmt
= new_stat (lang_wild_statement
, stat_ptr
);
7257 new_stmt
->filename
= NULL
;
7258 new_stmt
->filenames_sorted
= FALSE
;
7259 new_stmt
->section_flag_list
= NULL
;
7260 new_stmt
->exclude_name_list
= NULL
;
7261 if (filespec
!= NULL
)
7263 new_stmt
->filename
= filespec
->name
;
7264 new_stmt
->filenames_sorted
= filespec
->sorted
== by_name
;
7265 new_stmt
->section_flag_list
= filespec
->section_flag_list
;
7266 new_stmt
->exclude_name_list
= filespec
->exclude_name_list
;
7268 new_stmt
->section_list
= section_list
;
7269 new_stmt
->keep_sections
= keep_sections
;
7270 lang_list_init (&new_stmt
->children
);
7271 analyze_walk_wild_section_handler (new_stmt
);
7275 lang_section_start (const char *name
, etree_type
*address
,
7276 const segment_type
*segment
)
7278 lang_address_statement_type
*ad
;
7280 ad
= new_stat (lang_address_statement
, stat_ptr
);
7281 ad
->section_name
= name
;
7282 ad
->address
= address
;
7283 ad
->segment
= segment
;
7286 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
7287 because of a -e argument on the command line, or zero if this is
7288 called by ENTRY in a linker script. Command line arguments take
7292 lang_add_entry (const char *name
, bfd_boolean cmdline
)
7294 if (entry_symbol
.name
== NULL
7296 || !entry_from_cmdline
)
7298 entry_symbol
.name
= name
;
7299 entry_from_cmdline
= cmdline
;
7303 /* Set the default start symbol to NAME. .em files should use this,
7304 not lang_add_entry, to override the use of "start" if neither the
7305 linker script nor the command line specifies an entry point. NAME
7306 must be permanently allocated. */
7308 lang_default_entry (const char *name
)
7310 entry_symbol_default
= name
;
7314 lang_add_target (const char *name
)
7316 lang_target_statement_type
*new_stmt
;
7318 new_stmt
= new_stat (lang_target_statement
, stat_ptr
);
7319 new_stmt
->target
= name
;
7323 lang_add_map (const char *name
)
7330 map_option_f
= TRUE
;
7338 lang_add_fill (fill_type
*fill
)
7340 lang_fill_statement_type
*new_stmt
;
7342 new_stmt
= new_stat (lang_fill_statement
, stat_ptr
);
7343 new_stmt
->fill
= fill
;
7347 lang_add_data (int type
, union etree_union
*exp
)
7349 lang_data_statement_type
*new_stmt
;
7351 new_stmt
= new_stat (lang_data_statement
, stat_ptr
);
7352 new_stmt
->exp
= exp
;
7353 new_stmt
->type
= type
;
7356 /* Create a new reloc statement. RELOC is the BFD relocation type to
7357 generate. HOWTO is the corresponding howto structure (we could
7358 look this up, but the caller has already done so). SECTION is the
7359 section to generate a reloc against, or NAME is the name of the
7360 symbol to generate a reloc against. Exactly one of SECTION and
7361 NAME must be NULL. ADDEND is an expression for the addend. */
7364 lang_add_reloc (bfd_reloc_code_real_type reloc
,
7365 reloc_howto_type
*howto
,
7368 union etree_union
*addend
)
7370 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
7374 p
->section
= section
;
7376 p
->addend_exp
= addend
;
7378 p
->addend_value
= 0;
7379 p
->output_section
= NULL
;
7380 p
->output_offset
= 0;
7383 lang_assignment_statement_type
*
7384 lang_add_assignment (etree_type
*exp
)
7386 lang_assignment_statement_type
*new_stmt
;
7388 new_stmt
= new_stat (lang_assignment_statement
, stat_ptr
);
7389 new_stmt
->exp
= exp
;
7394 lang_add_attribute (enum statement_enum attribute
)
7396 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
7400 lang_startup (const char *name
)
7402 if (first_file
->filename
!= NULL
)
7404 einfo (_("%P%F: multiple STARTUP files\n"));
7406 first_file
->filename
= name
;
7407 first_file
->local_sym_name
= name
;
7408 first_file
->flags
.real
= TRUE
;
7412 lang_float (bfd_boolean maybe
)
7414 lang_float_flag
= maybe
;
7418 /* Work out the load- and run-time regions from a script statement, and
7419 store them in *LMA_REGION and *REGION respectively.
7421 MEMSPEC is the name of the run-time region, or the value of
7422 DEFAULT_MEMORY_REGION if the statement didn't specify one.
7423 LMA_MEMSPEC is the name of the load-time region, or null if the
7424 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
7425 had an explicit load address.
7427 It is an error to specify both a load region and a load address. */
7430 lang_get_regions (lang_memory_region_type
**region
,
7431 lang_memory_region_type
**lma_region
,
7432 const char *memspec
,
7433 const char *lma_memspec
,
7434 bfd_boolean have_lma
,
7435 bfd_boolean have_vma
)
7437 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
7439 /* If no runtime region or VMA has been specified, but the load region
7440 has been specified, then use the load region for the runtime region
7442 if (lma_memspec
!= NULL
7444 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
7445 *region
= *lma_region
;
7447 *region
= lang_memory_region_lookup (memspec
, FALSE
);
7449 if (have_lma
&& lma_memspec
!= 0)
7450 einfo (_("%X%P:%S: section has both a load address and a load region\n"),
7455 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
7456 lang_output_section_phdr_list
*phdrs
,
7457 const char *lma_memspec
)
7459 lang_get_regions (¤t_section
->region
,
7460 ¤t_section
->lma_region
,
7461 memspec
, lma_memspec
,
7462 current_section
->load_base
!= NULL
,
7463 current_section
->addr_tree
!= NULL
);
7465 current_section
->fill
= fill
;
7466 current_section
->phdrs
= phdrs
;
7471 lang_statement_append (lang_statement_list_type
*list
,
7472 lang_statement_union_type
*element
,
7473 lang_statement_union_type
**field
)
7475 *(list
->tail
) = element
;
7479 /* Set the output format type. -oformat overrides scripts. */
7482 lang_add_output_format (const char *format
,
7487 if (output_target
== NULL
|| !from_script
)
7489 if (command_line
.endian
== ENDIAN_BIG
7492 else if (command_line
.endian
== ENDIAN_LITTLE
7496 output_target
= format
;
7501 lang_add_insert (const char *where
, int is_before
)
7503 lang_insert_statement_type
*new_stmt
;
7505 new_stmt
= new_stat (lang_insert_statement
, stat_ptr
);
7506 new_stmt
->where
= where
;
7507 new_stmt
->is_before
= is_before
;
7508 saved_script_handle
= previous_script_handle
;
7511 /* Enter a group. This creates a new lang_group_statement, and sets
7512 stat_ptr to build new statements within the group. */
7515 lang_enter_group (void)
7517 lang_group_statement_type
*g
;
7519 g
= new_stat (lang_group_statement
, stat_ptr
);
7520 lang_list_init (&g
->children
);
7521 push_stat_ptr (&g
->children
);
7524 /* Leave a group. This just resets stat_ptr to start writing to the
7525 regular list of statements again. Note that this will not work if
7526 groups can occur inside anything else which can adjust stat_ptr,
7527 but currently they can't. */
7530 lang_leave_group (void)
7535 /* Add a new program header. This is called for each entry in a PHDRS
7536 command in a linker script. */
7539 lang_new_phdr (const char *name
,
7541 bfd_boolean filehdr
,
7546 struct lang_phdr
*n
, **pp
;
7549 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
7552 n
->type
= exp_get_value_int (type
, 0, "program header type");
7553 n
->filehdr
= filehdr
;
7558 hdrs
= n
->type
== 1 && (phdrs
|| filehdr
);
7560 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
7563 && !((*pp
)->filehdr
|| (*pp
)->phdrs
))
7565 einfo (_("%X%P:%S: PHDRS and FILEHDR are not supported"
7566 " when prior PT_LOAD headers lack them\n"), NULL
);
7573 /* Record the program header information in the output BFD. FIXME: We
7574 should not be calling an ELF specific function here. */
7577 lang_record_phdrs (void)
7581 lang_output_section_phdr_list
*last
;
7582 struct lang_phdr
*l
;
7583 lang_output_section_statement_type
*os
;
7586 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
7589 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
7596 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
7600 lang_output_section_phdr_list
*pl
;
7602 if (os
->constraint
< 0)
7610 if (os
->sectype
== noload_section
7611 || os
->bfd_section
== NULL
7612 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
7615 /* Don't add orphans to PT_INTERP header. */
7621 lang_output_section_statement_type
*tmp_os
;
7623 /* If we have not run across a section with a program
7624 header assigned to it yet, then scan forwards to find
7625 one. This prevents inconsistencies in the linker's
7626 behaviour when a script has specified just a single
7627 header and there are sections in that script which are
7628 not assigned to it, and which occur before the first
7629 use of that header. See here for more details:
7630 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
7631 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
7634 last
= tmp_os
->phdrs
;
7638 einfo (_("%F%P: no sections assigned to phdrs\n"));
7643 if (os
->bfd_section
== NULL
)
7646 for (; pl
!= NULL
; pl
= pl
->next
)
7648 if (strcmp (pl
->name
, l
->name
) == 0)
7653 secs
= (asection
**) xrealloc (secs
,
7654 alc
* sizeof (asection
*));
7656 secs
[c
] = os
->bfd_section
;
7663 if (l
->flags
== NULL
)
7666 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
7671 at
= exp_get_vma (l
->at
, 0, "phdr load address");
7673 if (!bfd_record_phdr (link_info
.output_bfd
, l
->type
,
7674 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
7675 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
7676 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
7681 /* Make sure all the phdr assignments succeeded. */
7682 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
7686 lang_output_section_phdr_list
*pl
;
7688 if (os
->constraint
< 0
7689 || os
->bfd_section
== NULL
)
7692 for (pl
= os
->phdrs
;
7695 if (!pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
7696 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
7697 os
->name
, pl
->name
);
7701 /* Record a list of sections which may not be cross referenced. */
7704 lang_add_nocrossref (lang_nocrossref_type
*l
)
7706 struct lang_nocrossrefs
*n
;
7708 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
7709 n
->next
= nocrossref_list
;
7711 n
->onlyfirst
= FALSE
;
7712 nocrossref_list
= n
;
7714 /* Set notice_all so that we get informed about all symbols. */
7715 link_info
.notice_all
= TRUE
;
7718 /* Record a section that cannot be referenced from a list of sections. */
7721 lang_add_nocrossref_to (lang_nocrossref_type
*l
)
7723 lang_add_nocrossref (l
);
7724 nocrossref_list
->onlyfirst
= TRUE
;
7727 /* Overlay handling. We handle overlays with some static variables. */
7729 /* The overlay virtual address. */
7730 static etree_type
*overlay_vma
;
7731 /* And subsection alignment. */
7732 static etree_type
*overlay_subalign
;
7734 /* An expression for the maximum section size seen so far. */
7735 static etree_type
*overlay_max
;
7737 /* A list of all the sections in this overlay. */
7739 struct overlay_list
{
7740 struct overlay_list
*next
;
7741 lang_output_section_statement_type
*os
;
7744 static struct overlay_list
*overlay_list
;
7746 /* Start handling an overlay. */
7749 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
7751 /* The grammar should prevent nested overlays from occurring. */
7752 ASSERT (overlay_vma
== NULL
7753 && overlay_subalign
== NULL
7754 && overlay_max
== NULL
);
7756 overlay_vma
= vma_expr
;
7757 overlay_subalign
= subalign
;
7760 /* Start a section in an overlay. We handle this by calling
7761 lang_enter_output_section_statement with the correct VMA.
7762 lang_leave_overlay sets up the LMA and memory regions. */
7765 lang_enter_overlay_section (const char *name
)
7767 struct overlay_list
*n
;
7770 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
7771 0, overlay_subalign
, 0, 0, 0);
7773 /* If this is the first section, then base the VMA of future
7774 sections on this one. This will work correctly even if `.' is
7775 used in the addresses. */
7776 if (overlay_list
== NULL
)
7777 overlay_vma
= exp_nameop (ADDR
, name
);
7779 /* Remember the section. */
7780 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
7781 n
->os
= current_section
;
7782 n
->next
= overlay_list
;
7785 size
= exp_nameop (SIZEOF
, name
);
7787 /* Arrange to work out the maximum section end address. */
7788 if (overlay_max
== NULL
)
7791 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
7794 /* Finish a section in an overlay. There isn't any special to do
7798 lang_leave_overlay_section (fill_type
*fill
,
7799 lang_output_section_phdr_list
*phdrs
)
7806 name
= current_section
->name
;
7808 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
7809 region and that no load-time region has been specified. It doesn't
7810 really matter what we say here, since lang_leave_overlay will
7812 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
7814 /* Define the magic symbols. */
7816 clean
= (char *) xmalloc (strlen (name
) + 1);
7818 for (s1
= name
; *s1
!= '\0'; s1
++)
7819 if (ISALNUM (*s1
) || *s1
== '_')
7823 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_start_");
7824 sprintf (buf
, "__load_start_%s", clean
);
7825 lang_add_assignment (exp_provide (buf
,
7826 exp_nameop (LOADADDR
, name
),
7829 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_stop_");
7830 sprintf (buf
, "__load_stop_%s", clean
);
7831 lang_add_assignment (exp_provide (buf
,
7833 exp_nameop (LOADADDR
, name
),
7834 exp_nameop (SIZEOF
, name
)),
7840 /* Finish an overlay. If there are any overlay wide settings, this
7841 looks through all the sections in the overlay and sets them. */
7844 lang_leave_overlay (etree_type
*lma_expr
,
7847 const char *memspec
,
7848 lang_output_section_phdr_list
*phdrs
,
7849 const char *lma_memspec
)
7851 lang_memory_region_type
*region
;
7852 lang_memory_region_type
*lma_region
;
7853 struct overlay_list
*l
;
7854 lang_nocrossref_type
*nocrossref
;
7856 lang_get_regions (®ion
, &lma_region
,
7857 memspec
, lma_memspec
,
7858 lma_expr
!= NULL
, FALSE
);
7862 /* After setting the size of the last section, set '.' to end of the
7864 if (overlay_list
!= NULL
)
7866 overlay_list
->os
->update_dot
= 1;
7867 overlay_list
->os
->update_dot_tree
7868 = exp_assign (".", exp_binop ('+', overlay_vma
, overlay_max
), FALSE
);
7874 struct overlay_list
*next
;
7876 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
7879 l
->os
->region
= region
;
7880 l
->os
->lma_region
= lma_region
;
7882 /* The first section has the load address specified in the
7883 OVERLAY statement. The rest are worked out from that.
7884 The base address is not needed (and should be null) if
7885 an LMA region was specified. */
7888 l
->os
->load_base
= lma_expr
;
7889 l
->os
->sectype
= normal_section
;
7891 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
7892 l
->os
->phdrs
= phdrs
;
7896 lang_nocrossref_type
*nc
;
7898 nc
= (lang_nocrossref_type
*) xmalloc (sizeof *nc
);
7899 nc
->name
= l
->os
->name
;
7900 nc
->next
= nocrossref
;
7909 if (nocrossref
!= NULL
)
7910 lang_add_nocrossref (nocrossref
);
7913 overlay_list
= NULL
;
7917 /* Version handling. This is only useful for ELF. */
7919 /* If PREV is NULL, return first version pattern matching particular symbol.
7920 If PREV is non-NULL, return first version pattern matching particular
7921 symbol after PREV (previously returned by lang_vers_match). */
7923 static struct bfd_elf_version_expr
*
7924 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
7925 struct bfd_elf_version_expr
*prev
,
7929 const char *cxx_sym
= sym
;
7930 const char *java_sym
= sym
;
7931 struct bfd_elf_version_expr
*expr
= NULL
;
7932 enum demangling_styles curr_style
;
7934 curr_style
= CURRENT_DEMANGLING_STYLE
;
7935 cplus_demangle_set_style (no_demangling
);
7936 c_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_NO_OPTS
);
7939 cplus_demangle_set_style (curr_style
);
7941 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
7943 cxx_sym
= bfd_demangle (link_info
.output_bfd
, sym
,
7944 DMGL_PARAMS
| DMGL_ANSI
);
7948 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
7950 java_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_JAVA
);
7955 if (head
->htab
&& (prev
== NULL
|| prev
->literal
))
7957 struct bfd_elf_version_expr e
;
7959 switch (prev
? prev
->mask
: 0)
7962 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
7965 expr
= (struct bfd_elf_version_expr
*)
7966 htab_find ((htab_t
) head
->htab
, &e
);
7967 while (expr
&& strcmp (expr
->pattern
, c_sym
) == 0)
7968 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
7974 case BFD_ELF_VERSION_C_TYPE
:
7975 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
7977 e
.pattern
= cxx_sym
;
7978 expr
= (struct bfd_elf_version_expr
*)
7979 htab_find ((htab_t
) head
->htab
, &e
);
7980 while (expr
&& strcmp (expr
->pattern
, cxx_sym
) == 0)
7981 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
7987 case BFD_ELF_VERSION_CXX_TYPE
:
7988 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
7990 e
.pattern
= java_sym
;
7991 expr
= (struct bfd_elf_version_expr
*)
7992 htab_find ((htab_t
) head
->htab
, &e
);
7993 while (expr
&& strcmp (expr
->pattern
, java_sym
) == 0)
7994 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8005 /* Finally, try the wildcards. */
8006 if (prev
== NULL
|| prev
->literal
)
8007 expr
= head
->remaining
;
8010 for (; expr
; expr
= expr
->next
)
8017 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
8020 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
8022 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
8026 if (fnmatch (expr
->pattern
, s
, 0) == 0)
8032 free ((char *) c_sym
);
8034 free ((char *) cxx_sym
);
8035 if (java_sym
!= sym
)
8036 free ((char *) java_sym
);
8040 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
8041 return a pointer to the symbol name with any backslash quotes removed. */
8044 realsymbol (const char *pattern
)
8047 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
8048 char *s
, *symbol
= (char *) xmalloc (strlen (pattern
) + 1);
8050 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
8052 /* It is a glob pattern only if there is no preceding
8056 /* Remove the preceding backslash. */
8063 if (*p
== '?' || *p
== '*' || *p
== '[')
8070 backslash
= *p
== '\\';
8086 /* This is called for each variable name or match expression. NEW_NAME is
8087 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
8088 pattern to be matched against symbol names. */
8090 struct bfd_elf_version_expr
*
8091 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
8092 const char *new_name
,
8094 bfd_boolean literal_p
)
8096 struct bfd_elf_version_expr
*ret
;
8098 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
8102 ret
->literal
= TRUE
;
8103 ret
->pattern
= literal_p
? new_name
: realsymbol (new_name
);
8104 if (ret
->pattern
== NULL
)
8106 ret
->pattern
= new_name
;
8107 ret
->literal
= FALSE
;
8110 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
8111 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
8112 else if (strcasecmp (lang
, "C++") == 0)
8113 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
8114 else if (strcasecmp (lang
, "Java") == 0)
8115 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
8118 einfo (_("%X%P: unknown language `%s' in version information\n"),
8120 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
8123 return ldemul_new_vers_pattern (ret
);
8126 /* This is called for each set of variable names and match
8129 struct bfd_elf_version_tree
*
8130 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
8131 struct bfd_elf_version_expr
*locals
)
8133 struct bfd_elf_version_tree
*ret
;
8135 ret
= (struct bfd_elf_version_tree
*) xcalloc (1, sizeof *ret
);
8136 ret
->globals
.list
= globals
;
8137 ret
->locals
.list
= locals
;
8138 ret
->match
= lang_vers_match
;
8139 ret
->name_indx
= (unsigned int) -1;
8143 /* This static variable keeps track of version indices. */
8145 static int version_index
;
8148 version_expr_head_hash (const void *p
)
8150 const struct bfd_elf_version_expr
*e
=
8151 (const struct bfd_elf_version_expr
*) p
;
8153 return htab_hash_string (e
->pattern
);
8157 version_expr_head_eq (const void *p1
, const void *p2
)
8159 const struct bfd_elf_version_expr
*e1
=
8160 (const struct bfd_elf_version_expr
*) p1
;
8161 const struct bfd_elf_version_expr
*e2
=
8162 (const struct bfd_elf_version_expr
*) p2
;
8164 return strcmp (e1
->pattern
, e2
->pattern
) == 0;
8168 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
8171 struct bfd_elf_version_expr
*e
, *next
;
8172 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
8174 for (e
= head
->list
; e
; e
= e
->next
)
8178 head
->mask
|= e
->mask
;
8183 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
8184 version_expr_head_eq
, NULL
);
8185 list_loc
= &head
->list
;
8186 remaining_loc
= &head
->remaining
;
8187 for (e
= head
->list
; e
; e
= next
)
8193 remaining_loc
= &e
->next
;
8197 void **loc
= htab_find_slot ((htab_t
) head
->htab
, e
, INSERT
);
8201 struct bfd_elf_version_expr
*e1
, *last
;
8203 e1
= (struct bfd_elf_version_expr
*) *loc
;
8207 if (e1
->mask
== e
->mask
)
8215 while (e1
&& strcmp (e1
->pattern
, e
->pattern
) == 0);
8219 /* This is a duplicate. */
8220 /* FIXME: Memory leak. Sometimes pattern is not
8221 xmalloced alone, but in larger chunk of memory. */
8222 /* free (e->pattern); */
8227 e
->next
= last
->next
;
8235 list_loc
= &e
->next
;
8239 *remaining_loc
= NULL
;
8240 *list_loc
= head
->remaining
;
8243 head
->remaining
= head
->list
;
8246 /* This is called when we know the name and dependencies of the
8250 lang_register_vers_node (const char *name
,
8251 struct bfd_elf_version_tree
*version
,
8252 struct bfd_elf_version_deps
*deps
)
8254 struct bfd_elf_version_tree
*t
, **pp
;
8255 struct bfd_elf_version_expr
*e1
;
8260 if (link_info
.version_info
!= NULL
8261 && (name
[0] == '\0' || link_info
.version_info
->name
[0] == '\0'))
8263 einfo (_("%X%P: anonymous version tag cannot be combined"
8264 " with other version tags\n"));
8269 /* Make sure this node has a unique name. */
8270 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8271 if (strcmp (t
->name
, name
) == 0)
8272 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
8274 lang_finalize_version_expr_head (&version
->globals
);
8275 lang_finalize_version_expr_head (&version
->locals
);
8277 /* Check the global and local match names, and make sure there
8278 aren't any duplicates. */
8280 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
8282 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8284 struct bfd_elf_version_expr
*e2
;
8286 if (t
->locals
.htab
&& e1
->literal
)
8288 e2
= (struct bfd_elf_version_expr
*)
8289 htab_find ((htab_t
) t
->locals
.htab
, e1
);
8290 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
8292 if (e1
->mask
== e2
->mask
)
8293 einfo (_("%X%P: duplicate expression `%s'"
8294 " in version information\n"), e1
->pattern
);
8298 else if (!e1
->literal
)
8299 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
8300 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
8301 && e1
->mask
== e2
->mask
)
8302 einfo (_("%X%P: duplicate expression `%s'"
8303 " in version information\n"), e1
->pattern
);
8307 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
8309 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8311 struct bfd_elf_version_expr
*e2
;
8313 if (t
->globals
.htab
&& e1
->literal
)
8315 e2
= (struct bfd_elf_version_expr
*)
8316 htab_find ((htab_t
) t
->globals
.htab
, e1
);
8317 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
8319 if (e1
->mask
== e2
->mask
)
8320 einfo (_("%X%P: duplicate expression `%s'"
8321 " in version information\n"),
8326 else if (!e1
->literal
)
8327 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
8328 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
8329 && e1
->mask
== e2
->mask
)
8330 einfo (_("%X%P: duplicate expression `%s'"
8331 " in version information\n"), e1
->pattern
);
8335 version
->deps
= deps
;
8336 version
->name
= name
;
8337 if (name
[0] != '\0')
8340 version
->vernum
= version_index
;
8343 version
->vernum
= 0;
8345 for (pp
= &link_info
.version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
8350 /* This is called when we see a version dependency. */
8352 struct bfd_elf_version_deps
*
8353 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
8355 struct bfd_elf_version_deps
*ret
;
8356 struct bfd_elf_version_tree
*t
;
8358 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
8361 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8363 if (strcmp (t
->name
, name
) == 0)
8365 ret
->version_needed
= t
;
8370 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
8372 ret
->version_needed
= NULL
;
8377 lang_do_version_exports_section (void)
8379 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
8381 LANG_FOR_EACH_INPUT_STATEMENT (is
)
8383 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
8391 contents
= (char *) xmalloc (len
);
8392 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
8393 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
8396 while (p
< contents
+ len
)
8398 greg
= lang_new_vers_pattern (greg
, p
, NULL
, FALSE
);
8399 p
= strchr (p
, '\0') + 1;
8402 /* Do not free the contents, as we used them creating the regex. */
8404 /* Do not include this section in the link. */
8405 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
8408 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, FALSE
);
8409 lang_register_vers_node (command_line
.version_exports_section
,
8410 lang_new_vers_node (greg
, lreg
), NULL
);
8413 /* Evaluate LENGTH and ORIGIN parts of MEMORY spec */
8416 lang_do_memory_regions (void)
8418 lang_memory_region_type
*r
= lang_memory_region_list
;
8420 for (; r
!= NULL
; r
= r
->next
)
8424 exp_fold_tree_no_dot (r
->origin_exp
);
8425 if (expld
.result
.valid_p
)
8427 r
->origin
= expld
.result
.value
;
8428 r
->current
= r
->origin
;
8431 einfo (_("%F%P: invalid origin for memory region %s\n"),
8436 exp_fold_tree_no_dot (r
->length_exp
);
8437 if (expld
.result
.valid_p
)
8438 r
->length
= expld
.result
.value
;
8440 einfo (_("%F%P: invalid length for memory region %s\n"),
8447 lang_add_unique (const char *name
)
8449 struct unique_sections
*ent
;
8451 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
8452 if (strcmp (ent
->name
, name
) == 0)
8455 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
8456 ent
->name
= xstrdup (name
);
8457 ent
->next
= unique_section_list
;
8458 unique_section_list
= ent
;
8461 /* Append the list of dynamic symbols to the existing one. */
8464 lang_append_dynamic_list (struct bfd_elf_version_expr
*dynamic
)
8466 if (link_info
.dynamic_list
)
8468 struct bfd_elf_version_expr
*tail
;
8469 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
8471 tail
->next
= link_info
.dynamic_list
->head
.list
;
8472 link_info
.dynamic_list
->head
.list
= dynamic
;
8476 struct bfd_elf_dynamic_list
*d
;
8478 d
= (struct bfd_elf_dynamic_list
*) xcalloc (1, sizeof *d
);
8479 d
->head
.list
= dynamic
;
8480 d
->match
= lang_vers_match
;
8481 link_info
.dynamic_list
= d
;
8485 /* Append the list of C++ typeinfo dynamic symbols to the existing
8489 lang_append_dynamic_list_cpp_typeinfo (void)
8491 const char *symbols
[] =
8493 "typeinfo name for*",
8496 struct bfd_elf_version_expr
*dynamic
= NULL
;
8499 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
8500 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
8503 lang_append_dynamic_list (dynamic
);
8506 /* Append the list of C++ operator new and delete dynamic symbols to the
8510 lang_append_dynamic_list_cpp_new (void)
8512 const char *symbols
[] =
8517 struct bfd_elf_version_expr
*dynamic
= NULL
;
8520 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
8521 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
8524 lang_append_dynamic_list (dynamic
);
8527 /* Scan a space and/or comma separated string of features. */
8530 lang_ld_feature (char *str
)
8538 while (*p
== ',' || ISSPACE (*p
))
8543 while (*q
&& *q
!= ',' && !ISSPACE (*q
))
8547 if (strcasecmp (p
, "SANE_EXPR") == 0)
8548 config
.sane_expr
= TRUE
;
8550 einfo (_("%X%P: unknown feature `%s'\n"), p
);
8556 /* Pretty print memory amount. */
8559 lang_print_memory_size (bfd_vma sz
)
8561 if ((sz
& 0x3fffffff) == 0)
8562 printf ("%10" BFD_VMA_FMT
"u GB", sz
>> 30);
8563 else if ((sz
& 0xfffff) == 0)
8564 printf ("%10" BFD_VMA_FMT
"u MB", sz
>> 20);
8565 else if ((sz
& 0x3ff) == 0)
8566 printf ("%10" BFD_VMA_FMT
"u KB", sz
>> 10);
8568 printf (" %10" BFD_VMA_FMT
"u B", sz
);
8571 /* Implement --print-memory-usage: disply per region memory usage. */
8574 lang_print_memory_usage (void)
8576 lang_memory_region_type
*r
;
8578 printf ("Memory region Used Size Region Size %%age Used\n");
8579 for (r
= lang_memory_region_list
; r
->next
!= NULL
; r
= r
->next
)
8581 bfd_vma used_length
= r
->current
- r
->origin
;
8584 printf ("%16s: ",r
->name_list
.name
);
8585 lang_print_memory_size (used_length
);
8586 lang_print_memory_size ((bfd_vma
) r
->length
);
8588 percent
= used_length
* 100.0 / r
->length
;
8590 printf (" %6.2f%%\n", percent
);