1 /* Linker command language support.
2 Copyright (C) 1991-2015 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"
46 #endif /* ENABLE_PLUGINS */
49 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
52 /* Locals variables. */
53 static struct obstack stat_obstack
;
54 static struct obstack map_obstack
;
56 #define obstack_chunk_alloc xmalloc
57 #define obstack_chunk_free free
58 static const char *entry_symbol_default
= "start";
59 static bfd_boolean placed_commons
= FALSE
;
60 static bfd_boolean map_head_is_link_order
= FALSE
;
61 static lang_output_section_statement_type
*default_common_section
;
62 static bfd_boolean map_option_f
;
63 static bfd_vma print_dot
;
64 static lang_input_statement_type
*first_file
;
65 static const char *current_target
;
66 static lang_statement_list_type statement_list
;
67 static lang_statement_list_type
*stat_save
[10];
68 static lang_statement_list_type
**stat_save_ptr
= &stat_save
[0];
69 static struct unique_sections
*unique_section_list
;
70 static struct asneeded_minfo
*asneeded_list_head
;
72 /* Forward declarations. */
73 static void exp_init_os (etree_type
*);
74 static lang_input_statement_type
*lookup_name (const char *);
75 static void insert_undefined (const char *);
76 static bfd_boolean
sort_def_symbol (struct bfd_link_hash_entry
*, void *);
77 static void print_statement (lang_statement_union_type
*,
78 lang_output_section_statement_type
*);
79 static void print_statement_list (lang_statement_union_type
*,
80 lang_output_section_statement_type
*);
81 static void print_statements (void);
82 static void print_input_section (asection
*, bfd_boolean
);
83 static bfd_boolean
lang_one_common (struct bfd_link_hash_entry
*, void *);
84 static void lang_record_phdrs (void);
85 static void lang_do_version_exports_section (void);
86 static void lang_finalize_version_expr_head
87 (struct bfd_elf_version_expr_head
*);
88 static void lang_do_memory_regions (void);
90 /* Exported variables. */
91 const char *output_target
;
92 lang_output_section_statement_type
*abs_output_section
;
93 lang_statement_list_type lang_output_section_statement
;
94 lang_statement_list_type
*stat_ptr
= &statement_list
;
95 lang_statement_list_type file_chain
= { NULL
, NULL
};
96 lang_statement_list_type input_file_chain
;
97 struct bfd_sym_chain entry_symbol
= { NULL
, NULL
};
98 const char *entry_section
= ".text";
99 struct lang_input_statement_flags input_flags
;
100 bfd_boolean entry_from_cmdline
;
101 bfd_boolean undef_from_cmdline
;
102 bfd_boolean lang_has_input_file
= FALSE
;
103 bfd_boolean had_output_filename
= FALSE
;
104 bfd_boolean lang_float_flag
= FALSE
;
105 bfd_boolean delete_output_file_on_failure
= FALSE
;
106 struct lang_phdr
*lang_phdr_list
;
107 struct lang_nocrossrefs
*nocrossref_list
;
108 struct asneeded_minfo
**asneeded_list_tail
;
110 /* Functions that traverse the linker script and might evaluate
111 DEFINED() need to increment this at the start of the traversal. */
112 int lang_statement_iteration
= 0;
114 /* Return TRUE if the PATTERN argument is a wildcard pattern.
115 Although backslashes are treated specially if a pattern contains
116 wildcards, we do not consider the mere presence of a backslash to
117 be enough to cause the pattern to be treated as a wildcard.
118 That lets us handle DOS filenames more naturally. */
119 #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
121 #define new_stat(x, y) \
122 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
124 #define outside_section_address(q) \
125 ((q)->output_offset + (q)->output_section->vma)
127 #define outside_symbol_address(q) \
128 ((q)->value + outside_section_address (q->section))
130 #define SECTION_NAME_MAP_LENGTH (16)
133 stat_alloc (size_t size
)
135 return obstack_alloc (&stat_obstack
, size
);
139 name_match (const char *pattern
, const char *name
)
141 if (wildcardp (pattern
))
142 return fnmatch (pattern
, name
, 0);
143 return strcmp (pattern
, name
);
146 /* If PATTERN is of the form archive:file, return a pointer to the
147 separator. If not, return NULL. */
150 archive_path (const char *pattern
)
154 if (link_info
.path_separator
== 0)
157 p
= strchr (pattern
, link_info
.path_separator
);
158 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
159 if (p
== NULL
|| link_info
.path_separator
!= ':')
162 /* Assume a match on the second char is part of drive specifier,
163 as in "c:\silly.dos". */
164 if (p
== pattern
+ 1 && ISALPHA (*pattern
))
165 p
= strchr (p
+ 1, link_info
.path_separator
);
170 /* Given that FILE_SPEC results in a non-NULL SEP result from archive_path,
171 return whether F matches FILE_SPEC. */
174 input_statement_is_archive_path (const char *file_spec
, char *sep
,
175 lang_input_statement_type
*f
)
177 bfd_boolean match
= FALSE
;
180 || name_match (sep
+ 1, f
->filename
) == 0)
181 && ((sep
!= file_spec
)
182 == (f
->the_bfd
!= NULL
&& f
->the_bfd
->my_archive
!= NULL
)))
186 if (sep
!= file_spec
)
188 const char *aname
= f
->the_bfd
->my_archive
->filename
;
190 match
= name_match (file_spec
, aname
) == 0;
191 *sep
= link_info
.path_separator
;
198 unique_section_p (const asection
*sec
,
199 const lang_output_section_statement_type
*os
)
201 struct unique_sections
*unam
;
204 if (bfd_link_relocatable (&link_info
)
205 && sec
->owner
!= NULL
206 && bfd_is_group_section (sec
->owner
, sec
))
208 && strcmp (os
->name
, DISCARD_SECTION_NAME
) == 0);
211 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
212 if (name_match (unam
->name
, secnam
) == 0)
218 /* Generic traversal routines for finding matching sections. */
220 /* Try processing a section against a wildcard. This just calls
221 the callback unless the filename exclusion list is present
222 and excludes the file. It's hardly ever present so this
223 function is very fast. */
226 walk_wild_consider_section (lang_wild_statement_type
*ptr
,
227 lang_input_statement_type
*file
,
229 struct wildcard_list
*sec
,
233 struct name_list
*list_tmp
;
235 /* Don't process sections from files which were excluded. */
236 for (list_tmp
= sec
->spec
.exclude_name_list
;
238 list_tmp
= list_tmp
->next
)
240 char *p
= archive_path (list_tmp
->name
);
244 if (input_statement_is_archive_path (list_tmp
->name
, p
, file
))
248 else if (name_match (list_tmp
->name
, file
->filename
) == 0)
251 /* FIXME: Perhaps remove the following at some stage? Matching
252 unadorned archives like this was never documented and has
253 been superceded by the archive:path syntax. */
254 else if (file
->the_bfd
!= NULL
255 && file
->the_bfd
->my_archive
!= NULL
256 && name_match (list_tmp
->name
,
257 file
->the_bfd
->my_archive
->filename
) == 0)
261 (*callback
) (ptr
, sec
, s
, ptr
->section_flag_list
, file
, data
);
264 /* Lowest common denominator routine that can handle everything correctly,
268 walk_wild_section_general (lang_wild_statement_type
*ptr
,
269 lang_input_statement_type
*file
,
274 struct wildcard_list
*sec
;
276 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
278 sec
= ptr
->section_list
;
280 (*callback
) (ptr
, sec
, s
, ptr
->section_flag_list
, file
, data
);
284 bfd_boolean skip
= FALSE
;
286 if (sec
->spec
.name
!= NULL
)
288 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
290 skip
= name_match (sec
->spec
.name
, sname
) != 0;
294 walk_wild_consider_section (ptr
, file
, s
, sec
, callback
, data
);
301 /* Routines to find a single section given its name. If there's more
302 than one section with that name, we report that. */
306 asection
*found_section
;
307 bfd_boolean multiple_sections_found
;
308 } section_iterator_callback_data
;
311 section_iterator_callback (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*s
, void *data
)
313 section_iterator_callback_data
*d
= (section_iterator_callback_data
*) data
;
315 if (d
->found_section
!= NULL
)
317 d
->multiple_sections_found
= TRUE
;
321 d
->found_section
= s
;
326 find_section (lang_input_statement_type
*file
,
327 struct wildcard_list
*sec
,
328 bfd_boolean
*multiple_sections_found
)
330 section_iterator_callback_data cb_data
= { NULL
, FALSE
};
332 bfd_get_section_by_name_if (file
->the_bfd
, sec
->spec
.name
,
333 section_iterator_callback
, &cb_data
);
334 *multiple_sections_found
= cb_data
.multiple_sections_found
;
335 return cb_data
.found_section
;
338 /* Code for handling simple wildcards without going through fnmatch,
339 which can be expensive because of charset translations etc. */
341 /* A simple wild is a literal string followed by a single '*',
342 where the literal part is at least 4 characters long. */
345 is_simple_wild (const char *name
)
347 size_t len
= strcspn (name
, "*?[");
348 return len
>= 4 && name
[len
] == '*' && name
[len
+ 1] == '\0';
352 match_simple_wild (const char *pattern
, const char *name
)
354 /* The first four characters of the pattern are guaranteed valid
355 non-wildcard characters. So we can go faster. */
356 if (pattern
[0] != name
[0] || pattern
[1] != name
[1]
357 || pattern
[2] != name
[2] || pattern
[3] != name
[3])
362 while (*pattern
!= '*')
363 if (*name
++ != *pattern
++)
369 /* Return the numerical value of the init_priority attribute from
370 section name NAME. */
373 get_init_priority (const char *name
)
376 unsigned long init_priority
;
378 /* GCC uses the following section names for the init_priority
379 attribute with numerical values 101 and 65535 inclusive. A
380 lower value means a higher priority.
382 1: .init_array.NNNN/.fini_array.NNNN: Where NNNN is the
383 decimal numerical value of the init_priority attribute.
384 The order of execution in .init_array is forward and
385 .fini_array is backward.
386 2: .ctors.NNNN/.dtors.NNNN: Where NNNN is 65535 minus the
387 decimal numerical value of the init_priority attribute.
388 The order of execution in .ctors is backward and .dtors
391 if (strncmp (name
, ".init_array.", 12) == 0
392 || strncmp (name
, ".fini_array.", 12) == 0)
394 init_priority
= strtoul (name
+ 12, &end
, 10);
395 return *end
? 0 : init_priority
;
397 else if (strncmp (name
, ".ctors.", 7) == 0
398 || strncmp (name
, ".dtors.", 7) == 0)
400 init_priority
= strtoul (name
+ 7, &end
, 10);
401 return *end
? 0 : 65535 - init_priority
;
407 /* Compare sections ASEC and BSEC according to SORT. */
410 compare_section (sort_type sort
, asection
*asec
, asection
*bsec
)
413 unsigned long ainit_priority
, binit_priority
;
420 case by_init_priority
:
422 = get_init_priority (bfd_get_section_name (asec
->owner
, asec
));
424 = get_init_priority (bfd_get_section_name (bsec
->owner
, bsec
));
425 if (ainit_priority
== 0 || binit_priority
== 0)
427 ret
= ainit_priority
- binit_priority
;
433 case by_alignment_name
:
434 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
435 - bfd_section_alignment (asec
->owner
, asec
));
442 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
443 bfd_get_section_name (bsec
->owner
, bsec
));
446 case by_name_alignment
:
447 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
448 bfd_get_section_name (bsec
->owner
, bsec
));
454 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
455 - bfd_section_alignment (asec
->owner
, asec
));
462 /* Build a Binary Search Tree to sort sections, unlike insertion sort
463 used in wild_sort(). BST is considerably faster if the number of
464 of sections are large. */
466 static lang_section_bst_type
**
467 wild_sort_fast (lang_wild_statement_type
*wild
,
468 struct wildcard_list
*sec
,
469 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
472 lang_section_bst_type
**tree
;
475 if (!wild
->filenames_sorted
476 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
478 /* Append at the right end of tree. */
480 tree
= &((*tree
)->right
);
486 /* Find the correct node to append this section. */
487 if (compare_section (sec
->spec
.sorted
, section
, (*tree
)->section
) < 0)
488 tree
= &((*tree
)->left
);
490 tree
= &((*tree
)->right
);
496 /* Use wild_sort_fast to build a BST to sort sections. */
499 output_section_callback_fast (lang_wild_statement_type
*ptr
,
500 struct wildcard_list
*sec
,
502 struct flag_info
*sflag_list ATTRIBUTE_UNUSED
,
503 lang_input_statement_type
*file
,
506 lang_section_bst_type
*node
;
507 lang_section_bst_type
**tree
;
508 lang_output_section_statement_type
*os
;
510 os
= (lang_output_section_statement_type
*) output
;
512 if (unique_section_p (section
, os
))
515 node
= (lang_section_bst_type
*) xmalloc (sizeof (lang_section_bst_type
));
518 node
->section
= section
;
520 tree
= wild_sort_fast (ptr
, sec
, file
, section
);
525 /* Convert a sorted sections' BST back to list form. */
528 output_section_callback_tree_to_list (lang_wild_statement_type
*ptr
,
529 lang_section_bst_type
*tree
,
533 output_section_callback_tree_to_list (ptr
, tree
->left
, output
);
535 lang_add_section (&ptr
->children
, tree
->section
, NULL
,
536 (lang_output_section_statement_type
*) output
);
539 output_section_callback_tree_to_list (ptr
, tree
->right
, output
);
544 /* Specialized, optimized routines for handling different kinds of
548 walk_wild_section_specs1_wild0 (lang_wild_statement_type
*ptr
,
549 lang_input_statement_type
*file
,
553 /* We can just do a hash lookup for the section with the right name.
554 But if that lookup discovers more than one section with the name
555 (should be rare), we fall back to the general algorithm because
556 we would otherwise have to sort the sections to make sure they
557 get processed in the bfd's order. */
558 bfd_boolean multiple_sections_found
;
559 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
560 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
562 if (multiple_sections_found
)
563 walk_wild_section_general (ptr
, file
, callback
, data
);
565 walk_wild_consider_section (ptr
, file
, s0
, sec0
, callback
, data
);
569 walk_wild_section_specs1_wild1 (lang_wild_statement_type
*ptr
,
570 lang_input_statement_type
*file
,
575 struct wildcard_list
*wildsec0
= ptr
->handler_data
[0];
577 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
579 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
580 bfd_boolean skip
= !match_simple_wild (wildsec0
->spec
.name
, sname
);
583 walk_wild_consider_section (ptr
, file
, s
, wildsec0
, callback
, data
);
588 walk_wild_section_specs2_wild1 (lang_wild_statement_type
*ptr
,
589 lang_input_statement_type
*file
,
594 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
595 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
596 bfd_boolean multiple_sections_found
;
597 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
599 if (multiple_sections_found
)
601 walk_wild_section_general (ptr
, file
, callback
, data
);
605 /* Note that if the section was not found, s0 is NULL and
606 we'll simply never succeed the s == s0 test below. */
607 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
609 /* Recall that in this code path, a section cannot satisfy more
610 than one spec, so if s == s0 then it cannot match
613 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
616 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
617 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
620 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
,
627 walk_wild_section_specs3_wild2 (lang_wild_statement_type
*ptr
,
628 lang_input_statement_type
*file
,
633 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
634 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
635 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
636 bfd_boolean multiple_sections_found
;
637 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
639 if (multiple_sections_found
)
641 walk_wild_section_general (ptr
, file
, callback
, data
);
645 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
648 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
651 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
652 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
655 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
, data
);
658 skip
= !match_simple_wild (wildsec2
->spec
.name
, sname
);
660 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
668 walk_wild_section_specs4_wild2 (lang_wild_statement_type
*ptr
,
669 lang_input_statement_type
*file
,
674 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
675 struct wildcard_list
*sec1
= ptr
->handler_data
[1];
676 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
677 struct wildcard_list
*wildsec3
= ptr
->handler_data
[3];
678 bfd_boolean multiple_sections_found
;
679 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
), *s1
;
681 if (multiple_sections_found
)
683 walk_wild_section_general (ptr
, file
, callback
, data
);
687 s1
= find_section (file
, sec1
, &multiple_sections_found
);
688 if (multiple_sections_found
)
690 walk_wild_section_general (ptr
, file
, callback
, data
);
694 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
697 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
700 walk_wild_consider_section (ptr
, file
, s
, sec1
, callback
, data
);
703 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
704 bfd_boolean skip
= !match_simple_wild (wildsec2
->spec
.name
,
708 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
712 skip
= !match_simple_wild (wildsec3
->spec
.name
, sname
);
714 walk_wild_consider_section (ptr
, file
, s
, wildsec3
,
722 walk_wild_section (lang_wild_statement_type
*ptr
,
723 lang_input_statement_type
*file
,
727 if (file
->flags
.just_syms
)
730 (*ptr
->walk_wild_section_handler
) (ptr
, file
, callback
, data
);
733 /* Returns TRUE when name1 is a wildcard spec that might match
734 something name2 can match. We're conservative: we return FALSE
735 only if the prefixes of name1 and name2 are different up to the
736 first wildcard character. */
739 wild_spec_can_overlap (const char *name1
, const char *name2
)
741 size_t prefix1_len
= strcspn (name1
, "?*[");
742 size_t prefix2_len
= strcspn (name2
, "?*[");
743 size_t min_prefix_len
;
745 /* Note that if there is no wildcard character, then we treat the
746 terminating 0 as part of the prefix. Thus ".text" won't match
747 ".text." or ".text.*", for example. */
748 if (name1
[prefix1_len
] == '\0')
750 if (name2
[prefix2_len
] == '\0')
753 min_prefix_len
= prefix1_len
< prefix2_len
? prefix1_len
: prefix2_len
;
755 return memcmp (name1
, name2
, min_prefix_len
) == 0;
758 /* Select specialized code to handle various kinds of wildcard
762 analyze_walk_wild_section_handler (lang_wild_statement_type
*ptr
)
765 int wild_name_count
= 0;
766 struct wildcard_list
*sec
;
770 ptr
->walk_wild_section_handler
= walk_wild_section_general
;
771 ptr
->handler_data
[0] = NULL
;
772 ptr
->handler_data
[1] = NULL
;
773 ptr
->handler_data
[2] = NULL
;
774 ptr
->handler_data
[3] = NULL
;
777 /* Count how many wildcard_specs there are, and how many of those
778 actually use wildcards in the name. Also, bail out if any of the
779 wildcard names are NULL. (Can this actually happen?
780 walk_wild_section used to test for it.) And bail out if any
781 of the wildcards are more complex than a simple string
782 ending in a single '*'. */
783 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
786 if (sec
->spec
.name
== NULL
)
788 if (wildcardp (sec
->spec
.name
))
791 if (!is_simple_wild (sec
->spec
.name
))
796 /* The zero-spec case would be easy to optimize but it doesn't
797 happen in practice. Likewise, more than 4 specs doesn't
798 happen in practice. */
799 if (sec_count
== 0 || sec_count
> 4)
802 /* Check that no two specs can match the same section. */
803 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
805 struct wildcard_list
*sec2
;
806 for (sec2
= sec
->next
; sec2
!= NULL
; sec2
= sec2
->next
)
808 if (wild_spec_can_overlap (sec
->spec
.name
, sec2
->spec
.name
))
813 signature
= (sec_count
<< 8) + wild_name_count
;
817 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild0
;
820 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild1
;
823 ptr
->walk_wild_section_handler
= walk_wild_section_specs2_wild1
;
826 ptr
->walk_wild_section_handler
= walk_wild_section_specs3_wild2
;
829 ptr
->walk_wild_section_handler
= walk_wild_section_specs4_wild2
;
835 /* Now fill the data array with pointers to the specs, first the
836 specs with non-wildcard names, then the specs with wildcard
837 names. It's OK to process the specs in different order from the
838 given order, because we've already determined that no section
839 will match more than one spec. */
841 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
842 if (!wildcardp (sec
->spec
.name
))
843 ptr
->handler_data
[data_counter
++] = sec
;
844 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
845 if (wildcardp (sec
->spec
.name
))
846 ptr
->handler_data
[data_counter
++] = sec
;
849 /* Handle a wild statement for a single file F. */
852 walk_wild_file (lang_wild_statement_type
*s
,
853 lang_input_statement_type
*f
,
857 if (f
->the_bfd
== NULL
858 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
859 walk_wild_section (s
, f
, callback
, data
);
864 /* This is an archive file. We must map each member of the
865 archive separately. */
866 member
= bfd_openr_next_archived_file (f
->the_bfd
, NULL
);
867 while (member
!= NULL
)
869 /* When lookup_name is called, it will call the add_symbols
870 entry point for the archive. For each element of the
871 archive which is included, BFD will call ldlang_add_file,
872 which will set the usrdata field of the member to the
873 lang_input_statement. */
874 if (member
->usrdata
!= NULL
)
876 walk_wild_section (s
,
877 (lang_input_statement_type
*) member
->usrdata
,
881 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
887 walk_wild (lang_wild_statement_type
*s
, callback_t callback
, void *data
)
889 const char *file_spec
= s
->filename
;
892 if (file_spec
== NULL
)
894 /* Perform the iteration over all files in the list. */
895 LANG_FOR_EACH_INPUT_STATEMENT (f
)
897 walk_wild_file (s
, f
, callback
, data
);
900 else if ((p
= archive_path (file_spec
)) != NULL
)
902 LANG_FOR_EACH_INPUT_STATEMENT (f
)
904 if (input_statement_is_archive_path (file_spec
, p
, f
))
905 walk_wild_file (s
, f
, callback
, data
);
908 else if (wildcardp (file_spec
))
910 LANG_FOR_EACH_INPUT_STATEMENT (f
)
912 if (fnmatch (file_spec
, f
->filename
, 0) == 0)
913 walk_wild_file (s
, f
, callback
, data
);
918 lang_input_statement_type
*f
;
920 /* Perform the iteration over a single file. */
921 f
= lookup_name (file_spec
);
923 walk_wild_file (s
, f
, callback
, data
);
927 /* lang_for_each_statement walks the parse tree and calls the provided
928 function for each node, except those inside output section statements
929 with constraint set to -1. */
932 lang_for_each_statement_worker (void (*func
) (lang_statement_union_type
*),
933 lang_statement_union_type
*s
)
935 for (; s
!= NULL
; s
= s
->header
.next
)
939 switch (s
->header
.type
)
941 case lang_constructors_statement_enum
:
942 lang_for_each_statement_worker (func
, constructor_list
.head
);
944 case lang_output_section_statement_enum
:
945 if (s
->output_section_statement
.constraint
!= -1)
946 lang_for_each_statement_worker
947 (func
, s
->output_section_statement
.children
.head
);
949 case lang_wild_statement_enum
:
950 lang_for_each_statement_worker (func
,
951 s
->wild_statement
.children
.head
);
953 case lang_group_statement_enum
:
954 lang_for_each_statement_worker (func
,
955 s
->group_statement
.children
.head
);
957 case lang_data_statement_enum
:
958 case lang_reloc_statement_enum
:
959 case lang_object_symbols_statement_enum
:
960 case lang_output_statement_enum
:
961 case lang_target_statement_enum
:
962 case lang_input_section_enum
:
963 case lang_input_statement_enum
:
964 case lang_assignment_statement_enum
:
965 case lang_padding_statement_enum
:
966 case lang_address_statement_enum
:
967 case lang_fill_statement_enum
:
968 case lang_insert_statement_enum
:
978 lang_for_each_statement (void (*func
) (lang_statement_union_type
*))
980 lang_for_each_statement_worker (func
, statement_list
.head
);
983 /*----------------------------------------------------------------------*/
986 lang_list_init (lang_statement_list_type
*list
)
989 list
->tail
= &list
->head
;
993 push_stat_ptr (lang_statement_list_type
*new_ptr
)
995 if (stat_save_ptr
>= stat_save
+ sizeof (stat_save
) / sizeof (stat_save
[0]))
997 *stat_save_ptr
++ = stat_ptr
;
1004 if (stat_save_ptr
<= stat_save
)
1006 stat_ptr
= *--stat_save_ptr
;
1009 /* Build a new statement node for the parse tree. */
1011 static lang_statement_union_type
*
1012 new_statement (enum statement_enum type
,
1014 lang_statement_list_type
*list
)
1016 lang_statement_union_type
*new_stmt
;
1018 new_stmt
= (lang_statement_union_type
*) stat_alloc (size
);
1019 new_stmt
->header
.type
= type
;
1020 new_stmt
->header
.next
= NULL
;
1021 lang_statement_append (list
, new_stmt
, &new_stmt
->header
.next
);
1025 /* Build a new input file node for the language. There are several
1026 ways in which we treat an input file, eg, we only look at symbols,
1027 or prefix it with a -l etc.
1029 We can be supplied with requests for input files more than once;
1030 they may, for example be split over several lines like foo.o(.text)
1031 foo.o(.data) etc, so when asked for a file we check that we haven't
1032 got it already so we don't duplicate the bfd. */
1034 static lang_input_statement_type
*
1035 new_afile (const char *name
,
1036 lang_input_file_enum_type file_type
,
1038 bfd_boolean add_to_list
)
1040 lang_input_statement_type
*p
;
1042 lang_has_input_file
= TRUE
;
1045 p
= (lang_input_statement_type
*) new_stat (lang_input_statement
, stat_ptr
);
1048 p
= (lang_input_statement_type
*)
1049 stat_alloc (sizeof (lang_input_statement_type
));
1050 p
->header
.type
= lang_input_statement_enum
;
1051 p
->header
.next
= NULL
;
1054 memset (&p
->the_bfd
, 0,
1055 sizeof (*p
) - offsetof (lang_input_statement_type
, the_bfd
));
1057 p
->flags
.dynamic
= input_flags
.dynamic
;
1058 p
->flags
.add_DT_NEEDED_for_dynamic
= input_flags
.add_DT_NEEDED_for_dynamic
;
1059 p
->flags
.add_DT_NEEDED_for_regular
= input_flags
.add_DT_NEEDED_for_regular
;
1060 p
->flags
.whole_archive
= input_flags
.whole_archive
;
1061 p
->flags
.sysrooted
= input_flags
.sysrooted
;
1065 case lang_input_file_is_symbols_only_enum
:
1067 p
->local_sym_name
= name
;
1068 p
->flags
.real
= TRUE
;
1069 p
->flags
.just_syms
= TRUE
;
1071 case lang_input_file_is_fake_enum
:
1073 p
->local_sym_name
= name
;
1075 case lang_input_file_is_l_enum
:
1076 if (name
[0] == ':' && name
[1] != '\0')
1078 p
->filename
= name
+ 1;
1079 p
->flags
.full_name_provided
= TRUE
;
1083 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
1084 p
->flags
.maybe_archive
= TRUE
;
1085 p
->flags
.real
= TRUE
;
1086 p
->flags
.search_dirs
= TRUE
;
1088 case lang_input_file_is_marker_enum
:
1090 p
->local_sym_name
= name
;
1091 p
->flags
.search_dirs
= TRUE
;
1093 case lang_input_file_is_search_file_enum
:
1095 p
->local_sym_name
= name
;
1096 p
->flags
.real
= TRUE
;
1097 p
->flags
.search_dirs
= TRUE
;
1099 case lang_input_file_is_file_enum
:
1101 p
->local_sym_name
= name
;
1102 p
->flags
.real
= TRUE
;
1108 lang_statement_append (&input_file_chain
,
1109 (lang_statement_union_type
*) p
,
1110 &p
->next_real_file
);
1114 lang_input_statement_type
*
1115 lang_add_input_file (const char *name
,
1116 lang_input_file_enum_type file_type
,
1119 if (name
!= NULL
&& *name
== '=')
1121 lang_input_statement_type
*ret
;
1122 char *sysrooted_name
1123 = concat (ld_sysroot
, name
+ 1, (const char *) NULL
);
1125 /* We've now forcibly prepended the sysroot, making the input
1126 file independent of the context. Therefore, temporarily
1127 force a non-sysrooted context for this statement, so it won't
1128 get the sysroot prepended again when opened. (N.B. if it's a
1129 script, any child nodes with input files starting with "/"
1130 will be handled as "sysrooted" as they'll be found to be
1131 within the sysroot subdirectory.) */
1132 unsigned int outer_sysrooted
= input_flags
.sysrooted
;
1133 input_flags
.sysrooted
= 0;
1134 ret
= new_afile (sysrooted_name
, file_type
, target
, TRUE
);
1135 input_flags
.sysrooted
= outer_sysrooted
;
1139 return new_afile (name
, file_type
, target
, TRUE
);
1142 struct out_section_hash_entry
1144 struct bfd_hash_entry root
;
1145 lang_statement_union_type s
;
1148 /* The hash table. */
1150 static struct bfd_hash_table output_section_statement_table
;
1152 /* Support routines for the hash table used by lang_output_section_find,
1153 initialize the table, fill in an entry and remove the table. */
1155 static struct bfd_hash_entry
*
1156 output_section_statement_newfunc (struct bfd_hash_entry
*entry
,
1157 struct bfd_hash_table
*table
,
1160 lang_output_section_statement_type
**nextp
;
1161 struct out_section_hash_entry
*ret
;
1165 entry
= (struct bfd_hash_entry
*) bfd_hash_allocate (table
,
1171 entry
= bfd_hash_newfunc (entry
, table
, string
);
1175 ret
= (struct out_section_hash_entry
*) entry
;
1176 memset (&ret
->s
, 0, sizeof (ret
->s
));
1177 ret
->s
.header
.type
= lang_output_section_statement_enum
;
1178 ret
->s
.output_section_statement
.subsection_alignment
= -1;
1179 ret
->s
.output_section_statement
.section_alignment
= -1;
1180 ret
->s
.output_section_statement
.block_value
= 1;
1181 lang_list_init (&ret
->s
.output_section_statement
.children
);
1182 lang_statement_append (stat_ptr
, &ret
->s
, &ret
->s
.header
.next
);
1184 /* For every output section statement added to the list, except the
1185 first one, lang_output_section_statement.tail points to the "next"
1186 field of the last element of the list. */
1187 if (lang_output_section_statement
.head
!= NULL
)
1188 ret
->s
.output_section_statement
.prev
1189 = ((lang_output_section_statement_type
*)
1190 ((char *) lang_output_section_statement
.tail
1191 - offsetof (lang_output_section_statement_type
, next
)));
1193 /* GCC's strict aliasing rules prevent us from just casting the
1194 address, so we store the pointer in a variable and cast that
1196 nextp
= &ret
->s
.output_section_statement
.next
;
1197 lang_statement_append (&lang_output_section_statement
,
1199 (lang_statement_union_type
**) nextp
);
1204 output_section_statement_table_init (void)
1206 if (!bfd_hash_table_init_n (&output_section_statement_table
,
1207 output_section_statement_newfunc
,
1208 sizeof (struct out_section_hash_entry
),
1210 einfo (_("%P%F: can not create hash table: %E\n"));
1214 output_section_statement_table_free (void)
1216 bfd_hash_table_free (&output_section_statement_table
);
1219 /* Build enough state so that the parser can build its tree. */
1224 obstack_begin (&stat_obstack
, 1000);
1226 stat_ptr
= &statement_list
;
1228 output_section_statement_table_init ();
1230 lang_list_init (stat_ptr
);
1232 lang_list_init (&input_file_chain
);
1233 lang_list_init (&lang_output_section_statement
);
1234 lang_list_init (&file_chain
);
1235 first_file
= lang_add_input_file (NULL
, lang_input_file_is_marker_enum
,
1237 abs_output_section
=
1238 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
, 0, TRUE
);
1240 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
1242 asneeded_list_head
= NULL
;
1243 asneeded_list_tail
= &asneeded_list_head
;
1249 output_section_statement_table_free ();
1252 /*----------------------------------------------------------------------
1253 A region is an area of memory declared with the
1254 MEMORY { name:org=exp, len=exp ... }
1257 We maintain a list of all the regions here.
1259 If no regions are specified in the script, then the default is used
1260 which is created when looked up to be the entire data space.
1262 If create is true we are creating a region inside a MEMORY block.
1263 In this case it is probably an error to create a region that has
1264 already been created. If we are not inside a MEMORY block it is
1265 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1266 and so we issue a warning.
1268 Each region has at least one name. The first name is either
1269 DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add
1270 alias names to an existing region within a script with
1271 REGION_ALIAS (alias, region_name). Each name corresponds to at most one
1274 static lang_memory_region_type
*lang_memory_region_list
;
1275 static lang_memory_region_type
**lang_memory_region_list_tail
1276 = &lang_memory_region_list
;
1278 lang_memory_region_type
*
1279 lang_memory_region_lookup (const char *const name
, bfd_boolean create
)
1281 lang_memory_region_name
*n
;
1282 lang_memory_region_type
*r
;
1283 lang_memory_region_type
*new_region
;
1285 /* NAME is NULL for LMA memspecs if no region was specified. */
1289 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1290 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1291 if (strcmp (n
->name
, name
) == 0)
1294 einfo (_("%P:%S: warning: redeclaration of memory region `%s'\n"),
1299 if (!create
&& strcmp (name
, DEFAULT_MEMORY_REGION
))
1300 einfo (_("%P:%S: warning: memory region `%s' not declared\n"),
1303 new_region
= (lang_memory_region_type
*)
1304 stat_alloc (sizeof (lang_memory_region_type
));
1306 new_region
->name_list
.name
= xstrdup (name
);
1307 new_region
->name_list
.next
= NULL
;
1308 new_region
->next
= NULL
;
1309 new_region
->origin_exp
= NULL
;
1310 new_region
->origin
= 0;
1311 new_region
->length_exp
= NULL
;
1312 new_region
->length
= ~(bfd_size_type
) 0;
1313 new_region
->current
= 0;
1314 new_region
->last_os
= NULL
;
1315 new_region
->flags
= 0;
1316 new_region
->not_flags
= 0;
1317 new_region
->had_full_message
= FALSE
;
1319 *lang_memory_region_list_tail
= new_region
;
1320 lang_memory_region_list_tail
= &new_region
->next
;
1326 lang_memory_region_alias (const char * alias
, const char * region_name
)
1328 lang_memory_region_name
* n
;
1329 lang_memory_region_type
* r
;
1330 lang_memory_region_type
* region
;
1332 /* The default region must be unique. This ensures that it is not necessary
1333 to iterate through the name list if someone wants the check if a region is
1334 the default memory region. */
1335 if (strcmp (region_name
, DEFAULT_MEMORY_REGION
) == 0
1336 || strcmp (alias
, DEFAULT_MEMORY_REGION
) == 0)
1337 einfo (_("%F%P:%S: error: alias for default memory region\n"), NULL
);
1339 /* Look for the target region and check if the alias is not already
1342 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1343 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1345 if (region
== NULL
&& strcmp (n
->name
, region_name
) == 0)
1347 if (strcmp (n
->name
, alias
) == 0)
1348 einfo (_("%F%P:%S: error: redefinition of memory region "
1353 /* Check if the target region exists. */
1355 einfo (_("%F%P:%S: error: memory region `%s' "
1356 "for alias `%s' does not exist\n"),
1357 NULL
, region_name
, alias
);
1359 /* Add alias to region name list. */
1360 n
= (lang_memory_region_name
*) stat_alloc (sizeof (lang_memory_region_name
));
1361 n
->name
= xstrdup (alias
);
1362 n
->next
= region
->name_list
.next
;
1363 region
->name_list
.next
= n
;
1366 static lang_memory_region_type
*
1367 lang_memory_default (asection
* section
)
1369 lang_memory_region_type
*p
;
1371 flagword sec_flags
= section
->flags
;
1373 /* Override SEC_DATA to mean a writable section. */
1374 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
1375 sec_flags
|= SEC_DATA
;
1377 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
1379 if ((p
->flags
& sec_flags
) != 0
1380 && (p
->not_flags
& sec_flags
) == 0)
1385 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
1388 /* Get the output section statement directly from the userdata. */
1390 lang_output_section_statement_type
*
1391 lang_output_section_get (const asection
*output_section
)
1393 return get_userdata (output_section
);
1396 /* Find or create an output_section_statement with the given NAME.
1397 If CONSTRAINT is non-zero match one with that constraint, otherwise
1398 match any non-negative constraint. If CREATE, always make a
1399 new output_section_statement for SPECIAL CONSTRAINT. */
1401 lang_output_section_statement_type
*
1402 lang_output_section_statement_lookup (const char *name
,
1406 struct out_section_hash_entry
*entry
;
1408 entry
= ((struct out_section_hash_entry
*)
1409 bfd_hash_lookup (&output_section_statement_table
, name
,
1414 einfo (_("%P%F: failed creating section `%s': %E\n"), name
);
1418 if (entry
->s
.output_section_statement
.name
!= NULL
)
1420 /* We have a section of this name, but it might not have the correct
1422 struct out_section_hash_entry
*last_ent
;
1424 name
= entry
->s
.output_section_statement
.name
;
1425 if (create
&& constraint
== SPECIAL
)
1426 /* Not traversing to the end reverses the order of the second
1427 and subsequent SPECIAL sections in the hash table chain,
1428 but that shouldn't matter. */
1433 if (constraint
== entry
->s
.output_section_statement
.constraint
1435 && entry
->s
.output_section_statement
.constraint
>= 0))
1436 return &entry
->s
.output_section_statement
;
1438 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1440 while (entry
!= NULL
1441 && name
== entry
->s
.output_section_statement
.name
);
1447 = ((struct out_section_hash_entry
*)
1448 output_section_statement_newfunc (NULL
,
1449 &output_section_statement_table
,
1453 einfo (_("%P%F: failed creating section `%s': %E\n"), name
);
1456 entry
->root
= last_ent
->root
;
1457 last_ent
->root
.next
= &entry
->root
;
1460 entry
->s
.output_section_statement
.name
= name
;
1461 entry
->s
.output_section_statement
.constraint
= constraint
;
1462 return &entry
->s
.output_section_statement
;
1465 /* Find the next output_section_statement with the same name as OS.
1466 If CONSTRAINT is non-zero, find one with that constraint otherwise
1467 match any non-negative constraint. */
1469 lang_output_section_statement_type
*
1470 next_matching_output_section_statement (lang_output_section_statement_type
*os
,
1473 /* All output_section_statements are actually part of a
1474 struct out_section_hash_entry. */
1475 struct out_section_hash_entry
*entry
= (struct out_section_hash_entry
*)
1477 - offsetof (struct out_section_hash_entry
, s
.output_section_statement
));
1478 const char *name
= os
->name
;
1480 ASSERT (name
== entry
->root
.string
);
1483 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1485 || name
!= entry
->s
.output_section_statement
.name
)
1488 while (constraint
!= entry
->s
.output_section_statement
.constraint
1490 || entry
->s
.output_section_statement
.constraint
< 0));
1492 return &entry
->s
.output_section_statement
;
1495 /* A variant of lang_output_section_find used by place_orphan.
1496 Returns the output statement that should precede a new output
1497 statement for SEC. If an exact match is found on certain flags,
1500 lang_output_section_statement_type
*
1501 lang_output_section_find_by_flags (const asection
*sec
,
1502 lang_output_section_statement_type
**exact
,
1503 lang_match_sec_type_func match_type
)
1505 lang_output_section_statement_type
*first
, *look
, *found
;
1506 flagword look_flags
, sec_flags
, differ
;
1508 /* We know the first statement on this list is *ABS*. May as well
1510 first
= &lang_output_section_statement
.head
->output_section_statement
;
1511 first
= first
->next
;
1513 /* First try for an exact match. */
1514 sec_flags
= sec
->flags
;
1516 for (look
= first
; look
; look
= look
->next
)
1518 look_flags
= look
->flags
;
1519 if (look
->bfd_section
!= NULL
)
1521 look_flags
= look
->bfd_section
->flags
;
1522 if (match_type
&& !match_type (link_info
.output_bfd
,
1527 differ
= look_flags
^ sec_flags
;
1528 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1529 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1539 if ((sec_flags
& SEC_CODE
) != 0
1540 && (sec_flags
& SEC_ALLOC
) != 0)
1542 /* Try for a rw code section. */
1543 for (look
= first
; look
; look
= look
->next
)
1545 look_flags
= look
->flags
;
1546 if (look
->bfd_section
!= NULL
)
1548 look_flags
= look
->bfd_section
->flags
;
1549 if (match_type
&& !match_type (link_info
.output_bfd
,
1554 differ
= look_flags
^ sec_flags
;
1555 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1556 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1560 else if ((sec_flags
& SEC_READONLY
) != 0
1561 && (sec_flags
& SEC_ALLOC
) != 0)
1563 /* .rodata can go after .text, .sdata2 after .rodata. */
1564 for (look
= first
; look
; look
= look
->next
)
1566 look_flags
= look
->flags
;
1567 if (look
->bfd_section
!= NULL
)
1569 look_flags
= look
->bfd_section
->flags
;
1570 if (match_type
&& !match_type (link_info
.output_bfd
,
1575 differ
= look_flags
^ sec_flags
;
1576 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1577 | SEC_READONLY
| SEC_SMALL_DATA
))
1578 || (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1580 && !(look_flags
& SEC_SMALL_DATA
)))
1584 else if ((sec_flags
& SEC_THREAD_LOCAL
) != 0
1585 && (sec_flags
& SEC_ALLOC
) != 0)
1587 /* .tdata can go after .data, .tbss after .tdata. Treat .tbss
1588 as if it were a loaded section, and don't use match_type. */
1589 bfd_boolean seen_thread_local
= FALSE
;
1592 for (look
= first
; look
; look
= look
->next
)
1594 look_flags
= look
->flags
;
1595 if (look
->bfd_section
!= NULL
)
1596 look_flags
= look
->bfd_section
->flags
;
1598 differ
= look_flags
^ (sec_flags
| SEC_LOAD
| SEC_HAS_CONTENTS
);
1599 if (!(differ
& (SEC_THREAD_LOCAL
| SEC_ALLOC
)))
1601 /* .tdata and .tbss must be adjacent and in that order. */
1602 if (!(look_flags
& SEC_LOAD
)
1603 && (sec_flags
& SEC_LOAD
))
1604 /* ..so if we're at a .tbss section and we're placing
1605 a .tdata section stop looking and return the
1606 previous section. */
1609 seen_thread_local
= TRUE
;
1611 else if (seen_thread_local
)
1613 else if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
)))
1617 else if ((sec_flags
& SEC_SMALL_DATA
) != 0
1618 && (sec_flags
& SEC_ALLOC
) != 0)
1620 /* .sdata goes after .data, .sbss after .sdata. */
1621 for (look
= first
; look
; look
= look
->next
)
1623 look_flags
= look
->flags
;
1624 if (look
->bfd_section
!= NULL
)
1626 look_flags
= look
->bfd_section
->flags
;
1627 if (match_type
&& !match_type (link_info
.output_bfd
,
1632 differ
= look_flags
^ sec_flags
;
1633 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1634 | SEC_THREAD_LOCAL
))
1635 || ((look_flags
& SEC_SMALL_DATA
)
1636 && !(sec_flags
& SEC_HAS_CONTENTS
)))
1640 else if ((sec_flags
& SEC_HAS_CONTENTS
) != 0
1641 && (sec_flags
& SEC_ALLOC
) != 0)
1643 /* .data goes after .rodata. */
1644 for (look
= first
; look
; look
= look
->next
)
1646 look_flags
= look
->flags
;
1647 if (look
->bfd_section
!= NULL
)
1649 look_flags
= look
->bfd_section
->flags
;
1650 if (match_type
&& !match_type (link_info
.output_bfd
,
1655 differ
= look_flags
^ sec_flags
;
1656 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1657 | SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1661 else if ((sec_flags
& SEC_ALLOC
) != 0)
1663 /* .bss goes after any other alloc section. */
1664 for (look
= first
; look
; look
= look
->next
)
1666 look_flags
= look
->flags
;
1667 if (look
->bfd_section
!= NULL
)
1669 look_flags
= look
->bfd_section
->flags
;
1670 if (match_type
&& !match_type (link_info
.output_bfd
,
1675 differ
= look_flags
^ sec_flags
;
1676 if (!(differ
& SEC_ALLOC
))
1682 /* non-alloc go last. */
1683 for (look
= first
; look
; look
= look
->next
)
1685 look_flags
= look
->flags
;
1686 if (look
->bfd_section
!= NULL
)
1687 look_flags
= look
->bfd_section
->flags
;
1688 differ
= look_flags
^ sec_flags
;
1689 if (!(differ
& SEC_DEBUGGING
))
1695 if (found
|| !match_type
)
1698 return lang_output_section_find_by_flags (sec
, NULL
, NULL
);
1701 /* Find the last output section before given output statement.
1702 Used by place_orphan. */
1705 output_prev_sec_find (lang_output_section_statement_type
*os
)
1707 lang_output_section_statement_type
*lookup
;
1709 for (lookup
= os
->prev
; lookup
!= NULL
; lookup
= lookup
->prev
)
1711 if (lookup
->constraint
< 0)
1714 if (lookup
->bfd_section
!= NULL
&& lookup
->bfd_section
->owner
!= NULL
)
1715 return lookup
->bfd_section
;
1721 /* Look for a suitable place for a new output section statement. The
1722 idea is to skip over anything that might be inside a SECTIONS {}
1723 statement in a script, before we find another output section
1724 statement. Assignments to "dot" before an output section statement
1725 are assumed to belong to it, except in two cases; The first
1726 assignment to dot, and assignments before non-alloc sections.
1727 Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
1728 similar assignments that set the initial address, or we might
1729 insert non-alloc note sections among assignments setting end of
1732 static lang_statement_union_type
**
1733 insert_os_after (lang_output_section_statement_type
*after
)
1735 lang_statement_union_type
**where
;
1736 lang_statement_union_type
**assign
= NULL
;
1737 bfd_boolean ignore_first
;
1740 = after
== &lang_output_section_statement
.head
->output_section_statement
;
1742 for (where
= &after
->header
.next
;
1744 where
= &(*where
)->header
.next
)
1746 switch ((*where
)->header
.type
)
1748 case lang_assignment_statement_enum
:
1751 lang_assignment_statement_type
*ass
;
1753 ass
= &(*where
)->assignment_statement
;
1754 if (ass
->exp
->type
.node_class
!= etree_assert
1755 && ass
->exp
->assign
.dst
[0] == '.'
1756 && ass
->exp
->assign
.dst
[1] == 0
1760 ignore_first
= FALSE
;
1762 case lang_wild_statement_enum
:
1763 case lang_input_section_enum
:
1764 case lang_object_symbols_statement_enum
:
1765 case lang_fill_statement_enum
:
1766 case lang_data_statement_enum
:
1767 case lang_reloc_statement_enum
:
1768 case lang_padding_statement_enum
:
1769 case lang_constructors_statement_enum
:
1772 case lang_output_section_statement_enum
:
1775 asection
*s
= (*where
)->output_section_statement
.bfd_section
;
1778 || s
->map_head
.s
== NULL
1779 || (s
->flags
& SEC_ALLOC
) != 0)
1783 case lang_input_statement_enum
:
1784 case lang_address_statement_enum
:
1785 case lang_target_statement_enum
:
1786 case lang_output_statement_enum
:
1787 case lang_group_statement_enum
:
1788 case lang_insert_statement_enum
:
1797 lang_output_section_statement_type
*
1798 lang_insert_orphan (asection
*s
,
1799 const char *secname
,
1801 lang_output_section_statement_type
*after
,
1802 struct orphan_save
*place
,
1803 etree_type
*address
,
1804 lang_statement_list_type
*add_child
)
1806 lang_statement_list_type add
;
1808 lang_output_section_statement_type
*os
;
1809 lang_output_section_statement_type
**os_tail
;
1811 /* If we have found an appropriate place for the output section
1812 statements for this orphan, add them to our own private list,
1813 inserting them later into the global statement list. */
1816 lang_list_init (&add
);
1817 push_stat_ptr (&add
);
1820 if (bfd_link_relocatable (&link_info
)
1821 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
1822 address
= exp_intop (0);
1824 os_tail
= ((lang_output_section_statement_type
**)
1825 lang_output_section_statement
.tail
);
1826 os
= lang_enter_output_section_statement (secname
, address
, normal_section
,
1827 NULL
, NULL
, NULL
, constraint
, 0);
1830 if (config
.build_constructors
&& *os_tail
== os
)
1832 /* If the name of the section is representable in C, then create
1833 symbols to mark the start and the end of the section. */
1834 for (ps
= secname
; *ps
!= '\0'; ps
++)
1835 if (! ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
1841 symname
= (char *) xmalloc (ps
- secname
+ sizeof "__start_" + 1);
1842 symname
[0] = bfd_get_symbol_leading_char (link_info
.output_bfd
);
1843 sprintf (symname
+ (symname
[0] != 0), "__start_%s", secname
);
1844 lang_add_assignment (exp_provide (symname
,
1845 exp_nameop (NAME
, "."),
1850 if (add_child
== NULL
)
1851 add_child
= &os
->children
;
1852 lang_add_section (add_child
, s
, NULL
, os
);
1854 if (after
&& (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) != 0)
1856 const char *region
= (after
->region
1857 ? after
->region
->name_list
.name
1858 : DEFAULT_MEMORY_REGION
);
1859 const char *lma_region
= (after
->lma_region
1860 ? after
->lma_region
->name_list
.name
1862 lang_leave_output_section_statement (NULL
, region
, after
->phdrs
,
1866 lang_leave_output_section_statement (NULL
, DEFAULT_MEMORY_REGION
, NULL
,
1869 if (ps
!= NULL
&& *ps
== '\0')
1873 symname
= (char *) xmalloc (ps
- secname
+ sizeof "__stop_" + 1);
1874 symname
[0] = bfd_get_symbol_leading_char (link_info
.output_bfd
);
1875 sprintf (symname
+ (symname
[0] != 0), "__stop_%s", secname
);
1876 lang_add_assignment (exp_provide (symname
,
1877 exp_nameop (NAME
, "."),
1881 /* Restore the global list pointer. */
1885 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
1887 asection
*snew
, *as
;
1889 snew
= os
->bfd_section
;
1891 /* Shuffle the bfd section list to make the output file look
1892 neater. This is really only cosmetic. */
1893 if (place
->section
== NULL
1894 && after
!= (&lang_output_section_statement
.head
1895 ->output_section_statement
))
1897 asection
*bfd_section
= after
->bfd_section
;
1899 /* If the output statement hasn't been used to place any input
1900 sections (and thus doesn't have an output bfd_section),
1901 look for the closest prior output statement having an
1903 if (bfd_section
== NULL
)
1904 bfd_section
= output_prev_sec_find (after
);
1906 if (bfd_section
!= NULL
&& bfd_section
!= snew
)
1907 place
->section
= &bfd_section
->next
;
1910 if (place
->section
== NULL
)
1911 place
->section
= &link_info
.output_bfd
->sections
;
1913 as
= *place
->section
;
1917 /* Put the section at the end of the list. */
1919 /* Unlink the section. */
1920 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1922 /* Now tack it back on in the right place. */
1923 bfd_section_list_append (link_info
.output_bfd
, snew
);
1925 else if (as
!= snew
&& as
->prev
!= snew
)
1927 /* Unlink the section. */
1928 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1930 /* Now tack it back on in the right place. */
1931 bfd_section_list_insert_before (link_info
.output_bfd
, as
, snew
);
1934 /* Save the end of this list. Further ophans of this type will
1935 follow the one we've just added. */
1936 place
->section
= &snew
->next
;
1938 /* The following is non-cosmetic. We try to put the output
1939 statements in some sort of reasonable order here, because they
1940 determine the final load addresses of the orphan sections.
1941 In addition, placing output statements in the wrong order may
1942 require extra segments. For instance, given a typical
1943 situation of all read-only sections placed in one segment and
1944 following that a segment containing all the read-write
1945 sections, we wouldn't want to place an orphan read/write
1946 section before or amongst the read-only ones. */
1947 if (add
.head
!= NULL
)
1949 lang_output_section_statement_type
*newly_added_os
;
1951 if (place
->stmt
== NULL
)
1953 lang_statement_union_type
**where
= insert_os_after (after
);
1958 place
->os_tail
= &after
->next
;
1962 /* Put it after the last orphan statement we added. */
1963 *add
.tail
= *place
->stmt
;
1964 *place
->stmt
= add
.head
;
1967 /* Fix the global list pointer if we happened to tack our
1968 new list at the tail. */
1969 if (*stat_ptr
->tail
== add
.head
)
1970 stat_ptr
->tail
= add
.tail
;
1972 /* Save the end of this list. */
1973 place
->stmt
= add
.tail
;
1975 /* Do the same for the list of output section statements. */
1976 newly_added_os
= *os_tail
;
1978 newly_added_os
->prev
= (lang_output_section_statement_type
*)
1979 ((char *) place
->os_tail
1980 - offsetof (lang_output_section_statement_type
, next
));
1981 newly_added_os
->next
= *place
->os_tail
;
1982 if (newly_added_os
->next
!= NULL
)
1983 newly_added_os
->next
->prev
= newly_added_os
;
1984 *place
->os_tail
= newly_added_os
;
1985 place
->os_tail
= &newly_added_os
->next
;
1987 /* Fixing the global list pointer here is a little different.
1988 We added to the list in lang_enter_output_section_statement,
1989 trimmed off the new output_section_statment above when
1990 assigning *os_tail = NULL, but possibly added it back in
1991 the same place when assigning *place->os_tail. */
1992 if (*os_tail
== NULL
)
1993 lang_output_section_statement
.tail
1994 = (lang_statement_union_type
**) os_tail
;
2001 lang_print_asneeded (void)
2003 struct asneeded_minfo
*m
;
2006 if (asneeded_list_head
== NULL
)
2009 sprintf (buf
, _("\nAs-needed library included "
2010 "to satisfy reference by file (symbol)\n\n"));
2013 for (m
= asneeded_list_head
; m
!= NULL
; m
= m
->next
)
2017 minfo ("%s", m
->soname
);
2018 len
= strlen (m
->soname
);
2032 minfo ("%B ", m
->ref
);
2033 minfo ("(%T)\n", m
->name
);
2038 lang_map_flags (flagword flag
)
2040 if (flag
& SEC_ALLOC
)
2043 if (flag
& SEC_CODE
)
2046 if (flag
& SEC_READONLY
)
2049 if (flag
& SEC_DATA
)
2052 if (flag
& SEC_LOAD
)
2059 lang_memory_region_type
*m
;
2060 bfd_boolean dis_header_printed
= FALSE
;
2062 LANG_FOR_EACH_INPUT_STATEMENT (file
)
2066 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
2067 || file
->flags
.just_syms
)
2070 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2071 if ((s
->output_section
== NULL
2072 || s
->output_section
->owner
!= link_info
.output_bfd
)
2073 && (s
->flags
& (SEC_LINKER_CREATED
| SEC_KEEP
)) == 0)
2075 if (! dis_header_printed
)
2077 fprintf (config
.map_file
, _("\nDiscarded input sections\n\n"));
2078 dis_header_printed
= TRUE
;
2081 print_input_section (s
, TRUE
);
2085 minfo (_("\nMemory Configuration\n\n"));
2086 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
2087 _("Name"), _("Origin"), _("Length"), _("Attributes"));
2089 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
2094 fprintf (config
.map_file
, "%-16s ", m
->name_list
.name
);
2096 sprintf_vma (buf
, m
->origin
);
2097 minfo ("0x%s ", buf
);
2105 minfo ("0x%V", m
->length
);
2106 if (m
->flags
|| m
->not_flags
)
2114 lang_map_flags (m
->flags
);
2120 lang_map_flags (m
->not_flags
);
2127 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
2129 if (! link_info
.reduce_memory_overheads
)
2131 obstack_begin (&map_obstack
, 1000);
2132 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
2134 lang_statement_iteration
++;
2135 print_statements ();
2137 ldemul_extra_map_file_text (link_info
.output_bfd
, &link_info
, config
.map_file
);
2141 sort_def_symbol (struct bfd_link_hash_entry
*hash_entry
,
2142 void *info ATTRIBUTE_UNUSED
)
2144 if ((hash_entry
->type
== bfd_link_hash_defined
2145 || hash_entry
->type
== bfd_link_hash_defweak
)
2146 && hash_entry
->u
.def
.section
->owner
!= link_info
.output_bfd
2147 && hash_entry
->u
.def
.section
->owner
!= NULL
)
2149 input_section_userdata_type
*ud
;
2150 struct map_symbol_def
*def
;
2152 ud
= ((input_section_userdata_type
*)
2153 get_userdata (hash_entry
->u
.def
.section
));
2156 ud
= (input_section_userdata_type
*) stat_alloc (sizeof (*ud
));
2157 get_userdata (hash_entry
->u
.def
.section
) = ud
;
2158 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2159 ud
->map_symbol_def_count
= 0;
2161 else if (!ud
->map_symbol_def_tail
)
2162 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2164 def
= (struct map_symbol_def
*) obstack_alloc (&map_obstack
, sizeof *def
);
2165 def
->entry
= hash_entry
;
2166 *(ud
->map_symbol_def_tail
) = def
;
2167 ud
->map_symbol_def_tail
= &def
->next
;
2168 ud
->map_symbol_def_count
++;
2173 /* Initialize an output section. */
2176 init_os (lang_output_section_statement_type
*s
, flagword flags
)
2178 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
2179 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
2181 if (s
->constraint
!= SPECIAL
)
2182 s
->bfd_section
= bfd_get_section_by_name (link_info
.output_bfd
, s
->name
);
2183 if (s
->bfd_section
== NULL
)
2184 s
->bfd_section
= bfd_make_section_anyway_with_flags (link_info
.output_bfd
,
2186 if (s
->bfd_section
== NULL
)
2188 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
2189 link_info
.output_bfd
->xvec
->name
, s
->name
);
2191 s
->bfd_section
->output_section
= s
->bfd_section
;
2192 s
->bfd_section
->output_offset
= 0;
2194 /* Set the userdata of the output section to the output section
2195 statement to avoid lookup. */
2196 get_userdata (s
->bfd_section
) = s
;
2198 /* If there is a base address, make sure that any sections it might
2199 mention are initialized. */
2200 if (s
->addr_tree
!= NULL
)
2201 exp_init_os (s
->addr_tree
);
2203 if (s
->load_base
!= NULL
)
2204 exp_init_os (s
->load_base
);
2206 /* If supplied an alignment, set it. */
2207 if (s
->section_alignment
!= -1)
2208 s
->bfd_section
->alignment_power
= s
->section_alignment
;
2211 /* Make sure that all output sections mentioned in an expression are
2215 exp_init_os (etree_type
*exp
)
2217 switch (exp
->type
.node_class
)
2221 exp_init_os (exp
->assign
.src
);
2225 exp_init_os (exp
->binary
.lhs
);
2226 exp_init_os (exp
->binary
.rhs
);
2230 exp_init_os (exp
->trinary
.cond
);
2231 exp_init_os (exp
->trinary
.lhs
);
2232 exp_init_os (exp
->trinary
.rhs
);
2236 exp_init_os (exp
->assert_s
.child
);
2240 exp_init_os (exp
->unary
.child
);
2244 switch (exp
->type
.node_code
)
2250 lang_output_section_statement_type
*os
;
2252 os
= lang_output_section_find (exp
->name
.name
);
2253 if (os
!= NULL
&& os
->bfd_section
== NULL
)
2265 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
2267 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
2269 /* If we are only reading symbols from this object, then we want to
2270 discard all sections. */
2271 if (entry
->flags
.just_syms
)
2273 bfd_link_just_syms (abfd
, sec
, &link_info
);
2277 if (!(abfd
->flags
& DYNAMIC
))
2278 bfd_section_already_linked (abfd
, sec
, &link_info
);
2281 /* The wild routines.
2283 These expand statements like *(.text) and foo.o to a list of
2284 explicit actions, like foo.o(.text), bar.o(.text) and
2285 foo.o(.text, .data). */
2287 /* Add SECTION to the output section OUTPUT. Do this by creating a
2288 lang_input_section statement which is placed at PTR. */
2291 lang_add_section (lang_statement_list_type
*ptr
,
2293 struct flag_info
*sflag_info
,
2294 lang_output_section_statement_type
*output
)
2296 flagword flags
= section
->flags
;
2298 bfd_boolean discard
;
2299 lang_input_section_type
*new_section
;
2300 bfd
*abfd
= link_info
.output_bfd
;
2302 /* Discard sections marked with SEC_EXCLUDE. */
2303 discard
= (flags
& SEC_EXCLUDE
) != 0;
2305 /* Discard input sections which are assigned to a section named
2306 DISCARD_SECTION_NAME. */
2307 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
2310 /* Discard debugging sections if we are stripping debugging
2312 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
2313 && (flags
& SEC_DEBUGGING
) != 0)
2318 if (section
->output_section
== NULL
)
2320 /* This prevents future calls from assigning this section. */
2321 section
->output_section
= bfd_abs_section_ptr
;
2330 keep
= bfd_lookup_section_flags (&link_info
, sflag_info
, section
);
2335 if (section
->output_section
!= NULL
)
2338 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2339 to an output section, because we want to be able to include a
2340 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2341 section (I don't know why we want to do this, but we do).
2342 build_link_order in ldwrite.c handles this case by turning
2343 the embedded SEC_NEVER_LOAD section into a fill. */
2344 flags
&= ~ SEC_NEVER_LOAD
;
2346 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2347 already been processed. One reason to do this is that on pe
2348 format targets, .text$foo sections go into .text and it's odd
2349 to see .text with SEC_LINK_ONCE set. */
2351 if (!bfd_link_relocatable (&link_info
))
2352 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2354 switch (output
->sectype
)
2356 case normal_section
:
2357 case overlay_section
:
2359 case noalloc_section
:
2360 flags
&= ~SEC_ALLOC
;
2362 case noload_section
:
2364 flags
|= SEC_NEVER_LOAD
;
2365 /* Unfortunately GNU ld has managed to evolve two different
2366 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2367 alloc, no contents section. All others get a noload, noalloc
2369 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
2370 flags
&= ~SEC_HAS_CONTENTS
;
2372 flags
&= ~SEC_ALLOC
;
2376 if (output
->bfd_section
== NULL
)
2377 init_os (output
, flags
);
2379 /* If SEC_READONLY is not set in the input section, then clear
2380 it from the output section. */
2381 output
->bfd_section
->flags
&= flags
| ~SEC_READONLY
;
2383 if (output
->bfd_section
->linker_has_input
)
2385 /* Only set SEC_READONLY flag on the first input section. */
2386 flags
&= ~ SEC_READONLY
;
2388 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2389 if ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2390 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2391 || ((flags
& SEC_MERGE
) != 0
2392 && output
->bfd_section
->entsize
!= section
->entsize
))
2394 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2395 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2398 output
->bfd_section
->flags
|= flags
;
2400 if (!output
->bfd_section
->linker_has_input
)
2402 output
->bfd_section
->linker_has_input
= 1;
2403 /* This must happen after flags have been updated. The output
2404 section may have been created before we saw its first input
2405 section, eg. for a data statement. */
2406 bfd_init_private_section_data (section
->owner
, section
,
2407 link_info
.output_bfd
,
2408 output
->bfd_section
,
2410 if ((flags
& SEC_MERGE
) != 0)
2411 output
->bfd_section
->entsize
= section
->entsize
;
2414 if ((flags
& SEC_TIC54X_BLOCK
) != 0
2415 && bfd_get_arch (section
->owner
) == bfd_arch_tic54x
)
2417 /* FIXME: This value should really be obtained from the bfd... */
2418 output
->block_value
= 128;
2421 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2422 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2424 section
->output_section
= output
->bfd_section
;
2426 if (!map_head_is_link_order
)
2428 asection
*s
= output
->bfd_section
->map_tail
.s
;
2429 output
->bfd_section
->map_tail
.s
= section
;
2430 section
->map_head
.s
= NULL
;
2431 section
->map_tail
.s
= s
;
2433 s
->map_head
.s
= section
;
2435 output
->bfd_section
->map_head
.s
= section
;
2438 /* Add a section reference to the list. */
2439 new_section
= new_stat (lang_input_section
, ptr
);
2440 new_section
->section
= section
;
2443 /* Handle wildcard sorting. This returns the lang_input_section which
2444 should follow the one we are going to create for SECTION and FILE,
2445 based on the sorting requirements of WILD. It returns NULL if the
2446 new section should just go at the end of the current list. */
2448 static lang_statement_union_type
*
2449 wild_sort (lang_wild_statement_type
*wild
,
2450 struct wildcard_list
*sec
,
2451 lang_input_statement_type
*file
,
2454 lang_statement_union_type
*l
;
2456 if (!wild
->filenames_sorted
2457 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
2460 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
2462 lang_input_section_type
*ls
;
2464 if (l
->header
.type
!= lang_input_section_enum
)
2466 ls
= &l
->input_section
;
2468 /* Sorting by filename takes precedence over sorting by section
2471 if (wild
->filenames_sorted
)
2473 const char *fn
, *ln
;
2477 /* The PE support for the .idata section as generated by
2478 dlltool assumes that files will be sorted by the name of
2479 the archive and then the name of the file within the
2482 if (file
->the_bfd
!= NULL
2483 && bfd_my_archive (file
->the_bfd
) != NULL
)
2485 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
2490 fn
= file
->filename
;
2494 if (bfd_my_archive (ls
->section
->owner
) != NULL
)
2496 ln
= bfd_get_filename (bfd_my_archive (ls
->section
->owner
));
2501 ln
= ls
->section
->owner
->filename
;
2505 i
= filename_cmp (fn
, ln
);
2514 fn
= file
->filename
;
2516 ln
= ls
->section
->owner
->filename
;
2518 i
= filename_cmp (fn
, ln
);
2526 /* Here either the files are not sorted by name, or we are
2527 looking at the sections for this file. */
2530 && sec
->spec
.sorted
!= none
2531 && sec
->spec
.sorted
!= by_none
)
2532 if (compare_section (sec
->spec
.sorted
, section
, ls
->section
) < 0)
2539 /* Expand a wild statement for a particular FILE. SECTION may be
2540 NULL, in which case it is a wild card. */
2543 output_section_callback (lang_wild_statement_type
*ptr
,
2544 struct wildcard_list
*sec
,
2546 struct flag_info
*sflag_info
,
2547 lang_input_statement_type
*file
,
2550 lang_statement_union_type
*before
;
2551 lang_output_section_statement_type
*os
;
2553 os
= (lang_output_section_statement_type
*) output
;
2555 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2556 if (unique_section_p (section
, os
))
2559 before
= wild_sort (ptr
, sec
, file
, section
);
2561 /* Here BEFORE points to the lang_input_section which
2562 should follow the one we are about to add. If BEFORE
2563 is NULL, then the section should just go at the end
2564 of the current list. */
2567 lang_add_section (&ptr
->children
, section
, sflag_info
, os
);
2570 lang_statement_list_type list
;
2571 lang_statement_union_type
**pp
;
2573 lang_list_init (&list
);
2574 lang_add_section (&list
, section
, sflag_info
, os
);
2576 /* If we are discarding the section, LIST.HEAD will
2578 if (list
.head
!= NULL
)
2580 ASSERT (list
.head
->header
.next
== NULL
);
2582 for (pp
= &ptr
->children
.head
;
2584 pp
= &(*pp
)->header
.next
)
2585 ASSERT (*pp
!= NULL
);
2587 list
.head
->header
.next
= *pp
;
2593 /* Check if all sections in a wild statement for a particular FILE
2597 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2598 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2600 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
2601 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2604 lang_output_section_statement_type
*os
;
2606 os
= (lang_output_section_statement_type
*) output
;
2608 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2609 if (unique_section_p (section
, os
))
2612 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2613 os
->all_input_readonly
= FALSE
;
2616 /* This is passed a file name which must have been seen already and
2617 added to the statement tree. We will see if it has been opened
2618 already and had its symbols read. If not then we'll read it. */
2620 static lang_input_statement_type
*
2621 lookup_name (const char *name
)
2623 lang_input_statement_type
*search
;
2625 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
2627 search
= (lang_input_statement_type
*) search
->next_real_file
)
2629 /* Use the local_sym_name as the name of the file that has
2630 already been loaded as filename might have been transformed
2631 via the search directory lookup mechanism. */
2632 const char *filename
= search
->local_sym_name
;
2634 if (filename
!= NULL
2635 && filename_cmp (filename
, name
) == 0)
2640 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2641 default_target
, FALSE
);
2643 /* If we have already added this file, or this file is not real
2644 don't add this file. */
2645 if (search
->flags
.loaded
|| !search
->flags
.real
)
2648 if (! load_symbols (search
, NULL
))
2654 /* Save LIST as a list of libraries whose symbols should not be exported. */
2659 struct excluded_lib
*next
;
2661 static struct excluded_lib
*excluded_libs
;
2664 add_excluded_libs (const char *list
)
2666 const char *p
= list
, *end
;
2670 struct excluded_lib
*entry
;
2671 end
= strpbrk (p
, ",:");
2673 end
= p
+ strlen (p
);
2674 entry
= (struct excluded_lib
*) xmalloc (sizeof (*entry
));
2675 entry
->next
= excluded_libs
;
2676 entry
->name
= (char *) xmalloc (end
- p
+ 1);
2677 memcpy (entry
->name
, p
, end
- p
);
2678 entry
->name
[end
- p
] = '\0';
2679 excluded_libs
= entry
;
2687 check_excluded_libs (bfd
*abfd
)
2689 struct excluded_lib
*lib
= excluded_libs
;
2693 int len
= strlen (lib
->name
);
2694 const char *filename
= lbasename (abfd
->filename
);
2696 if (strcmp (lib
->name
, "ALL") == 0)
2698 abfd
->no_export
= TRUE
;
2702 if (filename_ncmp (lib
->name
, filename
, len
) == 0
2703 && (filename
[len
] == '\0'
2704 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
2705 && filename
[len
+ 2] == '\0')))
2707 abfd
->no_export
= TRUE
;
2715 /* Get the symbols for an input file. */
2718 load_symbols (lang_input_statement_type
*entry
,
2719 lang_statement_list_type
*place
)
2723 if (entry
->flags
.loaded
)
2726 ldfile_open_file (entry
);
2728 /* Do not process further if the file was missing. */
2729 if (entry
->flags
.missing_file
)
2732 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
2733 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
2736 struct lang_input_statement_flags save_flags
;
2739 err
= bfd_get_error ();
2741 /* See if the emulation has some special knowledge. */
2742 if (ldemul_unrecognized_file (entry
))
2745 if (err
== bfd_error_file_ambiguously_recognized
)
2749 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
2750 einfo (_("%B: matching formats:"), entry
->the_bfd
);
2751 for (p
= matching
; *p
!= NULL
; p
++)
2755 else if (err
!= bfd_error_file_not_recognized
2757 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
2759 bfd_close (entry
->the_bfd
);
2760 entry
->the_bfd
= NULL
;
2762 /* Try to interpret the file as a linker script. */
2763 save_flags
= input_flags
;
2764 ldfile_open_command_file (entry
->filename
);
2766 push_stat_ptr (place
);
2767 input_flags
.add_DT_NEEDED_for_regular
2768 = entry
->flags
.add_DT_NEEDED_for_regular
;
2769 input_flags
.add_DT_NEEDED_for_dynamic
2770 = entry
->flags
.add_DT_NEEDED_for_dynamic
;
2771 input_flags
.whole_archive
= entry
->flags
.whole_archive
;
2772 input_flags
.dynamic
= entry
->flags
.dynamic
;
2774 ldfile_assumed_script
= TRUE
;
2775 parser_input
= input_script
;
2777 ldfile_assumed_script
= FALSE
;
2779 /* missing_file is sticky. sysrooted will already have been
2780 restored when seeing EOF in yyparse, but no harm to restore
2782 save_flags
.missing_file
|= input_flags
.missing_file
;
2783 input_flags
= save_flags
;
2787 entry
->flags
.loaded
= TRUE
;
2792 if (ldemul_recognized_file (entry
))
2795 /* We don't call ldlang_add_file for an archive. Instead, the
2796 add_symbols entry point will call ldlang_add_file, via the
2797 add_archive_element callback, for each element of the archive
2799 switch (bfd_get_format (entry
->the_bfd
))
2805 if (!entry
->flags
.reload
)
2806 ldlang_add_file (entry
);
2807 if (trace_files
|| verbose
)
2808 info_msg ("%I\n", entry
);
2812 check_excluded_libs (entry
->the_bfd
);
2814 if (entry
->flags
.whole_archive
)
2817 bfd_boolean loaded
= TRUE
;
2822 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
2827 if (! bfd_check_format (member
, bfd_object
))
2829 einfo (_("%F%B: member %B in archive is not an object\n"),
2830 entry
->the_bfd
, member
);
2835 if (!(*link_info
.callbacks
2836 ->add_archive_element
) (&link_info
, member
,
2837 "--whole-archive", &subsbfd
))
2840 /* Potentially, the add_archive_element hook may have set a
2841 substitute BFD for us. */
2842 if (!bfd_link_add_symbols (subsbfd
, &link_info
))
2844 einfo (_("%F%B: error adding symbols: %E\n"), member
);
2849 entry
->flags
.loaded
= loaded
;
2855 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
2856 entry
->flags
.loaded
= TRUE
;
2858 einfo (_("%F%B: error adding symbols: %E\n"), entry
->the_bfd
);
2860 return entry
->flags
.loaded
;
2863 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
2864 may be NULL, indicating that it is a wildcard. Separate
2865 lang_input_section statements are created for each part of the
2866 expansion; they are added after the wild statement S. OUTPUT is
2867 the output section. */
2870 wild (lang_wild_statement_type
*s
,
2871 const char *target ATTRIBUTE_UNUSED
,
2872 lang_output_section_statement_type
*output
)
2874 struct wildcard_list
*sec
;
2876 if (s
->handler_data
[0]
2877 && s
->handler_data
[0]->spec
.sorted
== by_name
2878 && !s
->filenames_sorted
)
2880 lang_section_bst_type
*tree
;
2882 walk_wild (s
, output_section_callback_fast
, output
);
2887 output_section_callback_tree_to_list (s
, tree
, output
);
2892 walk_wild (s
, output_section_callback
, output
);
2894 if (default_common_section
== NULL
)
2895 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
2896 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
2898 /* Remember the section that common is going to in case we
2899 later get something which doesn't know where to put it. */
2900 default_common_section
= output
;
2905 /* Return TRUE iff target is the sought target. */
2908 get_target (const bfd_target
*target
, void *data
)
2910 const char *sought
= (const char *) data
;
2912 return strcmp (target
->name
, sought
) == 0;
2915 /* Like strcpy() but convert to lower case as well. */
2918 stricpy (char *dest
, char *src
)
2922 while ((c
= *src
++) != 0)
2923 *dest
++ = TOLOWER (c
);
2928 /* Remove the first occurrence of needle (if any) in haystack
2932 strcut (char *haystack
, char *needle
)
2934 haystack
= strstr (haystack
, needle
);
2940 for (src
= haystack
+ strlen (needle
); *src
;)
2941 *haystack
++ = *src
++;
2947 /* Compare two target format name strings.
2948 Return a value indicating how "similar" they are. */
2951 name_compare (char *first
, char *second
)
2957 copy1
= (char *) xmalloc (strlen (first
) + 1);
2958 copy2
= (char *) xmalloc (strlen (second
) + 1);
2960 /* Convert the names to lower case. */
2961 stricpy (copy1
, first
);
2962 stricpy (copy2
, second
);
2964 /* Remove size and endian strings from the name. */
2965 strcut (copy1
, "big");
2966 strcut (copy1
, "little");
2967 strcut (copy2
, "big");
2968 strcut (copy2
, "little");
2970 /* Return a value based on how many characters match,
2971 starting from the beginning. If both strings are
2972 the same then return 10 * their length. */
2973 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
2974 if (copy1
[result
] == 0)
2986 /* Set by closest_target_match() below. */
2987 static const bfd_target
*winner
;
2989 /* Scan all the valid bfd targets looking for one that has the endianness
2990 requirement that was specified on the command line, and is the nearest
2991 match to the original output target. */
2994 closest_target_match (const bfd_target
*target
, void *data
)
2996 const bfd_target
*original
= (const bfd_target
*) data
;
2998 if (command_line
.endian
== ENDIAN_BIG
2999 && target
->byteorder
!= BFD_ENDIAN_BIG
)
3002 if (command_line
.endian
== ENDIAN_LITTLE
3003 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
3006 /* Must be the same flavour. */
3007 if (target
->flavour
!= original
->flavour
)
3010 /* Ignore generic big and little endian elf vectors. */
3011 if (strcmp (target
->name
, "elf32-big") == 0
3012 || strcmp (target
->name
, "elf64-big") == 0
3013 || strcmp (target
->name
, "elf32-little") == 0
3014 || strcmp (target
->name
, "elf64-little") == 0)
3017 /* If we have not found a potential winner yet, then record this one. */
3024 /* Oh dear, we now have two potential candidates for a successful match.
3025 Compare their names and choose the better one. */
3026 if (name_compare (target
->name
, original
->name
)
3027 > name_compare (winner
->name
, original
->name
))
3030 /* Keep on searching until wqe have checked them all. */
3034 /* Return the BFD target format of the first input file. */
3037 get_first_input_target (void)
3039 char *target
= NULL
;
3041 LANG_FOR_EACH_INPUT_STATEMENT (s
)
3043 if (s
->header
.type
== lang_input_statement_enum
3046 ldfile_open_file (s
);
3048 if (s
->the_bfd
!= NULL
3049 && bfd_check_format (s
->the_bfd
, bfd_object
))
3051 target
= bfd_get_target (s
->the_bfd
);
3063 lang_get_output_target (void)
3067 /* Has the user told us which output format to use? */
3068 if (output_target
!= NULL
)
3069 return output_target
;
3071 /* No - has the current target been set to something other than
3073 if (current_target
!= default_target
&& current_target
!= NULL
)
3074 return current_target
;
3076 /* No - can we determine the format of the first input file? */
3077 target
= get_first_input_target ();
3081 /* Failed - use the default output target. */
3082 return default_target
;
3085 /* Open the output file. */
3088 open_output (const char *name
)
3090 output_target
= lang_get_output_target ();
3092 /* Has the user requested a particular endianness on the command
3094 if (command_line
.endian
!= ENDIAN_UNSET
)
3096 const bfd_target
*target
;
3097 enum bfd_endian desired_endian
;
3099 /* Get the chosen target. */
3100 target
= bfd_search_for_target (get_target
, (void *) output_target
);
3102 /* If the target is not supported, we cannot do anything. */
3105 if (command_line
.endian
== ENDIAN_BIG
)
3106 desired_endian
= BFD_ENDIAN_BIG
;
3108 desired_endian
= BFD_ENDIAN_LITTLE
;
3110 /* See if the target has the wrong endianness. This should
3111 not happen if the linker script has provided big and
3112 little endian alternatives, but some scrips don't do
3114 if (target
->byteorder
!= desired_endian
)
3116 /* If it does, then see if the target provides
3117 an alternative with the correct endianness. */
3118 if (target
->alternative_target
!= NULL
3119 && (target
->alternative_target
->byteorder
== desired_endian
))
3120 output_target
= target
->alternative_target
->name
;
3123 /* Try to find a target as similar as possible to
3124 the default target, but which has the desired
3125 endian characteristic. */
3126 bfd_search_for_target (closest_target_match
,
3129 /* Oh dear - we could not find any targets that
3130 satisfy our requirements. */
3132 einfo (_("%P: warning: could not find any targets"
3133 " that match endianness requirement\n"));
3135 output_target
= winner
->name
;
3141 link_info
.output_bfd
= bfd_openw (name
, output_target
);
3143 if (link_info
.output_bfd
== NULL
)
3145 if (bfd_get_error () == bfd_error_invalid_target
)
3146 einfo (_("%P%F: target %s not found\n"), output_target
);
3148 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
3151 delete_output_file_on_failure
= TRUE
;
3153 if (! bfd_set_format (link_info
.output_bfd
, bfd_object
))
3154 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
3155 if (! bfd_set_arch_mach (link_info
.output_bfd
,
3156 ldfile_output_architecture
,
3157 ldfile_output_machine
))
3158 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
3160 link_info
.hash
= bfd_link_hash_table_create (link_info
.output_bfd
);
3161 if (link_info
.hash
== NULL
)
3162 einfo (_("%P%F: can not create hash table: %E\n"));
3164 bfd_set_gp_size (link_info
.output_bfd
, g_switch_value
);
3168 ldlang_open_output (lang_statement_union_type
*statement
)
3170 switch (statement
->header
.type
)
3172 case lang_output_statement_enum
:
3173 ASSERT (link_info
.output_bfd
== NULL
);
3174 open_output (statement
->output_statement
.name
);
3175 ldemul_set_output_arch ();
3176 if (config
.magic_demand_paged
3177 && !bfd_link_relocatable (&link_info
))
3178 link_info
.output_bfd
->flags
|= D_PAGED
;
3180 link_info
.output_bfd
->flags
&= ~D_PAGED
;
3181 if (config
.text_read_only
)
3182 link_info
.output_bfd
->flags
|= WP_TEXT
;
3184 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
3185 if (link_info
.traditional_format
)
3186 link_info
.output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
3188 link_info
.output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
3191 case lang_target_statement_enum
:
3192 current_target
= statement
->target_statement
.target
;
3199 /* Convert between addresses in bytes and sizes in octets.
3200 For currently supported targets, octets_per_byte is always a power
3201 of two, so we can use shifts. */
3202 #define TO_ADDR(X) ((X) >> opb_shift)
3203 #define TO_SIZE(X) ((X) << opb_shift)
3205 /* Support the above. */
3206 static unsigned int opb_shift
= 0;
3211 unsigned x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3212 ldfile_output_machine
);
3215 while ((x
& 1) == 0)
3223 /* Open all the input files. */
3227 OPEN_BFD_NORMAL
= 0,
3231 #ifdef ENABLE_PLUGINS
3232 static lang_input_statement_type
*plugin_insert
= NULL
;
3236 open_input_bfds (lang_statement_union_type
*s
, enum open_bfd_mode mode
)
3238 for (; s
!= NULL
; s
= s
->header
.next
)
3240 switch (s
->header
.type
)
3242 case lang_constructors_statement_enum
:
3243 open_input_bfds (constructor_list
.head
, mode
);
3245 case lang_output_section_statement_enum
:
3246 open_input_bfds (s
->output_section_statement
.children
.head
, mode
);
3248 case lang_wild_statement_enum
:
3249 /* Maybe we should load the file's symbols. */
3250 if ((mode
& OPEN_BFD_RESCAN
) == 0
3251 && s
->wild_statement
.filename
3252 && !wildcardp (s
->wild_statement
.filename
)
3253 && !archive_path (s
->wild_statement
.filename
))
3254 lookup_name (s
->wild_statement
.filename
);
3255 open_input_bfds (s
->wild_statement
.children
.head
, mode
);
3257 case lang_group_statement_enum
:
3259 struct bfd_link_hash_entry
*undefs
;
3261 /* We must continually search the entries in the group
3262 until no new symbols are added to the list of undefined
3267 undefs
= link_info
.hash
->undefs_tail
;
3268 open_input_bfds (s
->group_statement
.children
.head
,
3269 mode
| OPEN_BFD_FORCE
);
3271 while (undefs
!= link_info
.hash
->undefs_tail
);
3274 case lang_target_statement_enum
:
3275 current_target
= s
->target_statement
.target
;
3277 case lang_input_statement_enum
:
3278 if (s
->input_statement
.flags
.real
)
3280 lang_statement_union_type
**os_tail
;
3281 lang_statement_list_type add
;
3284 s
->input_statement
.target
= current_target
;
3286 /* If we are being called from within a group, and this
3287 is an archive which has already been searched, then
3288 force it to be researched unless the whole archive
3289 has been loaded already. Do the same for a rescan.
3290 Likewise reload --as-needed shared libs. */
3291 if (mode
!= OPEN_BFD_NORMAL
3292 #ifdef ENABLE_PLUGINS
3293 && ((mode
& OPEN_BFD_RESCAN
) == 0
3294 || plugin_insert
== NULL
)
3296 && s
->input_statement
.flags
.loaded
3297 && (abfd
= s
->input_statement
.the_bfd
) != NULL
3298 && ((bfd_get_format (abfd
) == bfd_archive
3299 && !s
->input_statement
.flags
.whole_archive
)
3300 || (bfd_get_format (abfd
) == bfd_object
3301 && ((abfd
->flags
) & DYNAMIC
) != 0
3302 && s
->input_statement
.flags
.add_DT_NEEDED_for_regular
3303 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3304 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)))
3306 s
->input_statement
.flags
.loaded
= FALSE
;
3307 s
->input_statement
.flags
.reload
= TRUE
;
3310 os_tail
= lang_output_section_statement
.tail
;
3311 lang_list_init (&add
);
3313 if (! load_symbols (&s
->input_statement
, &add
))
3314 config
.make_executable
= FALSE
;
3316 if (add
.head
!= NULL
)
3318 /* If this was a script with output sections then
3319 tack any added statements on to the end of the
3320 list. This avoids having to reorder the output
3321 section statement list. Very likely the user
3322 forgot -T, and whatever we do here will not meet
3323 naive user expectations. */
3324 if (os_tail
!= lang_output_section_statement
.tail
)
3326 einfo (_("%P: warning: %s contains output sections;"
3327 " did you forget -T?\n"),
3328 s
->input_statement
.filename
);
3329 *stat_ptr
->tail
= add
.head
;
3330 stat_ptr
->tail
= add
.tail
;
3334 *add
.tail
= s
->header
.next
;
3335 s
->header
.next
= add
.head
;
3339 #ifdef ENABLE_PLUGINS
3340 /* If we have found the point at which a plugin added new
3341 files, clear plugin_insert to enable archive rescan. */
3342 if (&s
->input_statement
== plugin_insert
)
3343 plugin_insert
= NULL
;
3346 case lang_assignment_statement_enum
:
3347 if (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 bfd_link_add_undef (link_info
.hash
, h
);
3405 /* Run through the list of undefineds created above and place them
3406 into the linker hash table as undefined symbols belonging to the
3410 lang_place_undefineds (void)
3412 ldlang_undef_chain_list_type
*ptr
;
3414 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3415 insert_undefined (ptr
->name
);
3418 /* Structure used to build the list of symbols that the user has required
3421 struct require_defined_symbol
3424 struct require_defined_symbol
*next
;
3427 /* The list of symbols that the user has required be defined. */
3429 static struct require_defined_symbol
*require_defined_symbol_list
;
3431 /* Add a new symbol NAME to the list of symbols that are required to be
3435 ldlang_add_require_defined (const char * const name
)
3437 struct require_defined_symbol
*ptr
;
3439 ldlang_add_undef (name
, TRUE
);
3440 ptr
= (struct require_defined_symbol
*) stat_alloc (sizeof (*ptr
));
3441 ptr
->next
= require_defined_symbol_list
;
3442 ptr
->name
= strdup (name
);
3443 require_defined_symbol_list
= ptr
;
3446 /* Check that all symbols the user required to be defined, are defined,
3447 raise an error if we find a symbol that is not defined. */
3450 ldlang_check_require_defined_symbols (void)
3452 struct require_defined_symbol
*ptr
;
3454 for (ptr
= require_defined_symbol_list
; ptr
!= NULL
; ptr
= ptr
->next
)
3456 struct bfd_link_hash_entry
*h
;
3458 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
,
3459 FALSE
, FALSE
, TRUE
);
3461 || (h
->type
!= bfd_link_hash_defined
3462 && h
->type
!= bfd_link_hash_defweak
))
3463 einfo(_("%P%X: required symbol `%s' not defined\n"), ptr
->name
);
3467 /* Check for all readonly or some readwrite sections. */
3470 check_input_sections
3471 (lang_statement_union_type
*s
,
3472 lang_output_section_statement_type
*output_section_statement
)
3474 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
3476 switch (s
->header
.type
)
3478 case lang_wild_statement_enum
:
3479 walk_wild (&s
->wild_statement
, check_section_callback
,
3480 output_section_statement
);
3481 if (! output_section_statement
->all_input_readonly
)
3484 case lang_constructors_statement_enum
:
3485 check_input_sections (constructor_list
.head
,
3486 output_section_statement
);
3487 if (! output_section_statement
->all_input_readonly
)
3490 case lang_group_statement_enum
:
3491 check_input_sections (s
->group_statement
.children
.head
,
3492 output_section_statement
);
3493 if (! output_section_statement
->all_input_readonly
)
3502 /* Update wildcard statements if needed. */
3505 update_wild_statements (lang_statement_union_type
*s
)
3507 struct wildcard_list
*sec
;
3509 switch (sort_section
)
3519 for (; s
!= NULL
; s
= s
->header
.next
)
3521 switch (s
->header
.type
)
3526 case lang_wild_statement_enum
:
3527 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
3530 switch (sec
->spec
.sorted
)
3533 sec
->spec
.sorted
= sort_section
;
3536 if (sort_section
== by_alignment
)
3537 sec
->spec
.sorted
= by_name_alignment
;
3540 if (sort_section
== by_name
)
3541 sec
->spec
.sorted
= by_alignment_name
;
3549 case lang_constructors_statement_enum
:
3550 update_wild_statements (constructor_list
.head
);
3553 case lang_output_section_statement_enum
:
3554 /* Don't sort .init/.fini sections. */
3555 if (strcmp (s
->output_section_statement
.name
, ".init") != 0
3556 && strcmp (s
->output_section_statement
.name
, ".fini") != 0)
3557 update_wild_statements
3558 (s
->output_section_statement
.children
.head
);
3561 case lang_group_statement_enum
:
3562 update_wild_statements (s
->group_statement
.children
.head
);
3570 /* Open input files and attach to output sections. */
3573 map_input_to_output_sections
3574 (lang_statement_union_type
*s
, const char *target
,
3575 lang_output_section_statement_type
*os
)
3577 for (; s
!= NULL
; s
= s
->header
.next
)
3579 lang_output_section_statement_type
*tos
;
3582 switch (s
->header
.type
)
3584 case lang_wild_statement_enum
:
3585 wild (&s
->wild_statement
, target
, os
);
3587 case lang_constructors_statement_enum
:
3588 map_input_to_output_sections (constructor_list
.head
,
3592 case lang_output_section_statement_enum
:
3593 tos
= &s
->output_section_statement
;
3594 if (tos
->constraint
!= 0)
3596 if (tos
->constraint
!= ONLY_IF_RW
3597 && tos
->constraint
!= ONLY_IF_RO
)
3599 tos
->all_input_readonly
= TRUE
;
3600 check_input_sections (tos
->children
.head
, tos
);
3601 if (tos
->all_input_readonly
!= (tos
->constraint
== ONLY_IF_RO
))
3603 tos
->constraint
= -1;
3607 map_input_to_output_sections (tos
->children
.head
,
3611 case lang_output_statement_enum
:
3613 case lang_target_statement_enum
:
3614 target
= s
->target_statement
.target
;
3616 case lang_group_statement_enum
:
3617 map_input_to_output_sections (s
->group_statement
.children
.head
,
3621 case lang_data_statement_enum
:
3622 /* Make sure that any sections mentioned in the expression
3624 exp_init_os (s
->data_statement
.exp
);
3625 /* The output section gets CONTENTS, ALLOC and LOAD, but
3626 these may be overridden by the script. */
3627 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
;
3628 switch (os
->sectype
)
3630 case normal_section
:
3631 case overlay_section
:
3633 case noalloc_section
:
3634 flags
= SEC_HAS_CONTENTS
;
3636 case noload_section
:
3637 if (bfd_get_flavour (link_info
.output_bfd
)
3638 == bfd_target_elf_flavour
)
3639 flags
= SEC_NEVER_LOAD
| SEC_ALLOC
;
3641 flags
= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
;
3644 if (os
->bfd_section
== NULL
)
3645 init_os (os
, flags
);
3647 os
->bfd_section
->flags
|= flags
;
3649 case lang_input_section_enum
:
3651 case lang_fill_statement_enum
:
3652 case lang_object_symbols_statement_enum
:
3653 case lang_reloc_statement_enum
:
3654 case lang_padding_statement_enum
:
3655 case lang_input_statement_enum
:
3656 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3659 case lang_assignment_statement_enum
:
3660 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3663 /* Make sure that any sections mentioned in the assignment
3665 exp_init_os (s
->assignment_statement
.exp
);
3667 case lang_address_statement_enum
:
3668 /* Mark the specified section with the supplied address.
3669 If this section was actually a segment marker, then the
3670 directive is ignored if the linker script explicitly
3671 processed the segment marker. Originally, the linker
3672 treated segment directives (like -Ttext on the
3673 command-line) as section directives. We honor the
3674 section directive semantics for backwards compatibilty;
3675 linker scripts that do not specifically check for
3676 SEGMENT_START automatically get the old semantics. */
3677 if (!s
->address_statement
.segment
3678 || !s
->address_statement
.segment
->used
)
3680 const char *name
= s
->address_statement
.section_name
;
3682 /* Create the output section statement here so that
3683 orphans with a set address will be placed after other
3684 script sections. If we let the orphan placement code
3685 place them in amongst other sections then the address
3686 will affect following script sections, which is
3687 likely to surprise naive users. */
3688 tos
= lang_output_section_statement_lookup (name
, 0, TRUE
);
3689 tos
->addr_tree
= s
->address_statement
.address
;
3690 if (tos
->bfd_section
== NULL
)
3694 case lang_insert_statement_enum
:
3700 /* An insert statement snips out all the linker statements from the
3701 start of the list and places them after the output section
3702 statement specified by the insert. This operation is complicated
3703 by the fact that we keep a doubly linked list of output section
3704 statements as well as the singly linked list of all statements. */
3707 process_insert_statements (void)
3709 lang_statement_union_type
**s
;
3710 lang_output_section_statement_type
*first_os
= NULL
;
3711 lang_output_section_statement_type
*last_os
= NULL
;
3712 lang_output_section_statement_type
*os
;
3714 /* "start of list" is actually the statement immediately after
3715 the special abs_section output statement, so that it isn't
3717 s
= &lang_output_section_statement
.head
;
3718 while (*(s
= &(*s
)->header
.next
) != NULL
)
3720 if ((*s
)->header
.type
== lang_output_section_statement_enum
)
3722 /* Keep pointers to the first and last output section
3723 statement in the sequence we may be about to move. */
3724 os
= &(*s
)->output_section_statement
;
3726 ASSERT (last_os
== NULL
|| last_os
->next
== os
);
3729 /* Set constraint negative so that lang_output_section_find
3730 won't match this output section statement. At this
3731 stage in linking constraint has values in the range
3732 [-1, ONLY_IN_RW]. */
3733 last_os
->constraint
= -2 - last_os
->constraint
;
3734 if (first_os
== NULL
)
3737 else if ((*s
)->header
.type
== lang_insert_statement_enum
)
3739 lang_insert_statement_type
*i
= &(*s
)->insert_statement
;
3740 lang_output_section_statement_type
*where
;
3741 lang_statement_union_type
**ptr
;
3742 lang_statement_union_type
*first
;
3744 where
= lang_output_section_find (i
->where
);
3745 if (where
!= NULL
&& i
->is_before
)
3748 where
= where
->prev
;
3749 while (where
!= NULL
&& where
->constraint
< 0);
3753 einfo (_("%F%P: %s not found for insert\n"), i
->where
);
3757 /* Deal with reordering the output section statement list. */
3758 if (last_os
!= NULL
)
3760 asection
*first_sec
, *last_sec
;
3761 struct lang_output_section_statement_struct
**next
;
3763 /* Snip out the output sections we are moving. */
3764 first_os
->prev
->next
= last_os
->next
;
3765 if (last_os
->next
== NULL
)
3767 next
= &first_os
->prev
->next
;
3768 lang_output_section_statement
.tail
3769 = (lang_statement_union_type
**) next
;
3772 last_os
->next
->prev
= first_os
->prev
;
3773 /* Add them in at the new position. */
3774 last_os
->next
= where
->next
;
3775 if (where
->next
== NULL
)
3777 next
= &last_os
->next
;
3778 lang_output_section_statement
.tail
3779 = (lang_statement_union_type
**) next
;
3782 where
->next
->prev
= last_os
;
3783 first_os
->prev
= where
;
3784 where
->next
= first_os
;
3786 /* Move the bfd sections in the same way. */
3789 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
3791 os
->constraint
= -2 - os
->constraint
;
3792 if (os
->bfd_section
!= NULL
3793 && os
->bfd_section
->owner
!= NULL
)
3795 last_sec
= os
->bfd_section
;
3796 if (first_sec
== NULL
)
3797 first_sec
= last_sec
;
3802 if (last_sec
!= NULL
)
3804 asection
*sec
= where
->bfd_section
;
3806 sec
= output_prev_sec_find (where
);
3808 /* The place we want to insert must come after the
3809 sections we are moving. So if we find no
3810 section or if the section is the same as our
3811 last section, then no move is needed. */
3812 if (sec
!= NULL
&& sec
!= last_sec
)
3814 /* Trim them off. */
3815 if (first_sec
->prev
!= NULL
)
3816 first_sec
->prev
->next
= last_sec
->next
;
3818 link_info
.output_bfd
->sections
= last_sec
->next
;
3819 if (last_sec
->next
!= NULL
)
3820 last_sec
->next
->prev
= first_sec
->prev
;
3822 link_info
.output_bfd
->section_last
= first_sec
->prev
;
3824 last_sec
->next
= sec
->next
;
3825 if (sec
->next
!= NULL
)
3826 sec
->next
->prev
= last_sec
;
3828 link_info
.output_bfd
->section_last
= last_sec
;
3829 first_sec
->prev
= sec
;
3830 sec
->next
= first_sec
;
3838 ptr
= insert_os_after (where
);
3839 /* Snip everything after the abs_section output statement we
3840 know is at the start of the list, up to and including
3841 the insert statement we are currently processing. */
3842 first
= lang_output_section_statement
.head
->header
.next
;
3843 lang_output_section_statement
.head
->header
.next
= (*s
)->header
.next
;
3844 /* Add them back where they belong. */
3847 statement_list
.tail
= s
;
3849 s
= &lang_output_section_statement
.head
;
3853 /* Undo constraint twiddling. */
3854 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
3856 os
->constraint
= -2 - os
->constraint
;
3862 /* An output section might have been removed after its statement was
3863 added. For example, ldemul_before_allocation can remove dynamic
3864 sections if they turn out to be not needed. Clean them up here. */
3867 strip_excluded_output_sections (void)
3869 lang_output_section_statement_type
*os
;
3871 /* Run lang_size_sections (if not already done). */
3872 if (expld
.phase
!= lang_mark_phase_enum
)
3874 expld
.phase
= lang_mark_phase_enum
;
3875 expld
.dataseg
.phase
= exp_dataseg_none
;
3876 one_lang_size_sections_pass (NULL
, FALSE
);
3877 lang_reset_memory_regions ();
3880 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
3884 asection
*output_section
;
3885 bfd_boolean exclude
;
3887 if (os
->constraint
< 0)
3890 output_section
= os
->bfd_section
;
3891 if (output_section
== NULL
)
3894 exclude
= (output_section
->rawsize
== 0
3895 && (output_section
->flags
& SEC_KEEP
) == 0
3896 && !bfd_section_removed_from_list (link_info
.output_bfd
,
3899 /* Some sections have not yet been sized, notably .gnu.version,
3900 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
3901 input sections, so don't drop output sections that have such
3902 input sections unless they are also marked SEC_EXCLUDE. */
3903 if (exclude
&& output_section
->map_head
.s
!= NULL
)
3907 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
3908 if ((s
->flags
& SEC_EXCLUDE
) == 0
3909 && ((s
->flags
& SEC_LINKER_CREATED
) != 0
3910 || link_info
.emitrelocations
))
3919 /* We don't set bfd_section to NULL since bfd_section of the
3920 removed output section statement may still be used. */
3921 if (!os
->update_dot
)
3923 output_section
->flags
|= SEC_EXCLUDE
;
3924 bfd_section_list_remove (link_info
.output_bfd
, output_section
);
3925 link_info
.output_bfd
->section_count
--;
3930 /* Called from ldwrite to clear out asection.map_head and
3931 asection.map_tail for use as link_orders in ldwrite.
3932 FIXME: Except for sh64elf.em which starts creating link_orders in
3933 its after_allocation routine so needs to call it early. */
3936 lang_clear_os_map (void)
3938 lang_output_section_statement_type
*os
;
3940 if (map_head_is_link_order
)
3943 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
3947 asection
*output_section
;
3949 if (os
->constraint
< 0)
3952 output_section
= os
->bfd_section
;
3953 if (output_section
== NULL
)
3956 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
3957 output_section
->map_head
.link_order
= NULL
;
3958 output_section
->map_tail
.link_order
= NULL
;
3961 /* Stop future calls to lang_add_section from messing with map_head
3962 and map_tail link_order fields. */
3963 map_head_is_link_order
= TRUE
;
3967 print_output_section_statement
3968 (lang_output_section_statement_type
*output_section_statement
)
3970 asection
*section
= output_section_statement
->bfd_section
;
3973 if (output_section_statement
!= abs_output_section
)
3975 minfo ("\n%s", output_section_statement
->name
);
3977 if (section
!= NULL
)
3979 print_dot
= section
->vma
;
3981 len
= strlen (output_section_statement
->name
);
3982 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
3987 while (len
< SECTION_NAME_MAP_LENGTH
)
3993 minfo ("0x%V %W", section
->vma
, section
->size
);
3995 if (section
->vma
!= section
->lma
)
3996 minfo (_(" load address 0x%V"), section
->lma
);
3998 if (output_section_statement
->update_dot_tree
!= NULL
)
3999 exp_fold_tree (output_section_statement
->update_dot_tree
,
4000 bfd_abs_section_ptr
, &print_dot
);
4006 print_statement_list (output_section_statement
->children
.head
,
4007 output_section_statement
);
4011 print_assignment (lang_assignment_statement_type
*assignment
,
4012 lang_output_section_statement_type
*output_section
)
4019 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4022 if (assignment
->exp
->type
.node_class
== etree_assert
)
4025 tree
= assignment
->exp
->assert_s
.child
;
4029 const char *dst
= assignment
->exp
->assign
.dst
;
4031 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
4033 expld
.assign_name
= dst
;
4034 tree
= assignment
->exp
->assign
.src
;
4037 osec
= output_section
->bfd_section
;
4039 osec
= bfd_abs_section_ptr
;
4041 if (assignment
->exp
->type
.node_class
!= etree_provide
)
4042 exp_fold_tree (tree
, osec
, &print_dot
);
4044 expld
.result
.valid_p
= FALSE
;
4046 if (expld
.result
.valid_p
)
4050 if (assignment
->exp
->type
.node_class
== etree_assert
4052 || expld
.assign_name
!= NULL
)
4054 value
= expld
.result
.value
;
4056 if (expld
.result
.section
!= NULL
)
4057 value
+= expld
.result
.section
->vma
;
4059 minfo ("0x%V", value
);
4065 struct bfd_link_hash_entry
*h
;
4067 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
4068 FALSE
, FALSE
, TRUE
);
4071 value
= h
->u
.def
.value
;
4072 value
+= h
->u
.def
.section
->output_section
->vma
;
4073 value
+= h
->u
.def
.section
->output_offset
;
4075 minfo ("[0x%V]", value
);
4078 minfo ("[unresolved]");
4083 if (assignment
->exp
->type
.node_class
== etree_provide
)
4084 minfo ("[!provide]");
4091 expld
.assign_name
= NULL
;
4094 exp_print_tree (assignment
->exp
);
4099 print_input_statement (lang_input_statement_type
*statm
)
4101 if (statm
->filename
!= NULL
4102 && (statm
->the_bfd
== NULL
4103 || (statm
->the_bfd
->flags
& BFD_LINKER_CREATED
) == 0))
4104 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
4107 /* Print all symbols defined in a particular section. This is called
4108 via bfd_link_hash_traverse, or by print_all_symbols. */
4111 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
4113 asection
*sec
= (asection
*) ptr
;
4115 if ((hash_entry
->type
== bfd_link_hash_defined
4116 || hash_entry
->type
== bfd_link_hash_defweak
)
4117 && sec
== hash_entry
->u
.def
.section
)
4121 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4124 (hash_entry
->u
.def
.value
4125 + hash_entry
->u
.def
.section
->output_offset
4126 + hash_entry
->u
.def
.section
->output_section
->vma
));
4128 minfo (" %T\n", hash_entry
->root
.string
);
4135 hash_entry_addr_cmp (const void *a
, const void *b
)
4137 const struct bfd_link_hash_entry
*l
= *(const struct bfd_link_hash_entry
**)a
;
4138 const struct bfd_link_hash_entry
*r
= *(const struct bfd_link_hash_entry
**)b
;
4140 if (l
->u
.def
.value
< r
->u
.def
.value
)
4142 else if (l
->u
.def
.value
> r
->u
.def
.value
)
4149 print_all_symbols (asection
*sec
)
4151 input_section_userdata_type
*ud
4152 = (input_section_userdata_type
*) get_userdata (sec
);
4153 struct map_symbol_def
*def
;
4154 struct bfd_link_hash_entry
**entries
;
4160 *ud
->map_symbol_def_tail
= 0;
4162 /* Sort the symbols by address. */
4163 entries
= (struct bfd_link_hash_entry
**)
4164 obstack_alloc (&map_obstack
, ud
->map_symbol_def_count
* sizeof (*entries
));
4166 for (i
= 0, def
= ud
->map_symbol_def_head
; def
; def
= def
->next
, i
++)
4167 entries
[i
] = def
->entry
;
4169 qsort (entries
, ud
->map_symbol_def_count
, sizeof (*entries
),
4170 hash_entry_addr_cmp
);
4172 /* Print the symbols. */
4173 for (i
= 0; i
< ud
->map_symbol_def_count
; i
++)
4174 print_one_symbol (entries
[i
], sec
);
4176 obstack_free (&map_obstack
, entries
);
4179 /* Print information about an input section to the map file. */
4182 print_input_section (asection
*i
, bfd_boolean is_discarded
)
4184 bfd_size_type size
= i
->size
;
4191 minfo ("%s", i
->name
);
4193 len
= 1 + strlen (i
->name
);
4194 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4199 while (len
< SECTION_NAME_MAP_LENGTH
)
4205 if (i
->output_section
!= NULL
4206 && i
->output_section
->owner
== link_info
.output_bfd
)
4207 addr
= i
->output_section
->vma
+ i
->output_offset
;
4215 minfo ("0x%V %W %B\n", addr
, TO_ADDR (size
), i
->owner
);
4217 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
4219 len
= SECTION_NAME_MAP_LENGTH
+ 3;
4231 minfo (_("%W (size before relaxing)\n"), i
->rawsize
);
4234 if (i
->output_section
!= NULL
4235 && i
->output_section
->owner
== link_info
.output_bfd
)
4237 if (link_info
.reduce_memory_overheads
)
4238 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, i
);
4240 print_all_symbols (i
);
4242 /* Update print_dot, but make sure that we do not move it
4243 backwards - this could happen if we have overlays and a
4244 later overlay is shorter than an earier one. */
4245 if (addr
+ TO_ADDR (size
) > print_dot
)
4246 print_dot
= addr
+ TO_ADDR (size
);
4251 print_fill_statement (lang_fill_statement_type
*fill
)
4255 fputs (" FILL mask 0x", config
.map_file
);
4256 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
4257 fprintf (config
.map_file
, "%02x", *p
);
4258 fputs ("\n", config
.map_file
);
4262 print_data_statement (lang_data_statement_type
*data
)
4270 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4273 addr
= data
->output_offset
;
4274 if (data
->output_section
!= NULL
)
4275 addr
+= data
->output_section
->vma
;
4303 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
4305 if (data
->exp
->type
.node_class
!= etree_value
)
4308 exp_print_tree (data
->exp
);
4313 print_dot
= addr
+ TO_ADDR (size
);
4316 /* Print an address statement. These are generated by options like
4320 print_address_statement (lang_address_statement_type
*address
)
4322 minfo (_("Address of section %s set to "), address
->section_name
);
4323 exp_print_tree (address
->address
);
4327 /* Print a reloc statement. */
4330 print_reloc_statement (lang_reloc_statement_type
*reloc
)
4337 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4340 addr
= reloc
->output_offset
;
4341 if (reloc
->output_section
!= NULL
)
4342 addr
+= reloc
->output_section
->vma
;
4344 size
= bfd_get_reloc_size (reloc
->howto
);
4346 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
4348 if (reloc
->name
!= NULL
)
4349 minfo ("%s+", reloc
->name
);
4351 minfo ("%s+", reloc
->section
->name
);
4353 exp_print_tree (reloc
->addend_exp
);
4357 print_dot
= addr
+ TO_ADDR (size
);
4361 print_padding_statement (lang_padding_statement_type
*s
)
4369 len
= sizeof " *fill*" - 1;
4370 while (len
< SECTION_NAME_MAP_LENGTH
)
4376 addr
= s
->output_offset
;
4377 if (s
->output_section
!= NULL
)
4378 addr
+= s
->output_section
->vma
;
4379 minfo ("0x%V %W ", addr
, (bfd_vma
) s
->size
);
4381 if (s
->fill
->size
!= 0)
4385 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
4386 fprintf (config
.map_file
, "%02x", *p
);
4391 print_dot
= addr
+ TO_ADDR (s
->size
);
4395 print_wild_statement (lang_wild_statement_type
*w
,
4396 lang_output_section_statement_type
*os
)
4398 struct wildcard_list
*sec
;
4402 if (w
->filenames_sorted
)
4404 if (w
->filename
!= NULL
)
4405 minfo ("%s", w
->filename
);
4408 if (w
->filenames_sorted
)
4412 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
4414 if (sec
->spec
.sorted
)
4416 if (sec
->spec
.exclude_name_list
!= NULL
)
4419 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
4420 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4421 minfo (" %s", tmp
->name
);
4424 if (sec
->spec
.name
!= NULL
)
4425 minfo ("%s", sec
->spec
.name
);
4428 if (sec
->spec
.sorted
)
4437 print_statement_list (w
->children
.head
, os
);
4440 /* Print a group statement. */
4443 print_group (lang_group_statement_type
*s
,
4444 lang_output_section_statement_type
*os
)
4446 fprintf (config
.map_file
, "START GROUP\n");
4447 print_statement_list (s
->children
.head
, os
);
4448 fprintf (config
.map_file
, "END GROUP\n");
4451 /* Print the list of statements in S.
4452 This can be called for any statement type. */
4455 print_statement_list (lang_statement_union_type
*s
,
4456 lang_output_section_statement_type
*os
)
4460 print_statement (s
, os
);
4465 /* Print the first statement in statement list S.
4466 This can be called for any statement type. */
4469 print_statement (lang_statement_union_type
*s
,
4470 lang_output_section_statement_type
*os
)
4472 switch (s
->header
.type
)
4475 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
4478 case lang_constructors_statement_enum
:
4479 if (constructor_list
.head
!= NULL
)
4481 if (constructors_sorted
)
4482 minfo (" SORT (CONSTRUCTORS)\n");
4484 minfo (" CONSTRUCTORS\n");
4485 print_statement_list (constructor_list
.head
, os
);
4488 case lang_wild_statement_enum
:
4489 print_wild_statement (&s
->wild_statement
, os
);
4491 case lang_address_statement_enum
:
4492 print_address_statement (&s
->address_statement
);
4494 case lang_object_symbols_statement_enum
:
4495 minfo (" CREATE_OBJECT_SYMBOLS\n");
4497 case lang_fill_statement_enum
:
4498 print_fill_statement (&s
->fill_statement
);
4500 case lang_data_statement_enum
:
4501 print_data_statement (&s
->data_statement
);
4503 case lang_reloc_statement_enum
:
4504 print_reloc_statement (&s
->reloc_statement
);
4506 case lang_input_section_enum
:
4507 print_input_section (s
->input_section
.section
, FALSE
);
4509 case lang_padding_statement_enum
:
4510 print_padding_statement (&s
->padding_statement
);
4512 case lang_output_section_statement_enum
:
4513 print_output_section_statement (&s
->output_section_statement
);
4515 case lang_assignment_statement_enum
:
4516 print_assignment (&s
->assignment_statement
, os
);
4518 case lang_target_statement_enum
:
4519 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
4521 case lang_output_statement_enum
:
4522 minfo ("OUTPUT(%s", s
->output_statement
.name
);
4523 if (output_target
!= NULL
)
4524 minfo (" %s", output_target
);
4527 case lang_input_statement_enum
:
4528 print_input_statement (&s
->input_statement
);
4530 case lang_group_statement_enum
:
4531 print_group (&s
->group_statement
, os
);
4533 case lang_insert_statement_enum
:
4534 minfo ("INSERT %s %s\n",
4535 s
->insert_statement
.is_before
? "BEFORE" : "AFTER",
4536 s
->insert_statement
.where
);
4542 print_statements (void)
4544 print_statement_list (statement_list
.head
, abs_output_section
);
4547 /* Print the first N statements in statement list S to STDERR.
4548 If N == 0, nothing is printed.
4549 If N < 0, the entire list is printed.
4550 Intended to be called from GDB. */
4553 dprint_statement (lang_statement_union_type
*s
, int n
)
4555 FILE *map_save
= config
.map_file
;
4557 config
.map_file
= stderr
;
4560 print_statement_list (s
, abs_output_section
);
4563 while (s
&& --n
>= 0)
4565 print_statement (s
, abs_output_section
);
4570 config
.map_file
= map_save
;
4574 insert_pad (lang_statement_union_type
**ptr
,
4576 bfd_size_type alignment_needed
,
4577 asection
*output_section
,
4580 static fill_type zero_fill
;
4581 lang_statement_union_type
*pad
= NULL
;
4583 if (ptr
!= &statement_list
.head
)
4584 pad
= ((lang_statement_union_type
*)
4585 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
4587 && pad
->header
.type
== lang_padding_statement_enum
4588 && pad
->padding_statement
.output_section
== output_section
)
4590 /* Use the existing pad statement. */
4592 else if ((pad
= *ptr
) != NULL
4593 && pad
->header
.type
== lang_padding_statement_enum
4594 && pad
->padding_statement
.output_section
== output_section
)
4596 /* Use the existing pad statement. */
4600 /* Make a new padding statement, linked into existing chain. */
4601 pad
= (lang_statement_union_type
*)
4602 stat_alloc (sizeof (lang_padding_statement_type
));
4603 pad
->header
.next
= *ptr
;
4605 pad
->header
.type
= lang_padding_statement_enum
;
4606 pad
->padding_statement
.output_section
= output_section
;
4609 pad
->padding_statement
.fill
= fill
;
4611 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
4612 pad
->padding_statement
.size
= alignment_needed
;
4613 output_section
->size
= TO_SIZE (dot
+ TO_ADDR (alignment_needed
)
4614 - output_section
->vma
);
4617 /* Work out how much this section will move the dot point. */
4621 (lang_statement_union_type
**this_ptr
,
4622 lang_output_section_statement_type
*output_section_statement
,
4626 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
4627 asection
*i
= is
->section
;
4628 asection
*o
= output_section_statement
->bfd_section
;
4630 if (i
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
4631 i
->output_offset
= i
->vma
- o
->vma
;
4632 else if ((i
->flags
& SEC_EXCLUDE
) != 0)
4633 i
->output_offset
= dot
- o
->vma
;
4636 bfd_size_type alignment_needed
;
4638 /* Align this section first to the input sections requirement,
4639 then to the output section's requirement. If this alignment
4640 is greater than any seen before, then record it too. Perform
4641 the alignment by inserting a magic 'padding' statement. */
4643 if (output_section_statement
->subsection_alignment
!= -1)
4644 i
->alignment_power
= output_section_statement
->subsection_alignment
;
4646 if (o
->alignment_power
< i
->alignment_power
)
4647 o
->alignment_power
= i
->alignment_power
;
4649 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
4651 if (alignment_needed
!= 0)
4653 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
4654 dot
+= alignment_needed
;
4657 /* Remember where in the output section this input section goes. */
4658 i
->output_offset
= dot
- o
->vma
;
4660 /* Mark how big the output section must be to contain this now. */
4661 dot
+= TO_ADDR (i
->size
);
4662 o
->size
= TO_SIZE (dot
- o
->vma
);
4669 sort_sections_by_lma (const void *arg1
, const void *arg2
)
4671 const asection
*sec1
= *(const asection
**) arg1
;
4672 const asection
*sec2
= *(const asection
**) arg2
;
4674 if (bfd_section_lma (sec1
->owner
, sec1
)
4675 < bfd_section_lma (sec2
->owner
, sec2
))
4677 else if (bfd_section_lma (sec1
->owner
, sec1
)
4678 > bfd_section_lma (sec2
->owner
, sec2
))
4680 else if (sec1
->id
< sec2
->id
)
4682 else if (sec1
->id
> sec2
->id
)
4688 #define IGNORE_SECTION(s) \
4689 ((s->flags & SEC_ALLOC) == 0 \
4690 || ((s->flags & SEC_THREAD_LOCAL) != 0 \
4691 && (s->flags & SEC_LOAD) == 0))
4693 /* Check to see if any allocated sections overlap with other allocated
4694 sections. This can happen if a linker script specifies the output
4695 section addresses of the two sections. Also check whether any memory
4696 region has overflowed. */
4699 lang_check_section_addresses (void)
4702 asection
**sections
, **spp
;
4709 lang_memory_region_type
*m
;
4711 if (bfd_count_sections (link_info
.output_bfd
) <= 1)
4714 amt
= bfd_count_sections (link_info
.output_bfd
) * sizeof (asection
*);
4715 sections
= (asection
**) xmalloc (amt
);
4717 /* Scan all sections in the output list. */
4719 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
4721 /* Only consider loadable sections with real contents. */
4722 if (!(s
->flags
& SEC_LOAD
)
4723 || !(s
->flags
& SEC_ALLOC
)
4727 sections
[count
] = s
;
4734 qsort (sections
, (size_t) count
, sizeof (asection
*),
4735 sort_sections_by_lma
);
4740 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
4741 for (count
--; count
; count
--)
4743 /* We must check the sections' LMA addresses not their VMA
4744 addresses because overlay sections can have overlapping VMAs
4745 but they must have distinct LMAs. */
4751 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
4753 /* Look for an overlap. We have sorted sections by lma, so we
4754 know that s_start >= p_start. Besides the obvious case of
4755 overlap when the current section starts before the previous
4756 one ends, we also must have overlap if the previous section
4757 wraps around the address space. */
4758 if (s_start
<= p_end
4760 einfo (_("%X%P: section %s loaded at [%V,%V] overlaps section %s loaded at [%V,%V]\n"),
4761 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
4766 /* If any memory region has overflowed, report by how much.
4767 We do not issue this diagnostic for regions that had sections
4768 explicitly placed outside their bounds; os_region_check's
4769 diagnostics are adequate for that case.
4771 FIXME: It is conceivable that m->current - (m->origin + m->length)
4772 might overflow a 32-bit integer. There is, alas, no way to print
4773 a bfd_vma quantity in decimal. */
4774 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
4775 if (m
->had_full_message
)
4776 einfo (_("%X%P: region `%s' overflowed by %ld bytes\n"),
4777 m
->name_list
.name
, (long)(m
->current
- (m
->origin
+ m
->length
)));
4781 /* Make sure the new address is within the region. We explicitly permit the
4782 current address to be at the exact end of the region when the address is
4783 non-zero, in case the region is at the end of addressable memory and the
4784 calculation wraps around. */
4787 os_region_check (lang_output_section_statement_type
*os
,
4788 lang_memory_region_type
*region
,
4792 if ((region
->current
< region
->origin
4793 || (region
->current
- region
->origin
> region
->length
))
4794 && ((region
->current
!= region
->origin
+ region
->length
)
4799 einfo (_("%X%P: address 0x%v of %B section `%s'"
4800 " is not within region `%s'\n"),
4802 os
->bfd_section
->owner
,
4803 os
->bfd_section
->name
,
4804 region
->name_list
.name
);
4806 else if (!region
->had_full_message
)
4808 region
->had_full_message
= TRUE
;
4810 einfo (_("%X%P: %B section `%s' will not fit in region `%s'\n"),
4811 os
->bfd_section
->owner
,
4812 os
->bfd_section
->name
,
4813 region
->name_list
.name
);
4818 /* Set the sizes for all the output sections. */
4821 lang_size_sections_1
4822 (lang_statement_union_type
**prev
,
4823 lang_output_section_statement_type
*output_section_statement
,
4827 bfd_boolean check_regions
)
4829 lang_statement_union_type
*s
;
4831 /* Size up the sections from their constituent parts. */
4832 for (s
= *prev
; s
!= NULL
; s
= s
->header
.next
)
4834 switch (s
->header
.type
)
4836 case lang_output_section_statement_enum
:
4838 bfd_vma newdot
, after
, dotdelta
;
4839 lang_output_section_statement_type
*os
;
4840 lang_memory_region_type
*r
;
4841 int section_alignment
= 0;
4843 os
= &s
->output_section_statement
;
4844 if (os
->constraint
== -1)
4847 /* FIXME: We shouldn't need to zero section vmas for ld -r
4848 here, in lang_insert_orphan, or in the default linker scripts.
4849 This is covering for coff backend linker bugs. See PR6945. */
4850 if (os
->addr_tree
== NULL
4851 && bfd_link_relocatable (&link_info
)
4852 && (bfd_get_flavour (link_info
.output_bfd
)
4853 == bfd_target_coff_flavour
))
4854 os
->addr_tree
= exp_intop (0);
4855 if (os
->addr_tree
!= NULL
)
4857 os
->processed_vma
= FALSE
;
4858 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
4860 if (expld
.result
.valid_p
)
4862 dot
= expld
.result
.value
;
4863 if (expld
.result
.section
!= NULL
)
4864 dot
+= expld
.result
.section
->vma
;
4866 else if (expld
.phase
!= lang_mark_phase_enum
)
4867 einfo (_("%F%S: non constant or forward reference"
4868 " address expression for section %s\n"),
4869 os
->addr_tree
, os
->name
);
4872 if (os
->bfd_section
== NULL
)
4873 /* This section was removed or never actually created. */
4876 /* If this is a COFF shared library section, use the size and
4877 address from the input section. FIXME: This is COFF
4878 specific; it would be cleaner if there were some other way
4879 to do this, but nothing simple comes to mind. */
4880 if (((bfd_get_flavour (link_info
.output_bfd
)
4881 == bfd_target_ecoff_flavour
)
4882 || (bfd_get_flavour (link_info
.output_bfd
)
4883 == bfd_target_coff_flavour
))
4884 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
4888 if (os
->children
.head
== NULL
4889 || os
->children
.head
->header
.next
!= NULL
4890 || (os
->children
.head
->header
.type
4891 != lang_input_section_enum
))
4892 einfo (_("%P%X: Internal error on COFF shared library"
4893 " section %s\n"), os
->name
);
4895 input
= os
->children
.head
->input_section
.section
;
4896 bfd_set_section_vma (os
->bfd_section
->owner
,
4898 bfd_section_vma (input
->owner
, input
));
4899 os
->bfd_section
->size
= input
->size
;
4905 if (bfd_is_abs_section (os
->bfd_section
))
4907 /* No matter what happens, an abs section starts at zero. */
4908 ASSERT (os
->bfd_section
->vma
== 0);
4912 if (os
->addr_tree
== NULL
)
4914 /* No address specified for this section, get one
4915 from the region specification. */
4916 if (os
->region
== NULL
4917 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
4918 && os
->region
->name_list
.name
[0] == '*'
4919 && strcmp (os
->region
->name_list
.name
,
4920 DEFAULT_MEMORY_REGION
) == 0))
4922 os
->region
= lang_memory_default (os
->bfd_section
);
4925 /* If a loadable section is using the default memory
4926 region, and some non default memory regions were
4927 defined, issue an error message. */
4929 && !IGNORE_SECTION (os
->bfd_section
)
4930 && !bfd_link_relocatable (&link_info
)
4932 && strcmp (os
->region
->name_list
.name
,
4933 DEFAULT_MEMORY_REGION
) == 0
4934 && lang_memory_region_list
!= NULL
4935 && (strcmp (lang_memory_region_list
->name_list
.name
,
4936 DEFAULT_MEMORY_REGION
) != 0
4937 || lang_memory_region_list
->next
!= NULL
)
4938 && expld
.phase
!= lang_mark_phase_enum
)
4940 /* By default this is an error rather than just a
4941 warning because if we allocate the section to the
4942 default memory region we can end up creating an
4943 excessively large binary, or even seg faulting when
4944 attempting to perform a negative seek. See
4945 sources.redhat.com/ml/binutils/2003-04/msg00423.html
4946 for an example of this. This behaviour can be
4947 overridden by the using the --no-check-sections
4949 if (command_line
.check_section_addresses
)
4950 einfo (_("%P%F: error: no memory region specified"
4951 " for loadable section `%s'\n"),
4952 bfd_get_section_name (link_info
.output_bfd
,
4955 einfo (_("%P: warning: no memory region specified"
4956 " for loadable section `%s'\n"),
4957 bfd_get_section_name (link_info
.output_bfd
,
4961 newdot
= os
->region
->current
;
4962 section_alignment
= os
->bfd_section
->alignment_power
;
4965 section_alignment
= os
->section_alignment
;
4967 /* Align to what the section needs. */
4968 if (section_alignment
> 0)
4970 bfd_vma savedot
= newdot
;
4971 newdot
= align_power (newdot
, section_alignment
);
4973 dotdelta
= newdot
- savedot
;
4975 && (config
.warn_section_align
4976 || os
->addr_tree
!= NULL
)
4977 && expld
.phase
!= lang_mark_phase_enum
)
4978 einfo (_("%P: warning: changing start of section"
4979 " %s by %lu bytes\n"),
4980 os
->name
, (unsigned long) dotdelta
);
4983 bfd_set_section_vma (0, os
->bfd_section
, newdot
);
4985 os
->bfd_section
->output_offset
= 0;
4988 lang_size_sections_1 (&os
->children
.head
, os
,
4989 os
->fill
, newdot
, relax
, check_regions
);
4991 os
->processed_vma
= TRUE
;
4993 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
4994 /* Except for some special linker created sections,
4995 no output section should change from zero size
4996 after strip_excluded_output_sections. A non-zero
4997 size on an ignored section indicates that some
4998 input section was not sized early enough. */
4999 ASSERT (os
->bfd_section
->size
== 0);
5002 dot
= os
->bfd_section
->vma
;
5004 /* Put the section within the requested block size, or
5005 align at the block boundary. */
5007 + TO_ADDR (os
->bfd_section
->size
)
5008 + os
->block_value
- 1)
5009 & - (bfd_vma
) os
->block_value
);
5011 os
->bfd_section
->size
= TO_SIZE (after
- os
->bfd_section
->vma
);
5014 /* Set section lma. */
5017 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
5021 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
5022 os
->bfd_section
->lma
= lma
;
5024 else if (os
->lma_region
!= NULL
)
5026 bfd_vma lma
= os
->lma_region
->current
;
5028 if (os
->align_lma_with_input
)
5032 /* When LMA_REGION is the same as REGION, align the LMA
5033 as we did for the VMA, possibly including alignment
5034 from the bfd section. If a different region, then
5035 only align according to the value in the output
5037 if (os
->lma_region
!= os
->region
)
5038 section_alignment
= os
->section_alignment
;
5039 if (section_alignment
> 0)
5040 lma
= align_power (lma
, section_alignment
);
5042 os
->bfd_section
->lma
= lma
;
5044 else if (r
->last_os
!= NULL
5045 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5050 last
= r
->last_os
->output_section_statement
.bfd_section
;
5052 /* A backwards move of dot should be accompanied by
5053 an explicit assignment to the section LMA (ie.
5054 os->load_base set) because backwards moves can
5055 create overlapping LMAs. */
5057 && os
->bfd_section
->size
!= 0
5058 && dot
+ os
->bfd_section
->size
<= last
->vma
)
5060 /* If dot moved backwards then leave lma equal to
5061 vma. This is the old default lma, which might
5062 just happen to work when the backwards move is
5063 sufficiently large. Nag if this changes anything,
5064 so people can fix their linker scripts. */
5066 if (last
->vma
!= last
->lma
)
5067 einfo (_("%P: warning: dot moved backwards before `%s'\n"),
5072 /* If this is an overlay, set the current lma to that
5073 at the end of the previous section. */
5074 if (os
->sectype
== overlay_section
)
5075 lma
= last
->lma
+ last
->size
;
5077 /* Otherwise, keep the same lma to vma relationship
5078 as the previous section. */
5080 lma
= dot
+ last
->lma
- last
->vma
;
5082 if (section_alignment
> 0)
5083 lma
= align_power (lma
, section_alignment
);
5084 os
->bfd_section
->lma
= lma
;
5087 os
->processed_lma
= TRUE
;
5089 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5092 /* Keep track of normal sections using the default
5093 lma region. We use this to set the lma for
5094 following sections. Overlays or other linker
5095 script assignment to lma might mean that the
5096 default lma == vma is incorrect.
5097 To avoid warnings about dot moving backwards when using
5098 -Ttext, don't start tracking sections until we find one
5099 of non-zero size or with lma set differently to vma. */
5100 if (((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
5101 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0)
5102 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0
5103 && (os
->bfd_section
->size
!= 0
5104 || (r
->last_os
== NULL
5105 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
5106 || (r
->last_os
!= NULL
5107 && dot
>= (r
->last_os
->output_section_statement
5108 .bfd_section
->vma
)))
5109 && os
->lma_region
== NULL
5110 && !bfd_link_relocatable (&link_info
))
5113 /* .tbss sections effectively have zero size. */
5114 if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
5115 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0
5116 || bfd_link_relocatable (&link_info
))
5117 dotdelta
= TO_ADDR (os
->bfd_section
->size
);
5122 if (os
->update_dot_tree
!= 0)
5123 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5125 /* Update dot in the region ?
5126 We only do this if the section is going to be allocated,
5127 since unallocated sections do not contribute to the region's
5128 overall size in memory. */
5129 if (os
->region
!= NULL
5130 && (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)))
5132 os
->region
->current
= dot
;
5135 /* Make sure the new address is within the region. */
5136 os_region_check (os
, os
->region
, os
->addr_tree
,
5137 os
->bfd_section
->vma
);
5139 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
5140 && ((os
->bfd_section
->flags
& SEC_LOAD
)
5141 || os
->align_lma_with_input
))
5143 os
->lma_region
->current
= os
->bfd_section
->lma
+ dotdelta
;
5146 os_region_check (os
, os
->lma_region
, NULL
,
5147 os
->bfd_section
->lma
);
5153 case lang_constructors_statement_enum
:
5154 dot
= lang_size_sections_1 (&constructor_list
.head
,
5155 output_section_statement
,
5156 fill
, dot
, relax
, check_regions
);
5159 case lang_data_statement_enum
:
5161 unsigned int size
= 0;
5163 s
->data_statement
.output_offset
=
5164 dot
- output_section_statement
->bfd_section
->vma
;
5165 s
->data_statement
.output_section
=
5166 output_section_statement
->bfd_section
;
5168 /* We might refer to provided symbols in the expression, and
5169 need to mark them as needed. */
5170 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5172 switch (s
->data_statement
.type
)
5190 if (size
< TO_SIZE ((unsigned) 1))
5191 size
= TO_SIZE ((unsigned) 1);
5192 dot
+= TO_ADDR (size
);
5193 output_section_statement
->bfd_section
->size
5194 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5199 case lang_reloc_statement_enum
:
5203 s
->reloc_statement
.output_offset
=
5204 dot
- output_section_statement
->bfd_section
->vma
;
5205 s
->reloc_statement
.output_section
=
5206 output_section_statement
->bfd_section
;
5207 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
5208 dot
+= TO_ADDR (size
);
5209 output_section_statement
->bfd_section
->size
5210 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5214 case lang_wild_statement_enum
:
5215 dot
= lang_size_sections_1 (&s
->wild_statement
.children
.head
,
5216 output_section_statement
,
5217 fill
, dot
, relax
, check_regions
);
5220 case lang_object_symbols_statement_enum
:
5221 link_info
.create_object_symbols_section
=
5222 output_section_statement
->bfd_section
;
5225 case lang_output_statement_enum
:
5226 case lang_target_statement_enum
:
5229 case lang_input_section_enum
:
5233 i
= s
->input_section
.section
;
5238 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
5239 einfo (_("%P%F: can't relax section: %E\n"));
5243 dot
= size_input_section (prev
, output_section_statement
,
5248 case lang_input_statement_enum
:
5251 case lang_fill_statement_enum
:
5252 s
->fill_statement
.output_section
=
5253 output_section_statement
->bfd_section
;
5255 fill
= s
->fill_statement
.fill
;
5258 case lang_assignment_statement_enum
:
5260 bfd_vma newdot
= dot
;
5261 etree_type
*tree
= s
->assignment_statement
.exp
;
5263 expld
.dataseg
.relro
= exp_dataseg_relro_none
;
5265 exp_fold_tree (tree
,
5266 output_section_statement
->bfd_section
,
5269 if (expld
.dataseg
.relro
== exp_dataseg_relro_start
)
5271 if (!expld
.dataseg
.relro_start_stat
)
5272 expld
.dataseg
.relro_start_stat
= s
;
5275 ASSERT (expld
.dataseg
.relro_start_stat
== s
);
5278 else if (expld
.dataseg
.relro
== exp_dataseg_relro_end
)
5280 if (!expld
.dataseg
.relro_end_stat
)
5281 expld
.dataseg
.relro_end_stat
= s
;
5284 ASSERT (expld
.dataseg
.relro_end_stat
== s
);
5287 expld
.dataseg
.relro
= exp_dataseg_relro_none
;
5289 /* This symbol may be relative to this section. */
5290 if ((tree
->type
.node_class
== etree_provided
5291 || tree
->type
.node_class
== etree_assign
)
5292 && (tree
->assign
.dst
[0] != '.'
5293 || tree
->assign
.dst
[1] != '\0'))
5294 output_section_statement
->update_dot
= 1;
5296 if (!output_section_statement
->ignored
)
5298 if (output_section_statement
== abs_output_section
)
5300 /* If we don't have an output section, then just adjust
5301 the default memory address. */
5302 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
5303 FALSE
)->current
= newdot
;
5305 else if (newdot
!= dot
)
5307 /* Insert a pad after this statement. We can't
5308 put the pad before when relaxing, in case the
5309 assignment references dot. */
5310 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
5311 output_section_statement
->bfd_section
, dot
);
5313 /* Don't neuter the pad below when relaxing. */
5316 /* If dot is advanced, this implies that the section
5317 should have space allocated to it, unless the
5318 user has explicitly stated that the section
5319 should not be allocated. */
5320 if (output_section_statement
->sectype
!= noalloc_section
5321 && (output_section_statement
->sectype
!= noload_section
5322 || (bfd_get_flavour (link_info
.output_bfd
)
5323 == bfd_target_elf_flavour
)))
5324 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
5331 case lang_padding_statement_enum
:
5332 /* If this is the first time lang_size_sections is called,
5333 we won't have any padding statements. If this is the
5334 second or later passes when relaxing, we should allow
5335 padding to shrink. If padding is needed on this pass, it
5336 will be added back in. */
5337 s
->padding_statement
.size
= 0;
5339 /* Make sure output_offset is valid. If relaxation shrinks
5340 the section and this pad isn't needed, it's possible to
5341 have output_offset larger than the final size of the
5342 section. bfd_set_section_contents will complain even for
5343 a pad size of zero. */
5344 s
->padding_statement
.output_offset
5345 = dot
- output_section_statement
->bfd_section
->vma
;
5348 case lang_group_statement_enum
:
5349 dot
= lang_size_sections_1 (&s
->group_statement
.children
.head
,
5350 output_section_statement
,
5351 fill
, dot
, relax
, check_regions
);
5354 case lang_insert_statement_enum
:
5357 /* We can only get here when relaxing is turned on. */
5358 case lang_address_statement_enum
:
5365 prev
= &s
->header
.next
;
5370 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
5371 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
5372 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
5373 segments. We are allowed an opportunity to override this decision. */
5376 ldlang_override_segment_assignment (struct bfd_link_info
* info ATTRIBUTE_UNUSED
,
5377 bfd
* abfd ATTRIBUTE_UNUSED
,
5378 asection
* current_section
,
5379 asection
* previous_section
,
5380 bfd_boolean new_segment
)
5382 lang_output_section_statement_type
* cur
;
5383 lang_output_section_statement_type
* prev
;
5385 /* The checks below are only necessary when the BFD library has decided
5386 that the two sections ought to be placed into the same segment. */
5390 /* Paranoia checks. */
5391 if (current_section
== NULL
|| previous_section
== NULL
)
5394 /* If this flag is set, the target never wants code and non-code
5395 sections comingled in the same segment. */
5396 if (config
.separate_code
5397 && ((current_section
->flags
^ previous_section
->flags
) & SEC_CODE
))
5400 /* Find the memory regions associated with the two sections.
5401 We call lang_output_section_find() here rather than scanning the list
5402 of output sections looking for a matching section pointer because if
5403 we have a large number of sections then a hash lookup is faster. */
5404 cur
= lang_output_section_find (current_section
->name
);
5405 prev
= lang_output_section_find (previous_section
->name
);
5407 /* More paranoia. */
5408 if (cur
== NULL
|| prev
== NULL
)
5411 /* If the regions are different then force the sections to live in
5412 different segments. See the email thread starting at the following
5413 URL for the reasons why this is necessary:
5414 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
5415 return cur
->region
!= prev
->region
;
5419 one_lang_size_sections_pass (bfd_boolean
*relax
, bfd_boolean check_regions
)
5421 lang_statement_iteration
++;
5422 lang_size_sections_1 (&statement_list
.head
, abs_output_section
,
5423 0, 0, relax
, check_regions
);
5427 lang_size_sections (bfd_boolean
*relax
, bfd_boolean check_regions
)
5429 expld
.phase
= lang_allocating_phase_enum
;
5430 expld
.dataseg
.phase
= exp_dataseg_none
;
5432 one_lang_size_sections_pass (relax
, check_regions
);
5433 if (expld
.dataseg
.phase
== exp_dataseg_end_seen
5434 && link_info
.relro
&& expld
.dataseg
.relro_end
)
5436 bfd_vma initial_base
, relro_end
, desired_end
;
5439 /* Compute the expected PT_GNU_RELRO segment end. */
5440 relro_end
= ((expld
.dataseg
.relro_end
+ expld
.dataseg
.pagesize
- 1)
5441 & ~(expld
.dataseg
.pagesize
- 1));
5443 /* Adjust by the offset arg of DATA_SEGMENT_RELRO_END. */
5444 desired_end
= relro_end
- expld
.dataseg
.relro_offset
;
5446 /* For sections in the relro segment.. */
5447 for (sec
= link_info
.output_bfd
->section_last
; sec
; sec
= sec
->prev
)
5448 if (!IGNORE_SECTION (sec
)
5449 && sec
->vma
>= expld
.dataseg
.base
5450 && sec
->vma
< expld
.dataseg
.relro_end
- expld
.dataseg
.relro_offset
)
5452 /* Where do we want to put this section so that it ends as
5454 bfd_vma start
= sec
->vma
;
5455 bfd_vma end
= start
+ sec
->size
;
5456 bfd_vma bump
= desired_end
- end
;
5457 /* We'd like to increase START by BUMP, but we must heed
5458 alignment so the increase might be less than optimum. */
5459 start
+= bump
& ~(((bfd_vma
) 1 << sec
->alignment_power
) - 1);
5460 /* This is now the desired end for the previous section. */
5461 desired_end
= start
;
5464 expld
.dataseg
.phase
= exp_dataseg_relro_adjust
;
5465 ASSERT (desired_end
>= expld
.dataseg
.base
);
5466 initial_base
= expld
.dataseg
.base
;
5467 expld
.dataseg
.base
= desired_end
;
5468 lang_reset_memory_regions ();
5469 one_lang_size_sections_pass (relax
, check_regions
);
5471 if (expld
.dataseg
.relro_end
> relro_end
)
5473 /* Assignments to dot, or to output section address in a
5474 user script have increased padding over the original.
5476 expld
.dataseg
.base
= initial_base
;
5477 lang_reset_memory_regions ();
5478 one_lang_size_sections_pass (relax
, check_regions
);
5481 link_info
.relro_start
= expld
.dataseg
.base
;
5482 link_info
.relro_end
= expld
.dataseg
.relro_end
;
5484 else if (expld
.dataseg
.phase
== exp_dataseg_end_seen
)
5486 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
5487 a page could be saved in the data segment. */
5488 bfd_vma first
, last
;
5490 first
= -expld
.dataseg
.base
& (expld
.dataseg
.pagesize
- 1);
5491 last
= expld
.dataseg
.end
& (expld
.dataseg
.pagesize
- 1);
5493 && ((expld
.dataseg
.base
& ~(expld
.dataseg
.pagesize
- 1))
5494 != (expld
.dataseg
.end
& ~(expld
.dataseg
.pagesize
- 1)))
5495 && first
+ last
<= expld
.dataseg
.pagesize
)
5497 expld
.dataseg
.phase
= exp_dataseg_adjust
;
5498 lang_reset_memory_regions ();
5499 one_lang_size_sections_pass (relax
, check_regions
);
5502 expld
.dataseg
.phase
= exp_dataseg_done
;
5505 expld
.dataseg
.phase
= exp_dataseg_done
;
5508 static lang_output_section_statement_type
*current_section
;
5509 static lang_assignment_statement_type
*current_assign
;
5510 static bfd_boolean prefer_next_section
;
5512 /* Worker function for lang_do_assignments. Recursiveness goes here. */
5515 lang_do_assignments_1 (lang_statement_union_type
*s
,
5516 lang_output_section_statement_type
*current_os
,
5519 bfd_boolean
*found_end
)
5521 for (; s
!= NULL
; s
= s
->header
.next
)
5523 switch (s
->header
.type
)
5525 case lang_constructors_statement_enum
:
5526 dot
= lang_do_assignments_1 (constructor_list
.head
,
5527 current_os
, fill
, dot
, found_end
);
5530 case lang_output_section_statement_enum
:
5532 lang_output_section_statement_type
*os
;
5534 os
= &(s
->output_section_statement
);
5535 os
->after_end
= *found_end
;
5536 if (os
->bfd_section
!= NULL
&& !os
->ignored
)
5538 if ((os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5540 current_section
= os
;
5541 prefer_next_section
= FALSE
;
5543 dot
= os
->bfd_section
->vma
;
5545 lang_do_assignments_1 (os
->children
.head
,
5546 os
, os
->fill
, dot
, found_end
);
5548 /* .tbss sections effectively have zero size. */
5549 if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
5550 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0
5551 || bfd_link_relocatable (&link_info
))
5552 dot
+= TO_ADDR (os
->bfd_section
->size
);
5554 if (os
->update_dot_tree
!= NULL
)
5555 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5560 case lang_wild_statement_enum
:
5562 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
5563 current_os
, fill
, dot
, found_end
);
5566 case lang_object_symbols_statement_enum
:
5567 case lang_output_statement_enum
:
5568 case lang_target_statement_enum
:
5571 case lang_data_statement_enum
:
5572 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5573 if (expld
.result
.valid_p
)
5575 s
->data_statement
.value
= expld
.result
.value
;
5576 if (expld
.result
.section
!= NULL
)
5577 s
->data_statement
.value
+= expld
.result
.section
->vma
;
5580 einfo (_("%F%P: invalid data statement\n"));
5583 switch (s
->data_statement
.type
)
5601 if (size
< TO_SIZE ((unsigned) 1))
5602 size
= TO_SIZE ((unsigned) 1);
5603 dot
+= TO_ADDR (size
);
5607 case lang_reloc_statement_enum
:
5608 exp_fold_tree (s
->reloc_statement
.addend_exp
,
5609 bfd_abs_section_ptr
, &dot
);
5610 if (expld
.result
.valid_p
)
5611 s
->reloc_statement
.addend_value
= expld
.result
.value
;
5613 einfo (_("%F%P: invalid reloc statement\n"));
5614 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
5617 case lang_input_section_enum
:
5619 asection
*in
= s
->input_section
.section
;
5621 if ((in
->flags
& SEC_EXCLUDE
) == 0)
5622 dot
+= TO_ADDR (in
->size
);
5626 case lang_input_statement_enum
:
5629 case lang_fill_statement_enum
:
5630 fill
= s
->fill_statement
.fill
;
5633 case lang_assignment_statement_enum
:
5634 current_assign
= &s
->assignment_statement
;
5635 if (current_assign
->exp
->type
.node_class
!= etree_assert
)
5637 const char *p
= current_assign
->exp
->assign
.dst
;
5639 if (current_os
== abs_output_section
&& p
[0] == '.' && p
[1] == 0)
5640 prefer_next_section
= TRUE
;
5644 if (strcmp (p
, "end") == 0)
5647 exp_fold_tree (s
->assignment_statement
.exp
,
5648 current_os
->bfd_section
,
5652 case lang_padding_statement_enum
:
5653 dot
+= TO_ADDR (s
->padding_statement
.size
);
5656 case lang_group_statement_enum
:
5657 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
5658 current_os
, fill
, dot
, found_end
);
5661 case lang_insert_statement_enum
:
5664 case lang_address_statement_enum
:
5676 lang_do_assignments (lang_phase_type phase
)
5678 bfd_boolean found_end
= FALSE
;
5680 current_section
= NULL
;
5681 prefer_next_section
= FALSE
;
5682 expld
.phase
= phase
;
5683 lang_statement_iteration
++;
5684 lang_do_assignments_1 (statement_list
.head
,
5685 abs_output_section
, NULL
, 0, &found_end
);
5688 /* For an assignment statement outside of an output section statement,
5689 choose the best of neighbouring output sections to use for values
5693 section_for_dot (void)
5697 /* Assignments belong to the previous output section, unless there
5698 has been an assignment to "dot", in which case following
5699 assignments belong to the next output section. (The assumption
5700 is that an assignment to "dot" is setting up the address for the
5701 next output section.) Except that past the assignment to "_end"
5702 we always associate with the previous section. This exception is
5703 for targets like SH that define an alloc .stack or other
5704 weirdness after non-alloc sections. */
5705 if (current_section
== NULL
|| prefer_next_section
)
5707 lang_statement_union_type
*stmt
;
5708 lang_output_section_statement_type
*os
;
5710 for (stmt
= (lang_statement_union_type
*) current_assign
;
5712 stmt
= stmt
->header
.next
)
5713 if (stmt
->header
.type
== lang_output_section_statement_enum
)
5716 os
= &stmt
->output_section_statement
;
5719 && (os
->bfd_section
== NULL
5720 || (os
->bfd_section
->flags
& SEC_EXCLUDE
) != 0
5721 || bfd_section_removed_from_list (link_info
.output_bfd
,
5725 if (current_section
== NULL
|| os
== NULL
|| !os
->after_end
)
5728 s
= os
->bfd_section
;
5730 s
= link_info
.output_bfd
->section_last
;
5732 && ((s
->flags
& SEC_ALLOC
) == 0
5733 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
5738 return bfd_abs_section_ptr
;
5742 s
= current_section
->bfd_section
;
5744 /* The section may have been stripped. */
5746 && ((s
->flags
& SEC_EXCLUDE
) != 0
5747 || (s
->flags
& SEC_ALLOC
) == 0
5748 || (s
->flags
& SEC_THREAD_LOCAL
) != 0
5749 || bfd_section_removed_from_list (link_info
.output_bfd
, s
)))
5752 s
= link_info
.output_bfd
->sections
;
5754 && ((s
->flags
& SEC_ALLOC
) == 0
5755 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
5760 return bfd_abs_section_ptr
;
5763 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
5764 operator .startof. (section_name), it produces an undefined symbol
5765 .startof.section_name. Similarly, when it sees
5766 .sizeof. (section_name), it produces an undefined symbol
5767 .sizeof.section_name. For all the output sections, we look for
5768 such symbols, and set them to the correct value. */
5771 lang_set_startof (void)
5775 if (bfd_link_relocatable (&link_info
))
5778 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5780 const char *secname
;
5782 struct bfd_link_hash_entry
*h
;
5784 secname
= bfd_get_section_name (link_info
.output_bfd
, s
);
5785 buf
= (char *) xmalloc (10 + strlen (secname
));
5787 sprintf (buf
, ".startof.%s", secname
);
5788 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
5789 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
5791 h
->type
= bfd_link_hash_defined
;
5793 h
->u
.def
.section
= s
;
5796 sprintf (buf
, ".sizeof.%s", secname
);
5797 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
5798 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
5800 h
->type
= bfd_link_hash_defined
;
5801 h
->u
.def
.value
= TO_ADDR (s
->size
);
5802 h
->u
.def
.section
= bfd_abs_section_ptr
;
5812 struct bfd_link_hash_entry
*h
;
5815 if ((bfd_link_relocatable (&link_info
) && !link_info
.gc_sections
)
5816 || bfd_link_dll (&link_info
))
5817 warn
= entry_from_cmdline
;
5821 /* Force the user to specify a root when generating a relocatable with
5823 if (link_info
.gc_sections
&& bfd_link_relocatable (&link_info
)
5824 && !(entry_from_cmdline
|| undef_from_cmdline
))
5825 einfo (_("%P%F: gc-sections requires either an entry or "
5826 "an undefined symbol\n"));
5828 if (entry_symbol
.name
== NULL
)
5830 /* No entry has been specified. Look for the default entry, but
5831 don't warn if we don't find it. */
5832 entry_symbol
.name
= entry_symbol_default
;
5836 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
5837 FALSE
, FALSE
, TRUE
);
5839 && (h
->type
== bfd_link_hash_defined
5840 || h
->type
== bfd_link_hash_defweak
)
5841 && h
->u
.def
.section
->output_section
!= NULL
)
5845 val
= (h
->u
.def
.value
5846 + bfd_get_section_vma (link_info
.output_bfd
,
5847 h
->u
.def
.section
->output_section
)
5848 + h
->u
.def
.section
->output_offset
);
5849 if (! bfd_set_start_address (link_info
.output_bfd
, val
))
5850 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
.name
);
5857 /* We couldn't find the entry symbol. Try parsing it as a
5859 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
5862 if (! bfd_set_start_address (link_info
.output_bfd
, val
))
5863 einfo (_("%P%F: can't set start address\n"));
5869 /* Can't find the entry symbol, and it's not a number. Use
5870 the first address in the text section. */
5871 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
5875 einfo (_("%P: warning: cannot find entry symbol %s;"
5876 " defaulting to %V\n"),
5878 bfd_get_section_vma (link_info
.output_bfd
, ts
));
5879 if (!(bfd_set_start_address
5880 (link_info
.output_bfd
,
5881 bfd_get_section_vma (link_info
.output_bfd
, ts
))))
5882 einfo (_("%P%F: can't set start address\n"));
5887 einfo (_("%P: warning: cannot find entry symbol %s;"
5888 " not setting start address\n"),
5895 /* This is a small function used when we want to ignore errors from
5899 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
5901 /* Don't do anything. */
5904 /* Check that the architecture of all the input files is compatible
5905 with the output file. Also call the backend to let it do any
5906 other checking that is needed. */
5911 lang_statement_union_type
*file
;
5913 const bfd_arch_info_type
*compatible
;
5915 for (file
= file_chain
.head
; file
!= NULL
; file
= file
->input_statement
.next
)
5917 #ifdef ENABLE_PLUGINS
5918 /* Don't check format of files claimed by plugin. */
5919 if (file
->input_statement
.flags
.claimed
)
5921 #endif /* ENABLE_PLUGINS */
5922 input_bfd
= file
->input_statement
.the_bfd
;
5924 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
5925 command_line
.accept_unknown_input_arch
);
5927 /* In general it is not possible to perform a relocatable
5928 link between differing object formats when the input
5929 file has relocations, because the relocations in the
5930 input format may not have equivalent representations in
5931 the output format (and besides BFD does not translate
5932 relocs for other link purposes than a final link). */
5933 if ((bfd_link_relocatable (&link_info
)
5934 || link_info
.emitrelocations
)
5935 && (compatible
== NULL
5936 || (bfd_get_flavour (input_bfd
)
5937 != bfd_get_flavour (link_info
.output_bfd
)))
5938 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
5940 einfo (_("%P%F: Relocatable linking with relocations from"
5941 " format %s (%B) to format %s (%B) is not supported\n"),
5942 bfd_get_target (input_bfd
), input_bfd
,
5943 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
5944 /* einfo with %F exits. */
5947 if (compatible
== NULL
)
5949 if (command_line
.warn_mismatch
)
5950 einfo (_("%P%X: %s architecture of input file `%B'"
5951 " is incompatible with %s output\n"),
5952 bfd_printable_name (input_bfd
), input_bfd
,
5953 bfd_printable_name (link_info
.output_bfd
));
5955 else if (bfd_count_sections (input_bfd
))
5957 /* If the input bfd has no contents, it shouldn't set the
5958 private data of the output bfd. */
5960 bfd_error_handler_type pfn
= NULL
;
5962 /* If we aren't supposed to warn about mismatched input
5963 files, temporarily set the BFD error handler to a
5964 function which will do nothing. We still want to call
5965 bfd_merge_private_bfd_data, since it may set up
5966 information which is needed in the output file. */
5967 if (! command_line
.warn_mismatch
)
5968 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
5969 if (! bfd_merge_private_bfd_data (input_bfd
, link_info
.output_bfd
))
5971 if (command_line
.warn_mismatch
)
5972 einfo (_("%P%X: failed to merge target specific data"
5973 " of file %B\n"), input_bfd
);
5975 if (! command_line
.warn_mismatch
)
5976 bfd_set_error_handler (pfn
);
5981 /* Look through all the global common symbols and attach them to the
5982 correct section. The -sort-common command line switch may be used
5983 to roughly sort the entries by alignment. */
5988 if (command_line
.inhibit_common_definition
)
5990 if (bfd_link_relocatable (&link_info
)
5991 && ! command_line
.force_common_definition
)
5994 if (! config
.sort_common
)
5995 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
6000 if (config
.sort_common
== sort_descending
)
6002 for (power
= 4; power
> 0; power
--)
6003 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6006 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6010 for (power
= 0; power
<= 4; power
++)
6011 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6013 power
= (unsigned int) -1;
6014 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6019 /* Place one common symbol in the correct section. */
6022 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
6024 unsigned int power_of_two
;
6028 if (h
->type
!= bfd_link_hash_common
)
6032 power_of_two
= h
->u
.c
.p
->alignment_power
;
6034 if (config
.sort_common
== sort_descending
6035 && power_of_two
< *(unsigned int *) info
)
6037 else if (config
.sort_common
== sort_ascending
6038 && power_of_two
> *(unsigned int *) info
)
6041 section
= h
->u
.c
.p
->section
;
6042 if (!bfd_define_common_symbol (link_info
.output_bfd
, &link_info
, h
))
6043 einfo (_("%P%F: Could not define common symbol `%T': %E\n"),
6046 if (config
.map_file
!= NULL
)
6048 static bfd_boolean header_printed
;
6053 if (! header_printed
)
6055 minfo (_("\nAllocating common symbols\n"));
6056 minfo (_("Common symbol size file\n\n"));
6057 header_printed
= TRUE
;
6060 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
6061 DMGL_ANSI
| DMGL_PARAMS
);
6064 minfo ("%s", h
->root
.string
);
6065 len
= strlen (h
->root
.string
);
6070 len
= strlen (name
);
6086 if (size
<= 0xffffffff)
6087 sprintf (buf
, "%lx", (unsigned long) size
);
6089 sprintf_vma (buf
, size
);
6099 minfo ("%B\n", section
->owner
);
6105 /* Handle a single orphan section S, placing the orphan into an appropriate
6106 output section. The effects of the --orphan-handling command line
6107 option are handled here. */
6110 ldlang_place_orphan (asection
*s
)
6112 if (config
.orphan_handling
== orphan_handling_discard
)
6114 lang_output_section_statement_type
*os
;
6115 os
= lang_output_section_statement_lookup (DISCARD_SECTION_NAME
, 0,
6117 if (os
->addr_tree
== NULL
6118 && (bfd_link_relocatable (&link_info
)
6119 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6120 os
->addr_tree
= exp_intop (0);
6121 lang_add_section (&os
->children
, s
, NULL
, os
);
6125 lang_output_section_statement_type
*os
;
6126 const char *name
= s
->name
;
6129 if (config
.orphan_handling
== orphan_handling_error
)
6130 einfo ("%X%P: error: unplaced orphan section `%A' from `%B'.\n",
6133 if (config
.unique_orphan_sections
|| unique_section_p (s
, NULL
))
6134 constraint
= SPECIAL
;
6136 os
= ldemul_place_orphan (s
, name
, constraint
);
6139 os
= lang_output_section_statement_lookup (name
, constraint
, TRUE
);
6140 if (os
->addr_tree
== NULL
6141 && (bfd_link_relocatable (&link_info
)
6142 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6143 os
->addr_tree
= exp_intop (0);
6144 lang_add_section (&os
->children
, s
, NULL
, os
);
6147 if (config
.orphan_handling
== orphan_handling_warn
)
6148 einfo ("%P: warning: orphan section `%A' from `%B' being "
6149 "placed in section `%s'.\n",
6150 s
, s
->owner
, os
->name
);
6154 /* Run through the input files and ensure that every input section has
6155 somewhere to go. If one is found without a destination then create
6156 an input request and place it into the statement tree. */
6159 lang_place_orphans (void)
6161 LANG_FOR_EACH_INPUT_STATEMENT (file
)
6165 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6167 if (s
->output_section
== NULL
)
6169 /* This section of the file is not attached, root
6170 around for a sensible place for it to go. */
6172 if (file
->flags
.just_syms
)
6173 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
6174 else if ((s
->flags
& SEC_EXCLUDE
) != 0)
6175 s
->output_section
= bfd_abs_section_ptr
;
6176 else if (strcmp (s
->name
, "COMMON") == 0)
6178 /* This is a lonely common section which must have
6179 come from an archive. We attach to the section
6180 with the wildcard. */
6181 if (!bfd_link_relocatable (&link_info
)
6182 || command_line
.force_common_definition
)
6184 if (default_common_section
== NULL
)
6185 default_common_section
6186 = lang_output_section_statement_lookup (".bss", 0,
6188 lang_add_section (&default_common_section
->children
, s
,
6189 NULL
, default_common_section
);
6193 ldlang_place_orphan (s
);
6200 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
6202 flagword
*ptr_flags
;
6204 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
6210 /* PR 17900: An exclamation mark in the attributes reverses
6211 the sense of any of the attributes that follow. */
6214 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
6218 *ptr_flags
|= SEC_ALLOC
;
6222 *ptr_flags
|= SEC_READONLY
;
6226 *ptr_flags
|= SEC_DATA
;
6230 *ptr_flags
|= SEC_CODE
;
6235 *ptr_flags
|= SEC_LOAD
;
6239 einfo (_("%P%F: invalid character %c (%d) in flags\n"), * flags
, * flags
);
6246 /* Call a function on each input file. This function will be called
6247 on an archive, but not on the elements. */
6250 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
6252 lang_input_statement_type
*f
;
6254 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
6256 f
= (lang_input_statement_type
*) f
->next_real_file
)
6260 /* Call a function on each file. The function will be called on all
6261 the elements of an archive which are included in the link, but will
6262 not be called on the archive file itself. */
6265 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
6267 LANG_FOR_EACH_INPUT_STATEMENT (f
)
6274 ldlang_add_file (lang_input_statement_type
*entry
)
6276 lang_statement_append (&file_chain
,
6277 (lang_statement_union_type
*) entry
,
6280 /* The BFD linker needs to have a list of all input BFDs involved in
6282 ASSERT (entry
->the_bfd
->link
.next
== NULL
);
6283 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
6285 *link_info
.input_bfds_tail
= entry
->the_bfd
;
6286 link_info
.input_bfds_tail
= &entry
->the_bfd
->link
.next
;
6287 entry
->the_bfd
->usrdata
= entry
;
6288 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
6290 /* Look through the sections and check for any which should not be
6291 included in the link. We need to do this now, so that we can
6292 notice when the backend linker tries to report multiple
6293 definition errors for symbols which are in sections we aren't
6294 going to link. FIXME: It might be better to entirely ignore
6295 symbols which are defined in sections which are going to be
6296 discarded. This would require modifying the backend linker for
6297 each backend which might set the SEC_LINK_ONCE flag. If we do
6298 this, we should probably handle SEC_EXCLUDE in the same way. */
6300 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
6304 lang_add_output (const char *name
, int from_script
)
6306 /* Make -o on command line override OUTPUT in script. */
6307 if (!had_output_filename
|| !from_script
)
6309 output_filename
= name
;
6310 had_output_filename
= TRUE
;
6323 for (l
= 0; l
< 32; l
++)
6325 if (i
>= (unsigned int) x
)
6333 lang_output_section_statement_type
*
6334 lang_enter_output_section_statement (const char *output_section_statement_name
,
6335 etree_type
*address_exp
,
6336 enum section_type sectype
,
6338 etree_type
*subalign
,
6341 int align_with_input
)
6343 lang_output_section_statement_type
*os
;
6345 os
= lang_output_section_statement_lookup (output_section_statement_name
,
6347 current_section
= os
;
6349 if (os
->addr_tree
== NULL
)
6351 os
->addr_tree
= address_exp
;
6353 os
->sectype
= sectype
;
6354 if (sectype
!= noload_section
)
6355 os
->flags
= SEC_NO_FLAGS
;
6357 os
->flags
= SEC_NEVER_LOAD
;
6358 os
->block_value
= 1;
6360 /* Make next things chain into subchain of this. */
6361 push_stat_ptr (&os
->children
);
6363 os
->align_lma_with_input
= align_with_input
== ALIGN_WITH_INPUT
;
6364 if (os
->align_lma_with_input
&& align
!= NULL
)
6365 einfo (_("%F%P:%S: error: align with input and explicit align specified\n"), NULL
);
6367 os
->subsection_alignment
=
6368 topower (exp_get_value_int (subalign
, -1, "subsection alignment"));
6369 os
->section_alignment
=
6370 topower (exp_get_value_int (align
, -1, "section alignment"));
6372 os
->load_base
= ebase
;
6379 lang_output_statement_type
*new_stmt
;
6381 new_stmt
= new_stat (lang_output_statement
, stat_ptr
);
6382 new_stmt
->name
= output_filename
;
6385 /* Reset the current counters in the regions. */
6388 lang_reset_memory_regions (void)
6390 lang_memory_region_type
*p
= lang_memory_region_list
;
6392 lang_output_section_statement_type
*os
;
6394 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
6396 p
->current
= p
->origin
;
6400 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
6404 os
->processed_vma
= FALSE
;
6405 os
->processed_lma
= FALSE
;
6408 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6410 /* Save the last size for possible use by bfd_relax_section. */
6411 o
->rawsize
= o
->size
;
6416 /* Worker for lang_gc_sections_1. */
6419 gc_section_callback (lang_wild_statement_type
*ptr
,
6420 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
6422 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
6423 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
6424 void *data ATTRIBUTE_UNUSED
)
6426 /* If the wild pattern was marked KEEP, the member sections
6427 should be as well. */
6428 if (ptr
->keep_sections
)
6429 section
->flags
|= SEC_KEEP
;
6432 /* Iterate over sections marking them against GC. */
6435 lang_gc_sections_1 (lang_statement_union_type
*s
)
6437 for (; s
!= NULL
; s
= s
->header
.next
)
6439 switch (s
->header
.type
)
6441 case lang_wild_statement_enum
:
6442 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
6444 case lang_constructors_statement_enum
:
6445 lang_gc_sections_1 (constructor_list
.head
);
6447 case lang_output_section_statement_enum
:
6448 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
6450 case lang_group_statement_enum
:
6451 lang_gc_sections_1 (s
->group_statement
.children
.head
);
6460 lang_gc_sections (void)
6462 /* Keep all sections so marked in the link script. */
6464 lang_gc_sections_1 (statement_list
.head
);
6466 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
6467 the special case of debug info. (See bfd/stabs.c)
6468 Twiddle the flag here, to simplify later linker code. */
6469 if (bfd_link_relocatable (&link_info
))
6471 LANG_FOR_EACH_INPUT_STATEMENT (f
)
6474 #ifdef ENABLE_PLUGINS
6475 if (f
->flags
.claimed
)
6478 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6479 if ((sec
->flags
& SEC_DEBUGGING
) == 0)
6480 sec
->flags
&= ~SEC_EXCLUDE
;
6484 if (link_info
.gc_sections
)
6485 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
6488 /* Worker for lang_find_relro_sections_1. */
6491 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
6492 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
6494 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
6495 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
6498 /* Discarded, excluded and ignored sections effectively have zero
6500 if (section
->output_section
!= NULL
6501 && section
->output_section
->owner
== link_info
.output_bfd
6502 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
6503 && !IGNORE_SECTION (section
)
6504 && section
->size
!= 0)
6506 bfd_boolean
*has_relro_section
= (bfd_boolean
*) data
;
6507 *has_relro_section
= TRUE
;
6511 /* Iterate over sections for relro sections. */
6514 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
6515 bfd_boolean
*has_relro_section
)
6517 if (*has_relro_section
)
6520 for (; s
!= NULL
; s
= s
->header
.next
)
6522 if (s
== expld
.dataseg
.relro_end_stat
)
6525 switch (s
->header
.type
)
6527 case lang_wild_statement_enum
:
6528 walk_wild (&s
->wild_statement
,
6529 find_relro_section_callback
,
6532 case lang_constructors_statement_enum
:
6533 lang_find_relro_sections_1 (constructor_list
.head
,
6536 case lang_output_section_statement_enum
:
6537 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
6540 case lang_group_statement_enum
:
6541 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
6551 lang_find_relro_sections (void)
6553 bfd_boolean has_relro_section
= FALSE
;
6555 /* Check all sections in the link script. */
6557 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
6558 &has_relro_section
);
6560 if (!has_relro_section
)
6561 link_info
.relro
= FALSE
;
6564 /* Relax all sections until bfd_relax_section gives up. */
6567 lang_relax_sections (bfd_boolean need_layout
)
6569 if (RELAXATION_ENABLED
)
6571 /* We may need more than one relaxation pass. */
6572 int i
= link_info
.relax_pass
;
6574 /* The backend can use it to determine the current pass. */
6575 link_info
.relax_pass
= 0;
6579 /* Keep relaxing until bfd_relax_section gives up. */
6580 bfd_boolean relax_again
;
6582 link_info
.relax_trip
= -1;
6585 link_info
.relax_trip
++;
6587 /* Note: pe-dll.c does something like this also. If you find
6588 you need to change this code, you probably need to change
6589 pe-dll.c also. DJ */
6591 /* Do all the assignments with our current guesses as to
6593 lang_do_assignments (lang_assigning_phase_enum
);
6595 /* We must do this after lang_do_assignments, because it uses
6597 lang_reset_memory_regions ();
6599 /* Perform another relax pass - this time we know where the
6600 globals are, so can make a better guess. */
6601 relax_again
= FALSE
;
6602 lang_size_sections (&relax_again
, FALSE
);
6604 while (relax_again
);
6606 link_info
.relax_pass
++;
6613 /* Final extra sizing to report errors. */
6614 lang_do_assignments (lang_assigning_phase_enum
);
6615 lang_reset_memory_regions ();
6616 lang_size_sections (NULL
, TRUE
);
6620 #ifdef ENABLE_PLUGINS
6621 /* Find the insert point for the plugin's replacement files. We
6622 place them after the first claimed real object file, or if the
6623 first claimed object is an archive member, after the last real
6624 object file immediately preceding the archive. In the event
6625 no objects have been claimed at all, we return the first dummy
6626 object file on the list as the insert point; that works, but
6627 the callee must be careful when relinking the file_chain as it
6628 is not actually on that chain, only the statement_list and the
6629 input_file list; in that case, the replacement files must be
6630 inserted at the head of the file_chain. */
6632 static lang_input_statement_type
*
6633 find_replacements_insert_point (void)
6635 lang_input_statement_type
*claim1
, *lastobject
;
6636 lastobject
= &input_file_chain
.head
->input_statement
;
6637 for (claim1
= &file_chain
.head
->input_statement
;
6639 claim1
= &claim1
->next
->input_statement
)
6641 if (claim1
->flags
.claimed
)
6642 return claim1
->flags
.claim_archive
? lastobject
: claim1
;
6643 /* Update lastobject if this is a real object file. */
6644 if (claim1
->the_bfd
&& (claim1
->the_bfd
->my_archive
== NULL
))
6645 lastobject
= claim1
;
6647 /* No files were claimed by the plugin. Choose the last object
6648 file found on the list (maybe the first, dummy entry) as the
6653 /* Insert SRCLIST into DESTLIST after given element by chaining
6654 on FIELD as the next-pointer. (Counterintuitively does not need
6655 a pointer to the actual after-node itself, just its chain field.) */
6658 lang_list_insert_after (lang_statement_list_type
*destlist
,
6659 lang_statement_list_type
*srclist
,
6660 lang_statement_union_type
**field
)
6662 *(srclist
->tail
) = *field
;
6663 *field
= srclist
->head
;
6664 if (destlist
->tail
== field
)
6665 destlist
->tail
= srclist
->tail
;
6668 /* Detach new nodes added to DESTLIST since the time ORIGLIST
6669 was taken as a copy of it and leave them in ORIGLIST. */
6672 lang_list_remove_tail (lang_statement_list_type
*destlist
,
6673 lang_statement_list_type
*origlist
)
6675 union lang_statement_union
**savetail
;
6676 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
6677 ASSERT (origlist
->head
== destlist
->head
);
6678 savetail
= origlist
->tail
;
6679 origlist
->head
= *(savetail
);
6680 origlist
->tail
= destlist
->tail
;
6681 destlist
->tail
= savetail
;
6684 #endif /* ENABLE_PLUGINS */
6689 /* Finalize dynamic list. */
6690 if (link_info
.dynamic_list
)
6691 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
6693 current_target
= default_target
;
6695 /* Open the output file. */
6696 lang_for_each_statement (ldlang_open_output
);
6699 ldemul_create_output_section_statements ();
6701 /* Add to the hash table all undefineds on the command line. */
6702 lang_place_undefineds ();
6704 if (!bfd_section_already_linked_table_init ())
6705 einfo (_("%P%F: Failed to create hash table\n"));
6707 /* Create a bfd for each input file. */
6708 current_target
= default_target
;
6709 open_input_bfds (statement_list
.head
, OPEN_BFD_NORMAL
);
6711 #ifdef ENABLE_PLUGINS
6712 if (link_info
.lto_plugin_active
)
6714 lang_statement_list_type added
;
6715 lang_statement_list_type files
, inputfiles
;
6717 /* Now all files are read, let the plugin(s) decide if there
6718 are any more to be added to the link before we call the
6719 emulation's after_open hook. We create a private list of
6720 input statements for this purpose, which we will eventually
6721 insert into the global statment list after the first claimed
6724 /* We need to manipulate all three chains in synchrony. */
6726 inputfiles
= input_file_chain
;
6727 if (plugin_call_all_symbols_read ())
6728 einfo (_("%P%F: %s: plugin reported error after all symbols read\n"),
6729 plugin_error_plugin ());
6730 /* Open any newly added files, updating the file chains. */
6731 open_input_bfds (*added
.tail
, OPEN_BFD_NORMAL
);
6732 /* Restore the global list pointer now they have all been added. */
6733 lang_list_remove_tail (stat_ptr
, &added
);
6734 /* And detach the fresh ends of the file lists. */
6735 lang_list_remove_tail (&file_chain
, &files
);
6736 lang_list_remove_tail (&input_file_chain
, &inputfiles
);
6737 /* Were any new files added? */
6738 if (added
.head
!= NULL
)
6740 /* If so, we will insert them into the statement list immediately
6741 after the first input file that was claimed by the plugin. */
6742 plugin_insert
= find_replacements_insert_point ();
6743 /* If a plugin adds input files without having claimed any, we
6744 don't really have a good idea where to place them. Just putting
6745 them at the start or end of the list is liable to leave them
6746 outside the crtbegin...crtend range. */
6747 ASSERT (plugin_insert
!= NULL
);
6748 /* Splice the new statement list into the old one. */
6749 lang_list_insert_after (stat_ptr
, &added
,
6750 &plugin_insert
->header
.next
);
6751 /* Likewise for the file chains. */
6752 lang_list_insert_after (&input_file_chain
, &inputfiles
,
6753 &plugin_insert
->next_real_file
);
6754 /* We must be careful when relinking file_chain; we may need to
6755 insert the new files at the head of the list if the insert
6756 point chosen is the dummy first input file. */
6757 if (plugin_insert
->filename
)
6758 lang_list_insert_after (&file_chain
, &files
, &plugin_insert
->next
);
6760 lang_list_insert_after (&file_chain
, &files
, &file_chain
.head
);
6762 /* Rescan archives in case new undefined symbols have appeared. */
6763 open_input_bfds (statement_list
.head
, OPEN_BFD_RESCAN
);
6766 #endif /* ENABLE_PLUGINS */
6768 link_info
.gc_sym_list
= &entry_symbol
;
6769 if (entry_symbol
.name
== NULL
)
6770 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
6771 if (link_info
.init_function
!= NULL
)
6773 struct bfd_sym_chain
*sym
6774 = (struct bfd_sym_chain
*) stat_alloc (sizeof (*sym
));
6775 sym
->next
= link_info
.gc_sym_list
;
6776 sym
->name
= link_info
.init_function
;
6777 link_info
.gc_sym_list
= sym
;
6779 if (link_info
.fini_function
!= NULL
)
6781 struct bfd_sym_chain
*sym
6782 = (struct bfd_sym_chain
*) stat_alloc (sizeof (*sym
));
6783 sym
->next
= link_info
.gc_sym_list
;
6784 sym
->name
= link_info
.fini_function
;
6785 link_info
.gc_sym_list
= sym
;
6788 ldemul_after_open ();
6789 if (config
.map_file
!= NULL
)
6790 lang_print_asneeded ();
6792 bfd_section_already_linked_table_free ();
6794 /* Make sure that we're not mixing architectures. We call this
6795 after all the input files have been opened, but before we do any
6796 other processing, so that any operations merge_private_bfd_data
6797 does on the output file will be known during the rest of the
6801 /* Handle .exports instead of a version script if we're told to do so. */
6802 if (command_line
.version_exports_section
)
6803 lang_do_version_exports_section ();
6805 /* Build all sets based on the information gathered from the input
6807 ldctor_build_sets ();
6809 /* PR 13683: We must rerun the assignments prior to running garbage
6810 collection in order to make sure that all symbol aliases are resolved. */
6811 lang_do_assignments (lang_mark_phase_enum
);
6813 lang_do_memory_regions();
6814 expld
.phase
= lang_first_phase_enum
;
6816 /* Size up the common data. */
6819 /* Remove unreferenced sections if asked to. */
6820 lang_gc_sections ();
6822 /* Update wild statements. */
6823 update_wild_statements (statement_list
.head
);
6825 /* Run through the contours of the script and attach input sections
6826 to the correct output sections. */
6827 lang_statement_iteration
++;
6828 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
6830 process_insert_statements ();
6832 /* Find any sections not attached explicitly and handle them. */
6833 lang_place_orphans ();
6835 if (!bfd_link_relocatable (&link_info
))
6839 /* Merge SEC_MERGE sections. This has to be done after GC of
6840 sections, so that GCed sections are not merged, but before
6841 assigning dynamic symbols, since removing whole input sections
6843 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
6845 /* Look for a text section and set the readonly attribute in it. */
6846 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
6850 if (config
.text_read_only
)
6851 found
->flags
|= SEC_READONLY
;
6853 found
->flags
&= ~SEC_READONLY
;
6857 /* Do anything special before sizing sections. This is where ELF
6858 and other back-ends size dynamic sections. */
6859 ldemul_before_allocation ();
6861 /* We must record the program headers before we try to fix the
6862 section positions, since they will affect SIZEOF_HEADERS. */
6863 lang_record_phdrs ();
6865 /* Check relro sections. */
6866 if (link_info
.relro
&& !bfd_link_relocatable (&link_info
))
6867 lang_find_relro_sections ();
6869 /* Size up the sections. */
6870 lang_size_sections (NULL
, ! RELAXATION_ENABLED
);
6872 /* See if anything special should be done now we know how big
6873 everything is. This is where relaxation is done. */
6874 ldemul_after_allocation ();
6876 /* Fix any .startof. or .sizeof. symbols. */
6877 lang_set_startof ();
6879 /* Do all the assignments, now that we know the final resting places
6880 of all the symbols. */
6881 lang_do_assignments (lang_final_phase_enum
);
6885 /* Convert absolute symbols to section relative. */
6886 ldexp_finalize_syms ();
6888 /* Make sure that the section addresses make sense. */
6889 if (command_line
.check_section_addresses
)
6890 lang_check_section_addresses ();
6892 /* Check any required symbols are known. */
6893 ldlang_check_require_defined_symbols ();
6898 /* EXPORTED TO YACC */
6901 lang_add_wild (struct wildcard_spec
*filespec
,
6902 struct wildcard_list
*section_list
,
6903 bfd_boolean keep_sections
)
6905 struct wildcard_list
*curr
, *next
;
6906 lang_wild_statement_type
*new_stmt
;
6908 /* Reverse the list as the parser puts it back to front. */
6909 for (curr
= section_list
, section_list
= NULL
;
6911 section_list
= curr
, curr
= next
)
6913 if (curr
->spec
.name
!= NULL
&& strcmp (curr
->spec
.name
, "COMMON") == 0)
6914 placed_commons
= TRUE
;
6917 curr
->next
= section_list
;
6920 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
6922 if (strcmp (filespec
->name
, "*") == 0)
6923 filespec
->name
= NULL
;
6924 else if (! wildcardp (filespec
->name
))
6925 lang_has_input_file
= TRUE
;
6928 new_stmt
= new_stat (lang_wild_statement
, stat_ptr
);
6929 new_stmt
->filename
= NULL
;
6930 new_stmt
->filenames_sorted
= FALSE
;
6931 new_stmt
->section_flag_list
= NULL
;
6932 if (filespec
!= NULL
)
6934 new_stmt
->filename
= filespec
->name
;
6935 new_stmt
->filenames_sorted
= filespec
->sorted
== by_name
;
6936 new_stmt
->section_flag_list
= filespec
->section_flag_list
;
6938 new_stmt
->section_list
= section_list
;
6939 new_stmt
->keep_sections
= keep_sections
;
6940 lang_list_init (&new_stmt
->children
);
6941 analyze_walk_wild_section_handler (new_stmt
);
6945 lang_section_start (const char *name
, etree_type
*address
,
6946 const segment_type
*segment
)
6948 lang_address_statement_type
*ad
;
6950 ad
= new_stat (lang_address_statement
, stat_ptr
);
6951 ad
->section_name
= name
;
6952 ad
->address
= address
;
6953 ad
->segment
= segment
;
6956 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
6957 because of a -e argument on the command line, or zero if this is
6958 called by ENTRY in a linker script. Command line arguments take
6962 lang_add_entry (const char *name
, bfd_boolean cmdline
)
6964 if (entry_symbol
.name
== NULL
6966 || ! entry_from_cmdline
)
6968 entry_symbol
.name
= name
;
6969 entry_from_cmdline
= cmdline
;
6973 /* Set the default start symbol to NAME. .em files should use this,
6974 not lang_add_entry, to override the use of "start" if neither the
6975 linker script nor the command line specifies an entry point. NAME
6976 must be permanently allocated. */
6978 lang_default_entry (const char *name
)
6980 entry_symbol_default
= name
;
6984 lang_add_target (const char *name
)
6986 lang_target_statement_type
*new_stmt
;
6988 new_stmt
= new_stat (lang_target_statement
, stat_ptr
);
6989 new_stmt
->target
= name
;
6993 lang_add_map (const char *name
)
7000 map_option_f
= TRUE
;
7008 lang_add_fill (fill_type
*fill
)
7010 lang_fill_statement_type
*new_stmt
;
7012 new_stmt
= new_stat (lang_fill_statement
, stat_ptr
);
7013 new_stmt
->fill
= fill
;
7017 lang_add_data (int type
, union etree_union
*exp
)
7019 lang_data_statement_type
*new_stmt
;
7021 new_stmt
= new_stat (lang_data_statement
, stat_ptr
);
7022 new_stmt
->exp
= exp
;
7023 new_stmt
->type
= type
;
7026 /* Create a new reloc statement. RELOC is the BFD relocation type to
7027 generate. HOWTO is the corresponding howto structure (we could
7028 look this up, but the caller has already done so). SECTION is the
7029 section to generate a reloc against, or NAME is the name of the
7030 symbol to generate a reloc against. Exactly one of SECTION and
7031 NAME must be NULL. ADDEND is an expression for the addend. */
7034 lang_add_reloc (bfd_reloc_code_real_type reloc
,
7035 reloc_howto_type
*howto
,
7038 union etree_union
*addend
)
7040 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
7044 p
->section
= section
;
7046 p
->addend_exp
= addend
;
7048 p
->addend_value
= 0;
7049 p
->output_section
= NULL
;
7050 p
->output_offset
= 0;
7053 lang_assignment_statement_type
*
7054 lang_add_assignment (etree_type
*exp
)
7056 lang_assignment_statement_type
*new_stmt
;
7058 new_stmt
= new_stat (lang_assignment_statement
, stat_ptr
);
7059 new_stmt
->exp
= exp
;
7064 lang_add_attribute (enum statement_enum attribute
)
7066 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
7070 lang_startup (const char *name
)
7072 if (first_file
->filename
!= NULL
)
7074 einfo (_("%P%F: multiple STARTUP files\n"));
7076 first_file
->filename
= name
;
7077 first_file
->local_sym_name
= name
;
7078 first_file
->flags
.real
= TRUE
;
7082 lang_float (bfd_boolean maybe
)
7084 lang_float_flag
= maybe
;
7088 /* Work out the load- and run-time regions from a script statement, and
7089 store them in *LMA_REGION and *REGION respectively.
7091 MEMSPEC is the name of the run-time region, or the value of
7092 DEFAULT_MEMORY_REGION if the statement didn't specify one.
7093 LMA_MEMSPEC is the name of the load-time region, or null if the
7094 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
7095 had an explicit load address.
7097 It is an error to specify both a load region and a load address. */
7100 lang_get_regions (lang_memory_region_type
**region
,
7101 lang_memory_region_type
**lma_region
,
7102 const char *memspec
,
7103 const char *lma_memspec
,
7104 bfd_boolean have_lma
,
7105 bfd_boolean have_vma
)
7107 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
7109 /* If no runtime region or VMA has been specified, but the load region
7110 has been specified, then use the load region for the runtime region
7112 if (lma_memspec
!= NULL
7114 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
7115 *region
= *lma_region
;
7117 *region
= lang_memory_region_lookup (memspec
, FALSE
);
7119 if (have_lma
&& lma_memspec
!= 0)
7120 einfo (_("%X%P:%S: section has both a load address and a load region\n"),
7125 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
7126 lang_output_section_phdr_list
*phdrs
,
7127 const char *lma_memspec
)
7129 lang_get_regions (¤t_section
->region
,
7130 ¤t_section
->lma_region
,
7131 memspec
, lma_memspec
,
7132 current_section
->load_base
!= NULL
,
7133 current_section
->addr_tree
!= NULL
);
7135 /* If this section has no load region or base, but uses the same
7136 region as the previous section, then propagate the previous
7137 section's load region. */
7139 if (current_section
->lma_region
== NULL
7140 && current_section
->load_base
== NULL
7141 && current_section
->addr_tree
== NULL
7142 && current_section
->region
== current_section
->prev
->region
)
7143 current_section
->lma_region
= current_section
->prev
->lma_region
;
7145 current_section
->fill
= fill
;
7146 current_section
->phdrs
= phdrs
;
7151 lang_statement_append (lang_statement_list_type
*list
,
7152 lang_statement_union_type
*element
,
7153 lang_statement_union_type
**field
)
7155 *(list
->tail
) = element
;
7159 /* Set the output format type. -oformat overrides scripts. */
7162 lang_add_output_format (const char *format
,
7167 if (output_target
== NULL
|| !from_script
)
7169 if (command_line
.endian
== ENDIAN_BIG
7172 else if (command_line
.endian
== ENDIAN_LITTLE
7176 output_target
= format
;
7181 lang_add_insert (const char *where
, int is_before
)
7183 lang_insert_statement_type
*new_stmt
;
7185 new_stmt
= new_stat (lang_insert_statement
, stat_ptr
);
7186 new_stmt
->where
= where
;
7187 new_stmt
->is_before
= is_before
;
7188 saved_script_handle
= previous_script_handle
;
7191 /* Enter a group. This creates a new lang_group_statement, and sets
7192 stat_ptr to build new statements within the group. */
7195 lang_enter_group (void)
7197 lang_group_statement_type
*g
;
7199 g
= new_stat (lang_group_statement
, stat_ptr
);
7200 lang_list_init (&g
->children
);
7201 push_stat_ptr (&g
->children
);
7204 /* Leave a group. This just resets stat_ptr to start writing to the
7205 regular list of statements again. Note that this will not work if
7206 groups can occur inside anything else which can adjust stat_ptr,
7207 but currently they can't. */
7210 lang_leave_group (void)
7215 /* Add a new program header. This is called for each entry in a PHDRS
7216 command in a linker script. */
7219 lang_new_phdr (const char *name
,
7221 bfd_boolean filehdr
,
7226 struct lang_phdr
*n
, **pp
;
7229 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
7232 n
->type
= exp_get_value_int (type
, 0, "program header type");
7233 n
->filehdr
= filehdr
;
7238 hdrs
= n
->type
== 1 && (phdrs
|| filehdr
);
7240 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
7243 && !((*pp
)->filehdr
|| (*pp
)->phdrs
))
7245 einfo (_("%X%P:%S: PHDRS and FILEHDR are not supported"
7246 " when prior PT_LOAD headers lack them\n"), NULL
);
7253 /* Record the program header information in the output BFD. FIXME: We
7254 should not be calling an ELF specific function here. */
7257 lang_record_phdrs (void)
7261 lang_output_section_phdr_list
*last
;
7262 struct lang_phdr
*l
;
7263 lang_output_section_statement_type
*os
;
7266 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
7269 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
7276 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
7280 lang_output_section_phdr_list
*pl
;
7282 if (os
->constraint
< 0)
7290 if (os
->sectype
== noload_section
7291 || os
->bfd_section
== NULL
7292 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
7295 /* Don't add orphans to PT_INTERP header. */
7301 lang_output_section_statement_type
* tmp_os
;
7303 /* If we have not run across a section with a program
7304 header assigned to it yet, then scan forwards to find
7305 one. This prevents inconsistencies in the linker's
7306 behaviour when a script has specified just a single
7307 header and there are sections in that script which are
7308 not assigned to it, and which occur before the first
7309 use of that header. See here for more details:
7310 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
7311 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
7314 last
= tmp_os
->phdrs
;
7318 einfo (_("%F%P: no sections assigned to phdrs\n"));
7323 if (os
->bfd_section
== NULL
)
7326 for (; pl
!= NULL
; pl
= pl
->next
)
7328 if (strcmp (pl
->name
, l
->name
) == 0)
7333 secs
= (asection
**) xrealloc (secs
,
7334 alc
* sizeof (asection
*));
7336 secs
[c
] = os
->bfd_section
;
7343 if (l
->flags
== NULL
)
7346 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
7351 at
= exp_get_vma (l
->at
, 0, "phdr load address");
7353 if (! bfd_record_phdr (link_info
.output_bfd
, l
->type
,
7354 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
7355 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
7356 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
7361 /* Make sure all the phdr assignments succeeded. */
7362 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
7366 lang_output_section_phdr_list
*pl
;
7368 if (os
->constraint
< 0
7369 || os
->bfd_section
== NULL
)
7372 for (pl
= os
->phdrs
;
7375 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
7376 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
7377 os
->name
, pl
->name
);
7381 /* Record a list of sections which may not be cross referenced. */
7384 lang_add_nocrossref (lang_nocrossref_type
*l
)
7386 struct lang_nocrossrefs
*n
;
7388 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
7389 n
->next
= nocrossref_list
;
7391 nocrossref_list
= n
;
7393 /* Set notice_all so that we get informed about all symbols. */
7394 link_info
.notice_all
= TRUE
;
7397 /* Overlay handling. We handle overlays with some static variables. */
7399 /* The overlay virtual address. */
7400 static etree_type
*overlay_vma
;
7401 /* And subsection alignment. */
7402 static etree_type
*overlay_subalign
;
7404 /* An expression for the maximum section size seen so far. */
7405 static etree_type
*overlay_max
;
7407 /* A list of all the sections in this overlay. */
7409 struct overlay_list
{
7410 struct overlay_list
*next
;
7411 lang_output_section_statement_type
*os
;
7414 static struct overlay_list
*overlay_list
;
7416 /* Start handling an overlay. */
7419 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
7421 /* The grammar should prevent nested overlays from occurring. */
7422 ASSERT (overlay_vma
== NULL
7423 && overlay_subalign
== NULL
7424 && overlay_max
== NULL
);
7426 overlay_vma
= vma_expr
;
7427 overlay_subalign
= subalign
;
7430 /* Start a section in an overlay. We handle this by calling
7431 lang_enter_output_section_statement with the correct VMA.
7432 lang_leave_overlay sets up the LMA and memory regions. */
7435 lang_enter_overlay_section (const char *name
)
7437 struct overlay_list
*n
;
7440 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
7441 0, overlay_subalign
, 0, 0, 0);
7443 /* If this is the first section, then base the VMA of future
7444 sections on this one. This will work correctly even if `.' is
7445 used in the addresses. */
7446 if (overlay_list
== NULL
)
7447 overlay_vma
= exp_nameop (ADDR
, name
);
7449 /* Remember the section. */
7450 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
7451 n
->os
= current_section
;
7452 n
->next
= overlay_list
;
7455 size
= exp_nameop (SIZEOF
, name
);
7457 /* Arrange to work out the maximum section end address. */
7458 if (overlay_max
== NULL
)
7461 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
7464 /* Finish a section in an overlay. There isn't any special to do
7468 lang_leave_overlay_section (fill_type
*fill
,
7469 lang_output_section_phdr_list
*phdrs
)
7476 name
= current_section
->name
;
7478 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
7479 region and that no load-time region has been specified. It doesn't
7480 really matter what we say here, since lang_leave_overlay will
7482 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
7484 /* Define the magic symbols. */
7486 clean
= (char *) xmalloc (strlen (name
) + 1);
7488 for (s1
= name
; *s1
!= '\0'; s1
++)
7489 if (ISALNUM (*s1
) || *s1
== '_')
7493 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_start_");
7494 sprintf (buf
, "__load_start_%s", clean
);
7495 lang_add_assignment (exp_provide (buf
,
7496 exp_nameop (LOADADDR
, name
),
7499 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_stop_");
7500 sprintf (buf
, "__load_stop_%s", clean
);
7501 lang_add_assignment (exp_provide (buf
,
7503 exp_nameop (LOADADDR
, name
),
7504 exp_nameop (SIZEOF
, name
)),
7510 /* Finish an overlay. If there are any overlay wide settings, this
7511 looks through all the sections in the overlay and sets them. */
7514 lang_leave_overlay (etree_type
*lma_expr
,
7517 const char *memspec
,
7518 lang_output_section_phdr_list
*phdrs
,
7519 const char *lma_memspec
)
7521 lang_memory_region_type
*region
;
7522 lang_memory_region_type
*lma_region
;
7523 struct overlay_list
*l
;
7524 lang_nocrossref_type
*nocrossref
;
7526 lang_get_regions (®ion
, &lma_region
,
7527 memspec
, lma_memspec
,
7528 lma_expr
!= NULL
, FALSE
);
7532 /* After setting the size of the last section, set '.' to end of the
7534 if (overlay_list
!= NULL
)
7536 overlay_list
->os
->update_dot
= 1;
7537 overlay_list
->os
->update_dot_tree
7538 = exp_assign (".", exp_binop ('+', overlay_vma
, overlay_max
), FALSE
);
7544 struct overlay_list
*next
;
7546 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
7549 l
->os
->region
= region
;
7550 l
->os
->lma_region
= lma_region
;
7552 /* The first section has the load address specified in the
7553 OVERLAY statement. The rest are worked out from that.
7554 The base address is not needed (and should be null) if
7555 an LMA region was specified. */
7558 l
->os
->load_base
= lma_expr
;
7559 l
->os
->sectype
= normal_section
;
7561 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
7562 l
->os
->phdrs
= phdrs
;
7566 lang_nocrossref_type
*nc
;
7568 nc
= (lang_nocrossref_type
*) xmalloc (sizeof *nc
);
7569 nc
->name
= l
->os
->name
;
7570 nc
->next
= nocrossref
;
7579 if (nocrossref
!= NULL
)
7580 lang_add_nocrossref (nocrossref
);
7583 overlay_list
= NULL
;
7587 /* Version handling. This is only useful for ELF. */
7589 /* If PREV is NULL, return first version pattern matching particular symbol.
7590 If PREV is non-NULL, return first version pattern matching particular
7591 symbol after PREV (previously returned by lang_vers_match). */
7593 static struct bfd_elf_version_expr
*
7594 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
7595 struct bfd_elf_version_expr
*prev
,
7599 const char *cxx_sym
= sym
;
7600 const char *java_sym
= sym
;
7601 struct bfd_elf_version_expr
*expr
= NULL
;
7602 enum demangling_styles curr_style
;
7604 curr_style
= CURRENT_DEMANGLING_STYLE
;
7605 cplus_demangle_set_style (no_demangling
);
7606 c_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_NO_OPTS
);
7609 cplus_demangle_set_style (curr_style
);
7611 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
7613 cxx_sym
= bfd_demangle (link_info
.output_bfd
, sym
,
7614 DMGL_PARAMS
| DMGL_ANSI
);
7618 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
7620 java_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_JAVA
);
7625 if (head
->htab
&& (prev
== NULL
|| prev
->literal
))
7627 struct bfd_elf_version_expr e
;
7629 switch (prev
? prev
->mask
: 0)
7632 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
7635 expr
= (struct bfd_elf_version_expr
*)
7636 htab_find ((htab_t
) head
->htab
, &e
);
7637 while (expr
&& strcmp (expr
->pattern
, c_sym
) == 0)
7638 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
7644 case BFD_ELF_VERSION_C_TYPE
:
7645 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
7647 e
.pattern
= cxx_sym
;
7648 expr
= (struct bfd_elf_version_expr
*)
7649 htab_find ((htab_t
) head
->htab
, &e
);
7650 while (expr
&& strcmp (expr
->pattern
, cxx_sym
) == 0)
7651 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
7657 case BFD_ELF_VERSION_CXX_TYPE
:
7658 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
7660 e
.pattern
= java_sym
;
7661 expr
= (struct bfd_elf_version_expr
*)
7662 htab_find ((htab_t
) head
->htab
, &e
);
7663 while (expr
&& strcmp (expr
->pattern
, java_sym
) == 0)
7664 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
7675 /* Finally, try the wildcards. */
7676 if (prev
== NULL
|| prev
->literal
)
7677 expr
= head
->remaining
;
7680 for (; expr
; expr
= expr
->next
)
7687 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
7690 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
7692 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
7696 if (fnmatch (expr
->pattern
, s
, 0) == 0)
7702 free ((char *) c_sym
);
7704 free ((char *) cxx_sym
);
7705 if (java_sym
!= sym
)
7706 free ((char *) java_sym
);
7710 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
7711 return a pointer to the symbol name with any backslash quotes removed. */
7714 realsymbol (const char *pattern
)
7717 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
7718 char *s
, *symbol
= (char *) xmalloc (strlen (pattern
) + 1);
7720 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
7722 /* It is a glob pattern only if there is no preceding
7726 /* Remove the preceding backslash. */
7733 if (*p
== '?' || *p
== '*' || *p
== '[')
7740 backslash
= *p
== '\\';
7756 /* This is called for each variable name or match expression. NEW_NAME is
7757 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
7758 pattern to be matched against symbol names. */
7760 struct bfd_elf_version_expr
*
7761 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
7762 const char *new_name
,
7764 bfd_boolean literal_p
)
7766 struct bfd_elf_version_expr
*ret
;
7768 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
7772 ret
->literal
= TRUE
;
7773 ret
->pattern
= literal_p
? new_name
: realsymbol (new_name
);
7774 if (ret
->pattern
== NULL
)
7776 ret
->pattern
= new_name
;
7777 ret
->literal
= FALSE
;
7780 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
7781 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
7782 else if (strcasecmp (lang
, "C++") == 0)
7783 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
7784 else if (strcasecmp (lang
, "Java") == 0)
7785 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
7788 einfo (_("%X%P: unknown language `%s' in version information\n"),
7790 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
7793 return ldemul_new_vers_pattern (ret
);
7796 /* This is called for each set of variable names and match
7799 struct bfd_elf_version_tree
*
7800 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
7801 struct bfd_elf_version_expr
*locals
)
7803 struct bfd_elf_version_tree
*ret
;
7805 ret
= (struct bfd_elf_version_tree
*) xcalloc (1, sizeof *ret
);
7806 ret
->globals
.list
= globals
;
7807 ret
->locals
.list
= locals
;
7808 ret
->match
= lang_vers_match
;
7809 ret
->name_indx
= (unsigned int) -1;
7813 /* This static variable keeps track of version indices. */
7815 static int version_index
;
7818 version_expr_head_hash (const void *p
)
7820 const struct bfd_elf_version_expr
*e
=
7821 (const struct bfd_elf_version_expr
*) p
;
7823 return htab_hash_string (e
->pattern
);
7827 version_expr_head_eq (const void *p1
, const void *p2
)
7829 const struct bfd_elf_version_expr
*e1
=
7830 (const struct bfd_elf_version_expr
*) p1
;
7831 const struct bfd_elf_version_expr
*e2
=
7832 (const struct bfd_elf_version_expr
*) p2
;
7834 return strcmp (e1
->pattern
, e2
->pattern
) == 0;
7838 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
7841 struct bfd_elf_version_expr
*e
, *next
;
7842 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
7844 for (e
= head
->list
; e
; e
= e
->next
)
7848 head
->mask
|= e
->mask
;
7853 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
7854 version_expr_head_eq
, NULL
);
7855 list_loc
= &head
->list
;
7856 remaining_loc
= &head
->remaining
;
7857 for (e
= head
->list
; e
; e
= next
)
7863 remaining_loc
= &e
->next
;
7867 void **loc
= htab_find_slot ((htab_t
) head
->htab
, e
, INSERT
);
7871 struct bfd_elf_version_expr
*e1
, *last
;
7873 e1
= (struct bfd_elf_version_expr
*) *loc
;
7877 if (e1
->mask
== e
->mask
)
7885 while (e1
&& strcmp (e1
->pattern
, e
->pattern
) == 0);
7889 /* This is a duplicate. */
7890 /* FIXME: Memory leak. Sometimes pattern is not
7891 xmalloced alone, but in larger chunk of memory. */
7892 /* free (e->pattern); */
7897 e
->next
= last
->next
;
7905 list_loc
= &e
->next
;
7909 *remaining_loc
= NULL
;
7910 *list_loc
= head
->remaining
;
7913 head
->remaining
= head
->list
;
7916 /* This is called when we know the name and dependencies of the
7920 lang_register_vers_node (const char *name
,
7921 struct bfd_elf_version_tree
*version
,
7922 struct bfd_elf_version_deps
*deps
)
7924 struct bfd_elf_version_tree
*t
, **pp
;
7925 struct bfd_elf_version_expr
*e1
;
7930 if (link_info
.version_info
!= NULL
7931 && (name
[0] == '\0' || link_info
.version_info
->name
[0] == '\0'))
7933 einfo (_("%X%P: anonymous version tag cannot be combined"
7934 " with other version tags\n"));
7939 /* Make sure this node has a unique name. */
7940 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
7941 if (strcmp (t
->name
, name
) == 0)
7942 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
7944 lang_finalize_version_expr_head (&version
->globals
);
7945 lang_finalize_version_expr_head (&version
->locals
);
7947 /* Check the global and local match names, and make sure there
7948 aren't any duplicates. */
7950 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
7952 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
7954 struct bfd_elf_version_expr
*e2
;
7956 if (t
->locals
.htab
&& e1
->literal
)
7958 e2
= (struct bfd_elf_version_expr
*)
7959 htab_find ((htab_t
) t
->locals
.htab
, e1
);
7960 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
7962 if (e1
->mask
== e2
->mask
)
7963 einfo (_("%X%P: duplicate expression `%s'"
7964 " in version information\n"), e1
->pattern
);
7968 else if (!e1
->literal
)
7969 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
7970 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
7971 && e1
->mask
== e2
->mask
)
7972 einfo (_("%X%P: duplicate expression `%s'"
7973 " in version information\n"), e1
->pattern
);
7977 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
7979 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
7981 struct bfd_elf_version_expr
*e2
;
7983 if (t
->globals
.htab
&& e1
->literal
)
7985 e2
= (struct bfd_elf_version_expr
*)
7986 htab_find ((htab_t
) t
->globals
.htab
, e1
);
7987 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
7989 if (e1
->mask
== e2
->mask
)
7990 einfo (_("%X%P: duplicate expression `%s'"
7991 " in version information\n"),
7996 else if (!e1
->literal
)
7997 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
7998 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
7999 && e1
->mask
== e2
->mask
)
8000 einfo (_("%X%P: duplicate expression `%s'"
8001 " in version information\n"), e1
->pattern
);
8005 version
->deps
= deps
;
8006 version
->name
= name
;
8007 if (name
[0] != '\0')
8010 version
->vernum
= version_index
;
8013 version
->vernum
= 0;
8015 for (pp
= &link_info
.version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
8020 /* This is called when we see a version dependency. */
8022 struct bfd_elf_version_deps
*
8023 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
8025 struct bfd_elf_version_deps
*ret
;
8026 struct bfd_elf_version_tree
*t
;
8028 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
8031 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8033 if (strcmp (t
->name
, name
) == 0)
8035 ret
->version_needed
= t
;
8040 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
8042 ret
->version_needed
= NULL
;
8047 lang_do_version_exports_section (void)
8049 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
8051 LANG_FOR_EACH_INPUT_STATEMENT (is
)
8053 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
8061 contents
= (char *) xmalloc (len
);
8062 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
8063 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
8066 while (p
< contents
+ len
)
8068 greg
= lang_new_vers_pattern (greg
, p
, NULL
, FALSE
);
8069 p
= strchr (p
, '\0') + 1;
8072 /* Do not free the contents, as we used them creating the regex. */
8074 /* Do not include this section in the link. */
8075 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
8078 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, FALSE
);
8079 lang_register_vers_node (command_line
.version_exports_section
,
8080 lang_new_vers_node (greg
, lreg
), NULL
);
8083 /* Evaluate LENGTH and ORIGIN parts of MEMORY spec */
8086 lang_do_memory_regions (void)
8088 lang_memory_region_type
*r
= lang_memory_region_list
;
8090 for (; r
!= NULL
; r
= r
->next
)
8094 exp_fold_tree_no_dot (r
->origin_exp
);
8095 if (expld
.result
.valid_p
)
8097 r
->origin
= expld
.result
.value
;
8098 r
->current
= r
->origin
;
8101 einfo (_("%F%P: invalid origin for memory region %s\n"), r
->name_list
.name
);
8105 exp_fold_tree_no_dot (r
->length_exp
);
8106 if (expld
.result
.valid_p
)
8107 r
->length
= expld
.result
.value
;
8109 einfo (_("%F%P: invalid length for memory region %s\n"), r
->name_list
.name
);
8115 lang_add_unique (const char *name
)
8117 struct unique_sections
*ent
;
8119 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
8120 if (strcmp (ent
->name
, name
) == 0)
8123 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
8124 ent
->name
= xstrdup (name
);
8125 ent
->next
= unique_section_list
;
8126 unique_section_list
= ent
;
8129 /* Append the list of dynamic symbols to the existing one. */
8132 lang_append_dynamic_list (struct bfd_elf_version_expr
*dynamic
)
8134 if (link_info
.dynamic_list
)
8136 struct bfd_elf_version_expr
*tail
;
8137 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
8139 tail
->next
= link_info
.dynamic_list
->head
.list
;
8140 link_info
.dynamic_list
->head
.list
= dynamic
;
8144 struct bfd_elf_dynamic_list
*d
;
8146 d
= (struct bfd_elf_dynamic_list
*) xcalloc (1, sizeof *d
);
8147 d
->head
.list
= dynamic
;
8148 d
->match
= lang_vers_match
;
8149 link_info
.dynamic_list
= d
;
8153 /* Append the list of C++ typeinfo dynamic symbols to the existing
8157 lang_append_dynamic_list_cpp_typeinfo (void)
8159 const char * symbols
[] =
8161 "typeinfo name for*",
8164 struct bfd_elf_version_expr
*dynamic
= NULL
;
8167 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
8168 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
8171 lang_append_dynamic_list (dynamic
);
8174 /* Append the list of C++ operator new and delete dynamic symbols to the
8178 lang_append_dynamic_list_cpp_new (void)
8180 const char * symbols
[] =
8185 struct bfd_elf_version_expr
*dynamic
= NULL
;
8188 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
8189 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
8192 lang_append_dynamic_list (dynamic
);
8195 /* Scan a space and/or comma separated string of features. */
8198 lang_ld_feature (char *str
)
8206 while (*p
== ',' || ISSPACE (*p
))
8211 while (*q
&& *q
!= ',' && !ISSPACE (*q
))
8215 if (strcasecmp (p
, "SANE_EXPR") == 0)
8216 config
.sane_expr
= TRUE
;
8218 einfo (_("%X%P: unknown feature `%s'\n"), p
);
8224 /* Pretty print memory amount. */
8227 lang_print_memory_size (bfd_vma sz
)
8229 if ((sz
& 0x3fffffff) == 0)
8230 printf ("%10" BFD_VMA_FMT
"u GB", sz
>> 30);
8231 else if ((sz
& 0xfffff) == 0)
8232 printf ("%10" BFD_VMA_FMT
"u MB", sz
>> 20);
8233 else if ((sz
& 0x3ff) == 0)
8234 printf ("%10" BFD_VMA_FMT
"u KB", sz
>> 10);
8236 printf (" %10" BFD_VMA_FMT
"u B", sz
);
8239 /* Implement --print-memory-usage: disply per region memory usage. */
8242 lang_print_memory_usage (void)
8244 lang_memory_region_type
*r
;
8246 printf ("Memory region Used Size Region Size %%age Used\n");
8247 for (r
= lang_memory_region_list
; r
->next
!= NULL
; r
= r
->next
)
8249 bfd_vma used_length
= r
->current
- r
->origin
;
8252 printf ("%16s: ",r
->name_list
.name
);
8253 lang_print_memory_size (used_length
);
8254 lang_print_memory_size ((bfd_vma
) r
->length
);
8256 percent
= used_length
* 100.0 / r
->length
;
8258 printf (" %6.2f%%\n", percent
);