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
,
1503 lang_output_section_statement_type
**exact
,
1504 lang_match_sec_type_func match_type
)
1506 lang_output_section_statement_type
*first
, *look
, *found
;
1507 flagword look_flags
, differ
;
1509 /* We know the first statement on this list is *ABS*. May as well
1511 first
= &lang_output_section_statement
.head
->output_section_statement
;
1512 first
= first
->next
;
1514 /* First try for an exact match. */
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
, sec_flags
, 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_assignment_statement_type
*start_assign
;
1809 lang_output_section_statement_type
*os
;
1810 lang_output_section_statement_type
**os_tail
;
1812 /* If we have found an appropriate place for the output section
1813 statements for this orphan, add them to our own private list,
1814 inserting them later into the global statement list. */
1817 lang_list_init (&add
);
1818 push_stat_ptr (&add
);
1821 if (bfd_link_relocatable (&link_info
)
1822 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
1823 address
= exp_intop (0);
1825 os_tail
= ((lang_output_section_statement_type
**)
1826 lang_output_section_statement
.tail
);
1827 os
= lang_enter_output_section_statement (secname
, address
, normal_section
,
1828 NULL
, NULL
, NULL
, constraint
, 0);
1831 start_assign
= NULL
;
1832 if (config
.build_constructors
&& *os_tail
== os
)
1834 /* If the name of the section is representable in C, then create
1835 symbols to mark the start and the end of the section. */
1836 for (ps
= secname
; *ps
!= '\0'; ps
++)
1837 if (! ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
1843 symname
= (char *) xmalloc (ps
- secname
+ sizeof "__start_" + 1);
1844 symname
[0] = bfd_get_symbol_leading_char (link_info
.output_bfd
);
1845 sprintf (symname
+ (symname
[0] != 0), "__start_%s", secname
);
1847 = lang_add_assignment (exp_provide (symname
,
1848 exp_nameop (NAME
, "."),
1853 if (add_child
== NULL
)
1854 add_child
= &os
->children
;
1855 lang_add_section (add_child
, s
, NULL
, os
);
1857 if (after
&& (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) != 0)
1859 const char *region
= (after
->region
1860 ? after
->region
->name_list
.name
1861 : DEFAULT_MEMORY_REGION
);
1862 const char *lma_region
= (after
->lma_region
1863 ? after
->lma_region
->name_list
.name
1865 lang_leave_output_section_statement (NULL
, region
, after
->phdrs
,
1869 lang_leave_output_section_statement (NULL
, DEFAULT_MEMORY_REGION
, NULL
,
1872 if (start_assign
!= NULL
)
1875 lang_assignment_statement_type
*stop_assign
;
1878 symname
= (char *) xmalloc (ps
- secname
+ sizeof "__stop_" + 1);
1879 symname
[0] = bfd_get_symbol_leading_char (link_info
.output_bfd
);
1880 sprintf (symname
+ (symname
[0] != 0), "__stop_%s", secname
);
1882 = lang_add_assignment (exp_provide (symname
,
1883 exp_nameop (NAME
, "."),
1885 /* Evaluate the expression to define the symbol if referenced,
1886 before sizing dynamic sections. */
1887 dot
= os
->bfd_section
->vma
;
1888 exp_fold_tree (start_assign
->exp
, os
->bfd_section
, &dot
);
1890 exp_fold_tree (stop_assign
->exp
, os
->bfd_section
, &dot
);
1893 /* Restore the global list pointer. */
1897 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
1899 asection
*snew
, *as
;
1901 snew
= os
->bfd_section
;
1903 /* Shuffle the bfd section list to make the output file look
1904 neater. This is really only cosmetic. */
1905 if (place
->section
== NULL
1906 && after
!= (&lang_output_section_statement
.head
1907 ->output_section_statement
))
1909 asection
*bfd_section
= after
->bfd_section
;
1911 /* If the output statement hasn't been used to place any input
1912 sections (and thus doesn't have an output bfd_section),
1913 look for the closest prior output statement having an
1915 if (bfd_section
== NULL
)
1916 bfd_section
= output_prev_sec_find (after
);
1918 if (bfd_section
!= NULL
&& bfd_section
!= snew
)
1919 place
->section
= &bfd_section
->next
;
1922 if (place
->section
== NULL
)
1923 place
->section
= &link_info
.output_bfd
->sections
;
1925 as
= *place
->section
;
1929 /* Put the section at the end of the list. */
1931 /* Unlink the section. */
1932 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1934 /* Now tack it back on in the right place. */
1935 bfd_section_list_append (link_info
.output_bfd
, snew
);
1937 else if (as
!= snew
&& as
->prev
!= snew
)
1939 /* Unlink the section. */
1940 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1942 /* Now tack it back on in the right place. */
1943 bfd_section_list_insert_before (link_info
.output_bfd
, as
, snew
);
1946 /* Save the end of this list. Further ophans of this type will
1947 follow the one we've just added. */
1948 place
->section
= &snew
->next
;
1950 /* The following is non-cosmetic. We try to put the output
1951 statements in some sort of reasonable order here, because they
1952 determine the final load addresses of the orphan sections.
1953 In addition, placing output statements in the wrong order may
1954 require extra segments. For instance, given a typical
1955 situation of all read-only sections placed in one segment and
1956 following that a segment containing all the read-write
1957 sections, we wouldn't want to place an orphan read/write
1958 section before or amongst the read-only ones. */
1959 if (add
.head
!= NULL
)
1961 lang_output_section_statement_type
*newly_added_os
;
1963 if (place
->stmt
== NULL
)
1965 lang_statement_union_type
**where
= insert_os_after (after
);
1970 place
->os_tail
= &after
->next
;
1974 /* Put it after the last orphan statement we added. */
1975 *add
.tail
= *place
->stmt
;
1976 *place
->stmt
= add
.head
;
1979 /* Fix the global list pointer if we happened to tack our
1980 new list at the tail. */
1981 if (*stat_ptr
->tail
== add
.head
)
1982 stat_ptr
->tail
= add
.tail
;
1984 /* Save the end of this list. */
1985 place
->stmt
= add
.tail
;
1987 /* Do the same for the list of output section statements. */
1988 newly_added_os
= *os_tail
;
1990 newly_added_os
->prev
= (lang_output_section_statement_type
*)
1991 ((char *) place
->os_tail
1992 - offsetof (lang_output_section_statement_type
, next
));
1993 newly_added_os
->next
= *place
->os_tail
;
1994 if (newly_added_os
->next
!= NULL
)
1995 newly_added_os
->next
->prev
= newly_added_os
;
1996 *place
->os_tail
= newly_added_os
;
1997 place
->os_tail
= &newly_added_os
->next
;
1999 /* Fixing the global list pointer here is a little different.
2000 We added to the list in lang_enter_output_section_statement,
2001 trimmed off the new output_section_statment above when
2002 assigning *os_tail = NULL, but possibly added it back in
2003 the same place when assigning *place->os_tail. */
2004 if (*os_tail
== NULL
)
2005 lang_output_section_statement
.tail
2006 = (lang_statement_union_type
**) os_tail
;
2013 lang_print_asneeded (void)
2015 struct asneeded_minfo
*m
;
2018 if (asneeded_list_head
== NULL
)
2021 sprintf (buf
, _("\nAs-needed library included "
2022 "to satisfy reference by file (symbol)\n\n"));
2025 for (m
= asneeded_list_head
; m
!= NULL
; m
= m
->next
)
2029 minfo ("%s", m
->soname
);
2030 len
= strlen (m
->soname
);
2044 minfo ("%B ", m
->ref
);
2045 minfo ("(%T)\n", m
->name
);
2050 lang_map_flags (flagword flag
)
2052 if (flag
& SEC_ALLOC
)
2055 if (flag
& SEC_CODE
)
2058 if (flag
& SEC_READONLY
)
2061 if (flag
& SEC_DATA
)
2064 if (flag
& SEC_LOAD
)
2071 lang_memory_region_type
*m
;
2072 bfd_boolean dis_header_printed
= FALSE
;
2074 LANG_FOR_EACH_INPUT_STATEMENT (file
)
2078 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
2079 || file
->flags
.just_syms
)
2082 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2083 if ((s
->output_section
== NULL
2084 || s
->output_section
->owner
!= link_info
.output_bfd
)
2085 && (s
->flags
& (SEC_LINKER_CREATED
| SEC_KEEP
)) == 0)
2087 if (! dis_header_printed
)
2089 fprintf (config
.map_file
, _("\nDiscarded input sections\n\n"));
2090 dis_header_printed
= TRUE
;
2093 print_input_section (s
, TRUE
);
2097 minfo (_("\nMemory Configuration\n\n"));
2098 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
2099 _("Name"), _("Origin"), _("Length"), _("Attributes"));
2101 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
2106 fprintf (config
.map_file
, "%-16s ", m
->name_list
.name
);
2108 sprintf_vma (buf
, m
->origin
);
2109 minfo ("0x%s ", buf
);
2117 minfo ("0x%V", m
->length
);
2118 if (m
->flags
|| m
->not_flags
)
2126 lang_map_flags (m
->flags
);
2132 lang_map_flags (m
->not_flags
);
2139 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
2141 if (! link_info
.reduce_memory_overheads
)
2143 obstack_begin (&map_obstack
, 1000);
2144 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
2146 lang_statement_iteration
++;
2147 print_statements ();
2149 ldemul_extra_map_file_text (link_info
.output_bfd
, &link_info
, config
.map_file
);
2153 sort_def_symbol (struct bfd_link_hash_entry
*hash_entry
,
2154 void *info ATTRIBUTE_UNUSED
)
2156 if ((hash_entry
->type
== bfd_link_hash_defined
2157 || hash_entry
->type
== bfd_link_hash_defweak
)
2158 && hash_entry
->u
.def
.section
->owner
!= link_info
.output_bfd
2159 && hash_entry
->u
.def
.section
->owner
!= NULL
)
2161 input_section_userdata_type
*ud
;
2162 struct map_symbol_def
*def
;
2164 ud
= ((input_section_userdata_type
*)
2165 get_userdata (hash_entry
->u
.def
.section
));
2168 ud
= (input_section_userdata_type
*) stat_alloc (sizeof (*ud
));
2169 get_userdata (hash_entry
->u
.def
.section
) = ud
;
2170 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2171 ud
->map_symbol_def_count
= 0;
2173 else if (!ud
->map_symbol_def_tail
)
2174 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2176 def
= (struct map_symbol_def
*) obstack_alloc (&map_obstack
, sizeof *def
);
2177 def
->entry
= hash_entry
;
2178 *(ud
->map_symbol_def_tail
) = def
;
2179 ud
->map_symbol_def_tail
= &def
->next
;
2180 ud
->map_symbol_def_count
++;
2185 /* Initialize an output section. */
2188 init_os (lang_output_section_statement_type
*s
, flagword flags
)
2190 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
2191 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
2193 if (s
->constraint
!= SPECIAL
)
2194 s
->bfd_section
= bfd_get_section_by_name (link_info
.output_bfd
, s
->name
);
2195 if (s
->bfd_section
== NULL
)
2196 s
->bfd_section
= bfd_make_section_anyway_with_flags (link_info
.output_bfd
,
2198 if (s
->bfd_section
== NULL
)
2200 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
2201 link_info
.output_bfd
->xvec
->name
, s
->name
);
2203 s
->bfd_section
->output_section
= s
->bfd_section
;
2204 s
->bfd_section
->output_offset
= 0;
2206 /* Set the userdata of the output section to the output section
2207 statement to avoid lookup. */
2208 get_userdata (s
->bfd_section
) = s
;
2210 /* If there is a base address, make sure that any sections it might
2211 mention are initialized. */
2212 if (s
->addr_tree
!= NULL
)
2213 exp_init_os (s
->addr_tree
);
2215 if (s
->load_base
!= NULL
)
2216 exp_init_os (s
->load_base
);
2218 /* If supplied an alignment, set it. */
2219 if (s
->section_alignment
!= -1)
2220 s
->bfd_section
->alignment_power
= s
->section_alignment
;
2223 /* Make sure that all output sections mentioned in an expression are
2227 exp_init_os (etree_type
*exp
)
2229 switch (exp
->type
.node_class
)
2233 exp_init_os (exp
->assign
.src
);
2237 exp_init_os (exp
->binary
.lhs
);
2238 exp_init_os (exp
->binary
.rhs
);
2242 exp_init_os (exp
->trinary
.cond
);
2243 exp_init_os (exp
->trinary
.lhs
);
2244 exp_init_os (exp
->trinary
.rhs
);
2248 exp_init_os (exp
->assert_s
.child
);
2252 exp_init_os (exp
->unary
.child
);
2256 switch (exp
->type
.node_code
)
2262 lang_output_section_statement_type
*os
;
2264 os
= lang_output_section_find (exp
->name
.name
);
2265 if (os
!= NULL
&& os
->bfd_section
== NULL
)
2277 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
2279 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
2281 /* If we are only reading symbols from this object, then we want to
2282 discard all sections. */
2283 if (entry
->flags
.just_syms
)
2285 bfd_link_just_syms (abfd
, sec
, &link_info
);
2289 if (!(abfd
->flags
& DYNAMIC
))
2290 bfd_section_already_linked (abfd
, sec
, &link_info
);
2293 /* The wild routines.
2295 These expand statements like *(.text) and foo.o to a list of
2296 explicit actions, like foo.o(.text), bar.o(.text) and
2297 foo.o(.text, .data). */
2299 /* Add SECTION to the output section OUTPUT. Do this by creating a
2300 lang_input_section statement which is placed at PTR. */
2303 lang_add_section (lang_statement_list_type
*ptr
,
2305 struct flag_info
*sflag_info
,
2306 lang_output_section_statement_type
*output
)
2308 flagword flags
= section
->flags
;
2310 bfd_boolean discard
;
2311 lang_input_section_type
*new_section
;
2312 bfd
*abfd
= link_info
.output_bfd
;
2314 /* Discard sections marked with SEC_EXCLUDE. */
2315 discard
= (flags
& SEC_EXCLUDE
) != 0;
2317 /* Discard input sections which are assigned to a section named
2318 DISCARD_SECTION_NAME. */
2319 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
2322 /* Discard debugging sections if we are stripping debugging
2324 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
2325 && (flags
& SEC_DEBUGGING
) != 0)
2330 if (section
->output_section
== NULL
)
2332 /* This prevents future calls from assigning this section. */
2333 section
->output_section
= bfd_abs_section_ptr
;
2342 keep
= bfd_lookup_section_flags (&link_info
, sflag_info
, section
);
2347 if (section
->output_section
!= NULL
)
2350 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2351 to an output section, because we want to be able to include a
2352 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2353 section (I don't know why we want to do this, but we do).
2354 build_link_order in ldwrite.c handles this case by turning
2355 the embedded SEC_NEVER_LOAD section into a fill. */
2356 flags
&= ~ SEC_NEVER_LOAD
;
2358 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2359 already been processed. One reason to do this is that on pe
2360 format targets, .text$foo sections go into .text and it's odd
2361 to see .text with SEC_LINK_ONCE set. */
2363 if (!bfd_link_relocatable (&link_info
))
2364 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2366 switch (output
->sectype
)
2368 case normal_section
:
2369 case overlay_section
:
2371 case noalloc_section
:
2372 flags
&= ~SEC_ALLOC
;
2374 case noload_section
:
2376 flags
|= SEC_NEVER_LOAD
;
2377 /* Unfortunately GNU ld has managed to evolve two different
2378 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2379 alloc, no contents section. All others get a noload, noalloc
2381 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
2382 flags
&= ~SEC_HAS_CONTENTS
;
2384 flags
&= ~SEC_ALLOC
;
2388 if (output
->bfd_section
== NULL
)
2389 init_os (output
, flags
);
2391 /* If SEC_READONLY is not set in the input section, then clear
2392 it from the output section. */
2393 output
->bfd_section
->flags
&= flags
| ~SEC_READONLY
;
2395 if (output
->bfd_section
->linker_has_input
)
2397 /* Only set SEC_READONLY flag on the first input section. */
2398 flags
&= ~ SEC_READONLY
;
2400 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2401 if ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2402 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2403 || ((flags
& SEC_MERGE
) != 0
2404 && output
->bfd_section
->entsize
!= section
->entsize
))
2406 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2407 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2410 output
->bfd_section
->flags
|= flags
;
2412 if (!output
->bfd_section
->linker_has_input
)
2414 output
->bfd_section
->linker_has_input
= 1;
2415 /* This must happen after flags have been updated. The output
2416 section may have been created before we saw its first input
2417 section, eg. for a data statement. */
2418 bfd_init_private_section_data (section
->owner
, section
,
2419 link_info
.output_bfd
,
2420 output
->bfd_section
,
2422 if ((flags
& SEC_MERGE
) != 0)
2423 output
->bfd_section
->entsize
= section
->entsize
;
2426 if ((flags
& SEC_TIC54X_BLOCK
) != 0
2427 && bfd_get_arch (section
->owner
) == bfd_arch_tic54x
)
2429 /* FIXME: This value should really be obtained from the bfd... */
2430 output
->block_value
= 128;
2433 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2434 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2436 section
->output_section
= output
->bfd_section
;
2438 if (!map_head_is_link_order
)
2440 asection
*s
= output
->bfd_section
->map_tail
.s
;
2441 output
->bfd_section
->map_tail
.s
= section
;
2442 section
->map_head
.s
= NULL
;
2443 section
->map_tail
.s
= s
;
2445 s
->map_head
.s
= section
;
2447 output
->bfd_section
->map_head
.s
= section
;
2450 /* Add a section reference to the list. */
2451 new_section
= new_stat (lang_input_section
, ptr
);
2452 new_section
->section
= section
;
2455 /* Handle wildcard sorting. This returns the lang_input_section which
2456 should follow the one we are going to create for SECTION and FILE,
2457 based on the sorting requirements of WILD. It returns NULL if the
2458 new section should just go at the end of the current list. */
2460 static lang_statement_union_type
*
2461 wild_sort (lang_wild_statement_type
*wild
,
2462 struct wildcard_list
*sec
,
2463 lang_input_statement_type
*file
,
2466 lang_statement_union_type
*l
;
2468 if (!wild
->filenames_sorted
2469 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
2472 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
2474 lang_input_section_type
*ls
;
2476 if (l
->header
.type
!= lang_input_section_enum
)
2478 ls
= &l
->input_section
;
2480 /* Sorting by filename takes precedence over sorting by section
2483 if (wild
->filenames_sorted
)
2485 const char *fn
, *ln
;
2489 /* The PE support for the .idata section as generated by
2490 dlltool assumes that files will be sorted by the name of
2491 the archive and then the name of the file within the
2494 if (file
->the_bfd
!= NULL
2495 && bfd_my_archive (file
->the_bfd
) != NULL
)
2497 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
2502 fn
= file
->filename
;
2506 if (bfd_my_archive (ls
->section
->owner
) != NULL
)
2508 ln
= bfd_get_filename (bfd_my_archive (ls
->section
->owner
));
2513 ln
= ls
->section
->owner
->filename
;
2517 i
= filename_cmp (fn
, ln
);
2526 fn
= file
->filename
;
2528 ln
= ls
->section
->owner
->filename
;
2530 i
= filename_cmp (fn
, ln
);
2538 /* Here either the files are not sorted by name, or we are
2539 looking at the sections for this file. */
2542 && sec
->spec
.sorted
!= none
2543 && sec
->spec
.sorted
!= by_none
)
2544 if (compare_section (sec
->spec
.sorted
, section
, ls
->section
) < 0)
2551 /* Expand a wild statement for a particular FILE. SECTION may be
2552 NULL, in which case it is a wild card. */
2555 output_section_callback (lang_wild_statement_type
*ptr
,
2556 struct wildcard_list
*sec
,
2558 struct flag_info
*sflag_info
,
2559 lang_input_statement_type
*file
,
2562 lang_statement_union_type
*before
;
2563 lang_output_section_statement_type
*os
;
2565 os
= (lang_output_section_statement_type
*) output
;
2567 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2568 if (unique_section_p (section
, os
))
2571 before
= wild_sort (ptr
, sec
, file
, section
);
2573 /* Here BEFORE points to the lang_input_section which
2574 should follow the one we are about to add. If BEFORE
2575 is NULL, then the section should just go at the end
2576 of the current list. */
2579 lang_add_section (&ptr
->children
, section
, sflag_info
, os
);
2582 lang_statement_list_type list
;
2583 lang_statement_union_type
**pp
;
2585 lang_list_init (&list
);
2586 lang_add_section (&list
, section
, sflag_info
, os
);
2588 /* If we are discarding the section, LIST.HEAD will
2590 if (list
.head
!= NULL
)
2592 ASSERT (list
.head
->header
.next
== NULL
);
2594 for (pp
= &ptr
->children
.head
;
2596 pp
= &(*pp
)->header
.next
)
2597 ASSERT (*pp
!= NULL
);
2599 list
.head
->header
.next
= *pp
;
2605 /* Check if all sections in a wild statement for a particular FILE
2609 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2610 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2612 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
2613 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2616 lang_output_section_statement_type
*os
;
2618 os
= (lang_output_section_statement_type
*) output
;
2620 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2621 if (unique_section_p (section
, os
))
2624 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2625 os
->all_input_readonly
= FALSE
;
2628 /* This is passed a file name which must have been seen already and
2629 added to the statement tree. We will see if it has been opened
2630 already and had its symbols read. If not then we'll read it. */
2632 static lang_input_statement_type
*
2633 lookup_name (const char *name
)
2635 lang_input_statement_type
*search
;
2637 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
2639 search
= (lang_input_statement_type
*) search
->next_real_file
)
2641 /* Use the local_sym_name as the name of the file that has
2642 already been loaded as filename might have been transformed
2643 via the search directory lookup mechanism. */
2644 const char *filename
= search
->local_sym_name
;
2646 if (filename
!= NULL
2647 && filename_cmp (filename
, name
) == 0)
2652 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2653 default_target
, FALSE
);
2655 /* If we have already added this file, or this file is not real
2656 don't add this file. */
2657 if (search
->flags
.loaded
|| !search
->flags
.real
)
2660 if (! load_symbols (search
, NULL
))
2666 /* Save LIST as a list of libraries whose symbols should not be exported. */
2671 struct excluded_lib
*next
;
2673 static struct excluded_lib
*excluded_libs
;
2676 add_excluded_libs (const char *list
)
2678 const char *p
= list
, *end
;
2682 struct excluded_lib
*entry
;
2683 end
= strpbrk (p
, ",:");
2685 end
= p
+ strlen (p
);
2686 entry
= (struct excluded_lib
*) xmalloc (sizeof (*entry
));
2687 entry
->next
= excluded_libs
;
2688 entry
->name
= (char *) xmalloc (end
- p
+ 1);
2689 memcpy (entry
->name
, p
, end
- p
);
2690 entry
->name
[end
- p
] = '\0';
2691 excluded_libs
= entry
;
2699 check_excluded_libs (bfd
*abfd
)
2701 struct excluded_lib
*lib
= excluded_libs
;
2705 int len
= strlen (lib
->name
);
2706 const char *filename
= lbasename (abfd
->filename
);
2708 if (strcmp (lib
->name
, "ALL") == 0)
2710 abfd
->no_export
= TRUE
;
2714 if (filename_ncmp (lib
->name
, filename
, len
) == 0
2715 && (filename
[len
] == '\0'
2716 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
2717 && filename
[len
+ 2] == '\0')))
2719 abfd
->no_export
= TRUE
;
2727 /* Get the symbols for an input file. */
2730 load_symbols (lang_input_statement_type
*entry
,
2731 lang_statement_list_type
*place
)
2735 if (entry
->flags
.loaded
)
2738 ldfile_open_file (entry
);
2740 /* Do not process further if the file was missing. */
2741 if (entry
->flags
.missing_file
)
2744 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
2745 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
2748 struct lang_input_statement_flags save_flags
;
2751 err
= bfd_get_error ();
2753 /* See if the emulation has some special knowledge. */
2754 if (ldemul_unrecognized_file (entry
))
2757 if (err
== bfd_error_file_ambiguously_recognized
)
2761 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
2762 einfo (_("%B: matching formats:"), entry
->the_bfd
);
2763 for (p
= matching
; *p
!= NULL
; p
++)
2767 else if (err
!= bfd_error_file_not_recognized
2769 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
2771 bfd_close (entry
->the_bfd
);
2772 entry
->the_bfd
= NULL
;
2774 /* Try to interpret the file as a linker script. */
2775 save_flags
= input_flags
;
2776 ldfile_open_command_file (entry
->filename
);
2778 push_stat_ptr (place
);
2779 input_flags
.add_DT_NEEDED_for_regular
2780 = entry
->flags
.add_DT_NEEDED_for_regular
;
2781 input_flags
.add_DT_NEEDED_for_dynamic
2782 = entry
->flags
.add_DT_NEEDED_for_dynamic
;
2783 input_flags
.whole_archive
= entry
->flags
.whole_archive
;
2784 input_flags
.dynamic
= entry
->flags
.dynamic
;
2786 ldfile_assumed_script
= TRUE
;
2787 parser_input
= input_script
;
2789 ldfile_assumed_script
= FALSE
;
2791 /* missing_file is sticky. sysrooted will already have been
2792 restored when seeing EOF in yyparse, but no harm to restore
2794 save_flags
.missing_file
|= input_flags
.missing_file
;
2795 input_flags
= save_flags
;
2799 entry
->flags
.loaded
= TRUE
;
2804 if (ldemul_recognized_file (entry
))
2807 /* We don't call ldlang_add_file for an archive. Instead, the
2808 add_symbols entry point will call ldlang_add_file, via the
2809 add_archive_element callback, for each element of the archive
2811 switch (bfd_get_format (entry
->the_bfd
))
2817 if (!entry
->flags
.reload
)
2818 ldlang_add_file (entry
);
2819 if (trace_files
|| verbose
)
2820 info_msg ("%I\n", entry
);
2824 check_excluded_libs (entry
->the_bfd
);
2826 if (entry
->flags
.whole_archive
)
2829 bfd_boolean loaded
= TRUE
;
2834 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
2839 if (! bfd_check_format (member
, bfd_object
))
2841 einfo (_("%F%B: member %B in archive is not an object\n"),
2842 entry
->the_bfd
, member
);
2847 if (!(*link_info
.callbacks
2848 ->add_archive_element
) (&link_info
, member
,
2849 "--whole-archive", &subsbfd
))
2852 /* Potentially, the add_archive_element hook may have set a
2853 substitute BFD for us. */
2854 if (!bfd_link_add_symbols (subsbfd
, &link_info
))
2856 einfo (_("%F%B: error adding symbols: %E\n"), member
);
2861 entry
->flags
.loaded
= loaded
;
2867 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
2868 entry
->flags
.loaded
= TRUE
;
2870 einfo (_("%F%B: error adding symbols: %E\n"), entry
->the_bfd
);
2872 return entry
->flags
.loaded
;
2875 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
2876 may be NULL, indicating that it is a wildcard. Separate
2877 lang_input_section statements are created for each part of the
2878 expansion; they are added after the wild statement S. OUTPUT is
2879 the output section. */
2882 wild (lang_wild_statement_type
*s
,
2883 const char *target ATTRIBUTE_UNUSED
,
2884 lang_output_section_statement_type
*output
)
2886 struct wildcard_list
*sec
;
2888 if (s
->handler_data
[0]
2889 && s
->handler_data
[0]->spec
.sorted
== by_name
2890 && !s
->filenames_sorted
)
2892 lang_section_bst_type
*tree
;
2894 walk_wild (s
, output_section_callback_fast
, output
);
2899 output_section_callback_tree_to_list (s
, tree
, output
);
2904 walk_wild (s
, output_section_callback
, output
);
2906 if (default_common_section
== NULL
)
2907 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
2908 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
2910 /* Remember the section that common is going to in case we
2911 later get something which doesn't know where to put it. */
2912 default_common_section
= output
;
2917 /* Return TRUE iff target is the sought target. */
2920 get_target (const bfd_target
*target
, void *data
)
2922 const char *sought
= (const char *) data
;
2924 return strcmp (target
->name
, sought
) == 0;
2927 /* Like strcpy() but convert to lower case as well. */
2930 stricpy (char *dest
, char *src
)
2934 while ((c
= *src
++) != 0)
2935 *dest
++ = TOLOWER (c
);
2940 /* Remove the first occurrence of needle (if any) in haystack
2944 strcut (char *haystack
, char *needle
)
2946 haystack
= strstr (haystack
, needle
);
2952 for (src
= haystack
+ strlen (needle
); *src
;)
2953 *haystack
++ = *src
++;
2959 /* Compare two target format name strings.
2960 Return a value indicating how "similar" they are. */
2963 name_compare (char *first
, char *second
)
2969 copy1
= (char *) xmalloc (strlen (first
) + 1);
2970 copy2
= (char *) xmalloc (strlen (second
) + 1);
2972 /* Convert the names to lower case. */
2973 stricpy (copy1
, first
);
2974 stricpy (copy2
, second
);
2976 /* Remove size and endian strings from the name. */
2977 strcut (copy1
, "big");
2978 strcut (copy1
, "little");
2979 strcut (copy2
, "big");
2980 strcut (copy2
, "little");
2982 /* Return a value based on how many characters match,
2983 starting from the beginning. If both strings are
2984 the same then return 10 * their length. */
2985 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
2986 if (copy1
[result
] == 0)
2998 /* Set by closest_target_match() below. */
2999 static const bfd_target
*winner
;
3001 /* Scan all the valid bfd targets looking for one that has the endianness
3002 requirement that was specified on the command line, and is the nearest
3003 match to the original output target. */
3006 closest_target_match (const bfd_target
*target
, void *data
)
3008 const bfd_target
*original
= (const bfd_target
*) data
;
3010 if (command_line
.endian
== ENDIAN_BIG
3011 && target
->byteorder
!= BFD_ENDIAN_BIG
)
3014 if (command_line
.endian
== ENDIAN_LITTLE
3015 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
3018 /* Must be the same flavour. */
3019 if (target
->flavour
!= original
->flavour
)
3022 /* Ignore generic big and little endian elf vectors. */
3023 if (strcmp (target
->name
, "elf32-big") == 0
3024 || strcmp (target
->name
, "elf64-big") == 0
3025 || strcmp (target
->name
, "elf32-little") == 0
3026 || strcmp (target
->name
, "elf64-little") == 0)
3029 /* If we have not found a potential winner yet, then record this one. */
3036 /* Oh dear, we now have two potential candidates for a successful match.
3037 Compare their names and choose the better one. */
3038 if (name_compare (target
->name
, original
->name
)
3039 > name_compare (winner
->name
, original
->name
))
3042 /* Keep on searching until wqe have checked them all. */
3046 /* Return the BFD target format of the first input file. */
3049 get_first_input_target (void)
3051 char *target
= NULL
;
3053 LANG_FOR_EACH_INPUT_STATEMENT (s
)
3055 if (s
->header
.type
== lang_input_statement_enum
3058 ldfile_open_file (s
);
3060 if (s
->the_bfd
!= NULL
3061 && bfd_check_format (s
->the_bfd
, bfd_object
))
3063 target
= bfd_get_target (s
->the_bfd
);
3075 lang_get_output_target (void)
3079 /* Has the user told us which output format to use? */
3080 if (output_target
!= NULL
)
3081 return output_target
;
3083 /* No - has the current target been set to something other than
3085 if (current_target
!= default_target
&& current_target
!= NULL
)
3086 return current_target
;
3088 /* No - can we determine the format of the first input file? */
3089 target
= get_first_input_target ();
3093 /* Failed - use the default output target. */
3094 return default_target
;
3097 /* Open the output file. */
3100 open_output (const char *name
)
3102 output_target
= lang_get_output_target ();
3104 /* Has the user requested a particular endianness on the command
3106 if (command_line
.endian
!= ENDIAN_UNSET
)
3108 const bfd_target
*target
;
3109 enum bfd_endian desired_endian
;
3111 /* Get the chosen target. */
3112 target
= bfd_search_for_target (get_target
, (void *) output_target
);
3114 /* If the target is not supported, we cannot do anything. */
3117 if (command_line
.endian
== ENDIAN_BIG
)
3118 desired_endian
= BFD_ENDIAN_BIG
;
3120 desired_endian
= BFD_ENDIAN_LITTLE
;
3122 /* See if the target has the wrong endianness. This should
3123 not happen if the linker script has provided big and
3124 little endian alternatives, but some scrips don't do
3126 if (target
->byteorder
!= desired_endian
)
3128 /* If it does, then see if the target provides
3129 an alternative with the correct endianness. */
3130 if (target
->alternative_target
!= NULL
3131 && (target
->alternative_target
->byteorder
== desired_endian
))
3132 output_target
= target
->alternative_target
->name
;
3135 /* Try to find a target as similar as possible to
3136 the default target, but which has the desired
3137 endian characteristic. */
3138 bfd_search_for_target (closest_target_match
,
3141 /* Oh dear - we could not find any targets that
3142 satisfy our requirements. */
3144 einfo (_("%P: warning: could not find any targets"
3145 " that match endianness requirement\n"));
3147 output_target
= winner
->name
;
3153 link_info
.output_bfd
= bfd_openw (name
, output_target
);
3155 if (link_info
.output_bfd
== NULL
)
3157 if (bfd_get_error () == bfd_error_invalid_target
)
3158 einfo (_("%P%F: target %s not found\n"), output_target
);
3160 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
3163 delete_output_file_on_failure
= TRUE
;
3165 if (! bfd_set_format (link_info
.output_bfd
, bfd_object
))
3166 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
3167 if (! bfd_set_arch_mach (link_info
.output_bfd
,
3168 ldfile_output_architecture
,
3169 ldfile_output_machine
))
3170 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
3172 link_info
.hash
= bfd_link_hash_table_create (link_info
.output_bfd
);
3173 if (link_info
.hash
== NULL
)
3174 einfo (_("%P%F: can not create hash table: %E\n"));
3176 bfd_set_gp_size (link_info
.output_bfd
, g_switch_value
);
3180 ldlang_open_output (lang_statement_union_type
*statement
)
3182 switch (statement
->header
.type
)
3184 case lang_output_statement_enum
:
3185 ASSERT (link_info
.output_bfd
== NULL
);
3186 open_output (statement
->output_statement
.name
);
3187 ldemul_set_output_arch ();
3188 if (config
.magic_demand_paged
3189 && !bfd_link_relocatable (&link_info
))
3190 link_info
.output_bfd
->flags
|= D_PAGED
;
3192 link_info
.output_bfd
->flags
&= ~D_PAGED
;
3193 if (config
.text_read_only
)
3194 link_info
.output_bfd
->flags
|= WP_TEXT
;
3196 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
3197 if (link_info
.traditional_format
)
3198 link_info
.output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
3200 link_info
.output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
3203 case lang_target_statement_enum
:
3204 current_target
= statement
->target_statement
.target
;
3211 /* Convert between addresses in bytes and sizes in octets.
3212 For currently supported targets, octets_per_byte is always a power
3213 of two, so we can use shifts. */
3214 #define TO_ADDR(X) ((X) >> opb_shift)
3215 #define TO_SIZE(X) ((X) << opb_shift)
3217 /* Support the above. */
3218 static unsigned int opb_shift
= 0;
3223 unsigned x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3224 ldfile_output_machine
);
3227 while ((x
& 1) == 0)
3235 /* Open all the input files. */
3239 OPEN_BFD_NORMAL
= 0,
3243 #ifdef ENABLE_PLUGINS
3244 static lang_input_statement_type
*plugin_insert
= NULL
;
3248 open_input_bfds (lang_statement_union_type
*s
, enum open_bfd_mode mode
)
3250 for (; s
!= NULL
; s
= s
->header
.next
)
3252 switch (s
->header
.type
)
3254 case lang_constructors_statement_enum
:
3255 open_input_bfds (constructor_list
.head
, mode
);
3257 case lang_output_section_statement_enum
:
3258 open_input_bfds (s
->output_section_statement
.children
.head
, mode
);
3260 case lang_wild_statement_enum
:
3261 /* Maybe we should load the file's symbols. */
3262 if ((mode
& OPEN_BFD_RESCAN
) == 0
3263 && s
->wild_statement
.filename
3264 && !wildcardp (s
->wild_statement
.filename
)
3265 && !archive_path (s
->wild_statement
.filename
))
3266 lookup_name (s
->wild_statement
.filename
);
3267 open_input_bfds (s
->wild_statement
.children
.head
, mode
);
3269 case lang_group_statement_enum
:
3271 struct bfd_link_hash_entry
*undefs
;
3273 /* We must continually search the entries in the group
3274 until no new symbols are added to the list of undefined
3279 undefs
= link_info
.hash
->undefs_tail
;
3280 open_input_bfds (s
->group_statement
.children
.head
,
3281 mode
| OPEN_BFD_FORCE
);
3283 while (undefs
!= link_info
.hash
->undefs_tail
);
3286 case lang_target_statement_enum
:
3287 current_target
= s
->target_statement
.target
;
3289 case lang_input_statement_enum
:
3290 if (s
->input_statement
.flags
.real
)
3292 lang_statement_union_type
**os_tail
;
3293 lang_statement_list_type add
;
3296 s
->input_statement
.target
= current_target
;
3298 /* If we are being called from within a group, and this
3299 is an archive which has already been searched, then
3300 force it to be researched unless the whole archive
3301 has been loaded already. Do the same for a rescan.
3302 Likewise reload --as-needed shared libs. */
3303 if (mode
!= OPEN_BFD_NORMAL
3304 #ifdef ENABLE_PLUGINS
3305 && ((mode
& OPEN_BFD_RESCAN
) == 0
3306 || plugin_insert
== NULL
)
3308 && s
->input_statement
.flags
.loaded
3309 && (abfd
= s
->input_statement
.the_bfd
) != NULL
3310 && ((bfd_get_format (abfd
) == bfd_archive
3311 && !s
->input_statement
.flags
.whole_archive
)
3312 || (bfd_get_format (abfd
) == bfd_object
3313 && ((abfd
->flags
) & DYNAMIC
) != 0
3314 && s
->input_statement
.flags
.add_DT_NEEDED_for_regular
3315 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3316 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)))
3318 s
->input_statement
.flags
.loaded
= FALSE
;
3319 s
->input_statement
.flags
.reload
= TRUE
;
3322 os_tail
= lang_output_section_statement
.tail
;
3323 lang_list_init (&add
);
3325 if (! load_symbols (&s
->input_statement
, &add
))
3326 config
.make_executable
= FALSE
;
3328 if (add
.head
!= NULL
)
3330 /* If this was a script with output sections then
3331 tack any added statements on to the end of the
3332 list. This avoids having to reorder the output
3333 section statement list. Very likely the user
3334 forgot -T, and whatever we do here will not meet
3335 naive user expectations. */
3336 if (os_tail
!= lang_output_section_statement
.tail
)
3338 einfo (_("%P: warning: %s contains output sections;"
3339 " did you forget -T?\n"),
3340 s
->input_statement
.filename
);
3341 *stat_ptr
->tail
= add
.head
;
3342 stat_ptr
->tail
= add
.tail
;
3346 *add
.tail
= s
->header
.next
;
3347 s
->header
.next
= add
.head
;
3351 #ifdef ENABLE_PLUGINS
3352 /* If we have found the point at which a plugin added new
3353 files, clear plugin_insert to enable archive rescan. */
3354 if (&s
->input_statement
== plugin_insert
)
3355 plugin_insert
= NULL
;
3358 case lang_assignment_statement_enum
:
3359 if (s
->assignment_statement
.exp
->assign
.defsym
)
3360 /* This is from a --defsym on the command line. */
3361 exp_fold_tree_no_dot (s
->assignment_statement
.exp
);
3368 /* Exit if any of the files were missing. */
3369 if (input_flags
.missing_file
)
3373 /* Add the supplied name to the symbol table as an undefined reference.
3374 This is a two step process as the symbol table doesn't even exist at
3375 the time the ld command line is processed. First we put the name
3376 on a list, then, once the output file has been opened, transfer the
3377 name to the symbol table. */
3379 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3381 #define ldlang_undef_chain_list_head entry_symbol.next
3384 ldlang_add_undef (const char *const name
, bfd_boolean cmdline
)
3386 ldlang_undef_chain_list_type
*new_undef
;
3388 undef_from_cmdline
= undef_from_cmdline
|| cmdline
;
3389 new_undef
= (ldlang_undef_chain_list_type
*) stat_alloc (sizeof (*new_undef
));
3390 new_undef
->next
= ldlang_undef_chain_list_head
;
3391 ldlang_undef_chain_list_head
= new_undef
;
3393 new_undef
->name
= xstrdup (name
);
3395 if (link_info
.output_bfd
!= NULL
)
3396 insert_undefined (new_undef
->name
);
3399 /* Insert NAME as undefined in the symbol table. */
3402 insert_undefined (const char *name
)
3404 struct bfd_link_hash_entry
*h
;
3406 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
3408 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3409 if (h
->type
== bfd_link_hash_new
)
3411 h
->type
= bfd_link_hash_undefined
;
3412 h
->u
.undef
.abfd
= NULL
;
3413 bfd_link_add_undef (link_info
.hash
, h
);
3417 /* Run through the list of undefineds created above and place them
3418 into the linker hash table as undefined symbols belonging to the
3422 lang_place_undefineds (void)
3424 ldlang_undef_chain_list_type
*ptr
;
3426 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3427 insert_undefined (ptr
->name
);
3430 /* Structure used to build the list of symbols that the user has required
3433 struct require_defined_symbol
3436 struct require_defined_symbol
*next
;
3439 /* The list of symbols that the user has required be defined. */
3441 static struct require_defined_symbol
*require_defined_symbol_list
;
3443 /* Add a new symbol NAME to the list of symbols that are required to be
3447 ldlang_add_require_defined (const char * const name
)
3449 struct require_defined_symbol
*ptr
;
3451 ldlang_add_undef (name
, TRUE
);
3452 ptr
= (struct require_defined_symbol
*) stat_alloc (sizeof (*ptr
));
3453 ptr
->next
= require_defined_symbol_list
;
3454 ptr
->name
= strdup (name
);
3455 require_defined_symbol_list
= ptr
;
3458 /* Check that all symbols the user required to be defined, are defined,
3459 raise an error if we find a symbol that is not defined. */
3462 ldlang_check_require_defined_symbols (void)
3464 struct require_defined_symbol
*ptr
;
3466 for (ptr
= require_defined_symbol_list
; ptr
!= NULL
; ptr
= ptr
->next
)
3468 struct bfd_link_hash_entry
*h
;
3470 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
,
3471 FALSE
, FALSE
, TRUE
);
3473 || (h
->type
!= bfd_link_hash_defined
3474 && h
->type
!= bfd_link_hash_defweak
))
3475 einfo(_("%P%X: required symbol `%s' not defined\n"), ptr
->name
);
3479 /* Check for all readonly or some readwrite sections. */
3482 check_input_sections
3483 (lang_statement_union_type
*s
,
3484 lang_output_section_statement_type
*output_section_statement
)
3486 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
3488 switch (s
->header
.type
)
3490 case lang_wild_statement_enum
:
3491 walk_wild (&s
->wild_statement
, check_section_callback
,
3492 output_section_statement
);
3493 if (! output_section_statement
->all_input_readonly
)
3496 case lang_constructors_statement_enum
:
3497 check_input_sections (constructor_list
.head
,
3498 output_section_statement
);
3499 if (! output_section_statement
->all_input_readonly
)
3502 case lang_group_statement_enum
:
3503 check_input_sections (s
->group_statement
.children
.head
,
3504 output_section_statement
);
3505 if (! output_section_statement
->all_input_readonly
)
3514 /* Update wildcard statements if needed. */
3517 update_wild_statements (lang_statement_union_type
*s
)
3519 struct wildcard_list
*sec
;
3521 switch (sort_section
)
3531 for (; s
!= NULL
; s
= s
->header
.next
)
3533 switch (s
->header
.type
)
3538 case lang_wild_statement_enum
:
3539 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
3542 switch (sec
->spec
.sorted
)
3545 sec
->spec
.sorted
= sort_section
;
3548 if (sort_section
== by_alignment
)
3549 sec
->spec
.sorted
= by_name_alignment
;
3552 if (sort_section
== by_name
)
3553 sec
->spec
.sorted
= by_alignment_name
;
3561 case lang_constructors_statement_enum
:
3562 update_wild_statements (constructor_list
.head
);
3565 case lang_output_section_statement_enum
:
3566 /* Don't sort .init/.fini sections. */
3567 if (strcmp (s
->output_section_statement
.name
, ".init") != 0
3568 && strcmp (s
->output_section_statement
.name
, ".fini") != 0)
3569 update_wild_statements
3570 (s
->output_section_statement
.children
.head
);
3573 case lang_group_statement_enum
:
3574 update_wild_statements (s
->group_statement
.children
.head
);
3582 /* Open input files and attach to output sections. */
3585 map_input_to_output_sections
3586 (lang_statement_union_type
*s
, const char *target
,
3587 lang_output_section_statement_type
*os
)
3589 for (; s
!= NULL
; s
= s
->header
.next
)
3591 lang_output_section_statement_type
*tos
;
3594 switch (s
->header
.type
)
3596 case lang_wild_statement_enum
:
3597 wild (&s
->wild_statement
, target
, os
);
3599 case lang_constructors_statement_enum
:
3600 map_input_to_output_sections (constructor_list
.head
,
3604 case lang_output_section_statement_enum
:
3605 tos
= &s
->output_section_statement
;
3606 if (tos
->constraint
!= 0)
3608 if (tos
->constraint
!= ONLY_IF_RW
3609 && tos
->constraint
!= ONLY_IF_RO
)
3611 tos
->all_input_readonly
= TRUE
;
3612 check_input_sections (tos
->children
.head
, tos
);
3613 if (tos
->all_input_readonly
!= (tos
->constraint
== ONLY_IF_RO
))
3615 tos
->constraint
= -1;
3619 map_input_to_output_sections (tos
->children
.head
,
3623 case lang_output_statement_enum
:
3625 case lang_target_statement_enum
:
3626 target
= s
->target_statement
.target
;
3628 case lang_group_statement_enum
:
3629 map_input_to_output_sections (s
->group_statement
.children
.head
,
3633 case lang_data_statement_enum
:
3634 /* Make sure that any sections mentioned in the expression
3636 exp_init_os (s
->data_statement
.exp
);
3637 /* The output section gets CONTENTS, ALLOC and LOAD, but
3638 these may be overridden by the script. */
3639 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
;
3640 switch (os
->sectype
)
3642 case normal_section
:
3643 case overlay_section
:
3645 case noalloc_section
:
3646 flags
= SEC_HAS_CONTENTS
;
3648 case noload_section
:
3649 if (bfd_get_flavour (link_info
.output_bfd
)
3650 == bfd_target_elf_flavour
)
3651 flags
= SEC_NEVER_LOAD
| SEC_ALLOC
;
3653 flags
= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
;
3656 if (os
->bfd_section
== NULL
)
3657 init_os (os
, flags
);
3659 os
->bfd_section
->flags
|= flags
;
3661 case lang_input_section_enum
:
3663 case lang_fill_statement_enum
:
3664 case lang_object_symbols_statement_enum
:
3665 case lang_reloc_statement_enum
:
3666 case lang_padding_statement_enum
:
3667 case lang_input_statement_enum
:
3668 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3671 case lang_assignment_statement_enum
:
3672 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3675 /* Make sure that any sections mentioned in the assignment
3677 exp_init_os (s
->assignment_statement
.exp
);
3679 case lang_address_statement_enum
:
3680 /* Mark the specified section with the supplied address.
3681 If this section was actually a segment marker, then the
3682 directive is ignored if the linker script explicitly
3683 processed the segment marker. Originally, the linker
3684 treated segment directives (like -Ttext on the
3685 command-line) as section directives. We honor the
3686 section directive semantics for backwards compatibilty;
3687 linker scripts that do not specifically check for
3688 SEGMENT_START automatically get the old semantics. */
3689 if (!s
->address_statement
.segment
3690 || !s
->address_statement
.segment
->used
)
3692 const char *name
= s
->address_statement
.section_name
;
3694 /* Create the output section statement here so that
3695 orphans with a set address will be placed after other
3696 script sections. If we let the orphan placement code
3697 place them in amongst other sections then the address
3698 will affect following script sections, which is
3699 likely to surprise naive users. */
3700 tos
= lang_output_section_statement_lookup (name
, 0, TRUE
);
3701 tos
->addr_tree
= s
->address_statement
.address
;
3702 if (tos
->bfd_section
== NULL
)
3706 case lang_insert_statement_enum
:
3712 /* An insert statement snips out all the linker statements from the
3713 start of the list and places them after the output section
3714 statement specified by the insert. This operation is complicated
3715 by the fact that we keep a doubly linked list of output section
3716 statements as well as the singly linked list of all statements. */
3719 process_insert_statements (void)
3721 lang_statement_union_type
**s
;
3722 lang_output_section_statement_type
*first_os
= NULL
;
3723 lang_output_section_statement_type
*last_os
= NULL
;
3724 lang_output_section_statement_type
*os
;
3726 /* "start of list" is actually the statement immediately after
3727 the special abs_section output statement, so that it isn't
3729 s
= &lang_output_section_statement
.head
;
3730 while (*(s
= &(*s
)->header
.next
) != NULL
)
3732 if ((*s
)->header
.type
== lang_output_section_statement_enum
)
3734 /* Keep pointers to the first and last output section
3735 statement in the sequence we may be about to move. */
3736 os
= &(*s
)->output_section_statement
;
3738 ASSERT (last_os
== NULL
|| last_os
->next
== os
);
3741 /* Set constraint negative so that lang_output_section_find
3742 won't match this output section statement. At this
3743 stage in linking constraint has values in the range
3744 [-1, ONLY_IN_RW]. */
3745 last_os
->constraint
= -2 - last_os
->constraint
;
3746 if (first_os
== NULL
)
3749 else if ((*s
)->header
.type
== lang_insert_statement_enum
)
3751 lang_insert_statement_type
*i
= &(*s
)->insert_statement
;
3752 lang_output_section_statement_type
*where
;
3753 lang_statement_union_type
**ptr
;
3754 lang_statement_union_type
*first
;
3756 where
= lang_output_section_find (i
->where
);
3757 if (where
!= NULL
&& i
->is_before
)
3760 where
= where
->prev
;
3761 while (where
!= NULL
&& where
->constraint
< 0);
3765 einfo (_("%F%P: %s not found for insert\n"), i
->where
);
3769 /* Deal with reordering the output section statement list. */
3770 if (last_os
!= NULL
)
3772 asection
*first_sec
, *last_sec
;
3773 struct lang_output_section_statement_struct
**next
;
3775 /* Snip out the output sections we are moving. */
3776 first_os
->prev
->next
= last_os
->next
;
3777 if (last_os
->next
== NULL
)
3779 next
= &first_os
->prev
->next
;
3780 lang_output_section_statement
.tail
3781 = (lang_statement_union_type
**) next
;
3784 last_os
->next
->prev
= first_os
->prev
;
3785 /* Add them in at the new position. */
3786 last_os
->next
= where
->next
;
3787 if (where
->next
== NULL
)
3789 next
= &last_os
->next
;
3790 lang_output_section_statement
.tail
3791 = (lang_statement_union_type
**) next
;
3794 where
->next
->prev
= last_os
;
3795 first_os
->prev
= where
;
3796 where
->next
= first_os
;
3798 /* Move the bfd sections in the same way. */
3801 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
3803 os
->constraint
= -2 - os
->constraint
;
3804 if (os
->bfd_section
!= NULL
3805 && os
->bfd_section
->owner
!= NULL
)
3807 last_sec
= os
->bfd_section
;
3808 if (first_sec
== NULL
)
3809 first_sec
= last_sec
;
3814 if (last_sec
!= NULL
)
3816 asection
*sec
= where
->bfd_section
;
3818 sec
= output_prev_sec_find (where
);
3820 /* The place we want to insert must come after the
3821 sections we are moving. So if we find no
3822 section or if the section is the same as our
3823 last section, then no move is needed. */
3824 if (sec
!= NULL
&& sec
!= last_sec
)
3826 /* Trim them off. */
3827 if (first_sec
->prev
!= NULL
)
3828 first_sec
->prev
->next
= last_sec
->next
;
3830 link_info
.output_bfd
->sections
= last_sec
->next
;
3831 if (last_sec
->next
!= NULL
)
3832 last_sec
->next
->prev
= first_sec
->prev
;
3834 link_info
.output_bfd
->section_last
= first_sec
->prev
;
3836 last_sec
->next
= sec
->next
;
3837 if (sec
->next
!= NULL
)
3838 sec
->next
->prev
= last_sec
;
3840 link_info
.output_bfd
->section_last
= last_sec
;
3841 first_sec
->prev
= sec
;
3842 sec
->next
= first_sec
;
3850 ptr
= insert_os_after (where
);
3851 /* Snip everything after the abs_section output statement we
3852 know is at the start of the list, up to and including
3853 the insert statement we are currently processing. */
3854 first
= lang_output_section_statement
.head
->header
.next
;
3855 lang_output_section_statement
.head
->header
.next
= (*s
)->header
.next
;
3856 /* Add them back where they belong. */
3859 statement_list
.tail
= s
;
3861 s
= &lang_output_section_statement
.head
;
3865 /* Undo constraint twiddling. */
3866 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
3868 os
->constraint
= -2 - os
->constraint
;
3874 /* An output section might have been removed after its statement was
3875 added. For example, ldemul_before_allocation can remove dynamic
3876 sections if they turn out to be not needed. Clean them up here. */
3879 strip_excluded_output_sections (void)
3881 lang_output_section_statement_type
*os
;
3883 /* Run lang_size_sections (if not already done). */
3884 if (expld
.phase
!= lang_mark_phase_enum
)
3886 expld
.phase
= lang_mark_phase_enum
;
3887 expld
.dataseg
.phase
= exp_dataseg_none
;
3888 one_lang_size_sections_pass (NULL
, FALSE
);
3889 lang_reset_memory_regions ();
3892 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
3896 asection
*output_section
;
3897 bfd_boolean exclude
;
3899 if (os
->constraint
< 0)
3902 output_section
= os
->bfd_section
;
3903 if (output_section
== NULL
)
3906 exclude
= (output_section
->rawsize
== 0
3907 && (output_section
->flags
& SEC_KEEP
) == 0
3908 && !bfd_section_removed_from_list (link_info
.output_bfd
,
3911 /* Some sections have not yet been sized, notably .gnu.version,
3912 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
3913 input sections, so don't drop output sections that have such
3914 input sections unless they are also marked SEC_EXCLUDE. */
3915 if (exclude
&& output_section
->map_head
.s
!= NULL
)
3919 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
3920 if ((s
->flags
& SEC_EXCLUDE
) == 0
3921 && ((s
->flags
& SEC_LINKER_CREATED
) != 0
3922 || link_info
.emitrelocations
))
3931 /* We don't set bfd_section to NULL since bfd_section of the
3932 removed output section statement may still be used. */
3933 if (!os
->update_dot
)
3935 output_section
->flags
|= SEC_EXCLUDE
;
3936 bfd_section_list_remove (link_info
.output_bfd
, output_section
);
3937 link_info
.output_bfd
->section_count
--;
3942 /* Called from ldwrite to clear out asection.map_head and
3943 asection.map_tail for use as link_orders in ldwrite.
3944 FIXME: Except for sh64elf.em which starts creating link_orders in
3945 its after_allocation routine so needs to call it early. */
3948 lang_clear_os_map (void)
3950 lang_output_section_statement_type
*os
;
3952 if (map_head_is_link_order
)
3955 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
3959 asection
*output_section
;
3961 if (os
->constraint
< 0)
3964 output_section
= os
->bfd_section
;
3965 if (output_section
== NULL
)
3968 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
3969 output_section
->map_head
.link_order
= NULL
;
3970 output_section
->map_tail
.link_order
= NULL
;
3973 /* Stop future calls to lang_add_section from messing with map_head
3974 and map_tail link_order fields. */
3975 map_head_is_link_order
= TRUE
;
3979 print_output_section_statement
3980 (lang_output_section_statement_type
*output_section_statement
)
3982 asection
*section
= output_section_statement
->bfd_section
;
3985 if (output_section_statement
!= abs_output_section
)
3987 minfo ("\n%s", output_section_statement
->name
);
3989 if (section
!= NULL
)
3991 print_dot
= section
->vma
;
3993 len
= strlen (output_section_statement
->name
);
3994 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
3999 while (len
< SECTION_NAME_MAP_LENGTH
)
4005 minfo ("0x%V %W", section
->vma
, section
->size
);
4007 if (section
->vma
!= section
->lma
)
4008 minfo (_(" load address 0x%V"), section
->lma
);
4010 if (output_section_statement
->update_dot_tree
!= NULL
)
4011 exp_fold_tree (output_section_statement
->update_dot_tree
,
4012 bfd_abs_section_ptr
, &print_dot
);
4018 print_statement_list (output_section_statement
->children
.head
,
4019 output_section_statement
);
4023 print_assignment (lang_assignment_statement_type
*assignment
,
4024 lang_output_section_statement_type
*output_section
)
4031 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4034 if (assignment
->exp
->type
.node_class
== etree_assert
)
4037 tree
= assignment
->exp
->assert_s
.child
;
4041 const char *dst
= assignment
->exp
->assign
.dst
;
4043 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
4045 expld
.assign_name
= dst
;
4046 tree
= assignment
->exp
->assign
.src
;
4049 osec
= output_section
->bfd_section
;
4051 osec
= bfd_abs_section_ptr
;
4053 if (assignment
->exp
->type
.node_class
!= etree_provide
)
4054 exp_fold_tree (tree
, osec
, &print_dot
);
4056 expld
.result
.valid_p
= FALSE
;
4058 if (expld
.result
.valid_p
)
4062 if (assignment
->exp
->type
.node_class
== etree_assert
4064 || expld
.assign_name
!= NULL
)
4066 value
= expld
.result
.value
;
4068 if (expld
.result
.section
!= NULL
)
4069 value
+= expld
.result
.section
->vma
;
4071 minfo ("0x%V", value
);
4077 struct bfd_link_hash_entry
*h
;
4079 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
4080 FALSE
, FALSE
, TRUE
);
4083 value
= h
->u
.def
.value
;
4084 value
+= h
->u
.def
.section
->output_section
->vma
;
4085 value
+= h
->u
.def
.section
->output_offset
;
4087 minfo ("[0x%V]", value
);
4090 minfo ("[unresolved]");
4095 if (assignment
->exp
->type
.node_class
== etree_provide
)
4096 minfo ("[!provide]");
4103 expld
.assign_name
= NULL
;
4106 exp_print_tree (assignment
->exp
);
4111 print_input_statement (lang_input_statement_type
*statm
)
4113 if (statm
->filename
!= NULL
4114 && (statm
->the_bfd
== NULL
4115 || (statm
->the_bfd
->flags
& BFD_LINKER_CREATED
) == 0))
4116 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
4119 /* Print all symbols defined in a particular section. This is called
4120 via bfd_link_hash_traverse, or by print_all_symbols. */
4123 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
4125 asection
*sec
= (asection
*) ptr
;
4127 if ((hash_entry
->type
== bfd_link_hash_defined
4128 || hash_entry
->type
== bfd_link_hash_defweak
)
4129 && sec
== hash_entry
->u
.def
.section
)
4133 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4136 (hash_entry
->u
.def
.value
4137 + hash_entry
->u
.def
.section
->output_offset
4138 + hash_entry
->u
.def
.section
->output_section
->vma
));
4140 minfo (" %T\n", hash_entry
->root
.string
);
4147 hash_entry_addr_cmp (const void *a
, const void *b
)
4149 const struct bfd_link_hash_entry
*l
= *(const struct bfd_link_hash_entry
**)a
;
4150 const struct bfd_link_hash_entry
*r
= *(const struct bfd_link_hash_entry
**)b
;
4152 if (l
->u
.def
.value
< r
->u
.def
.value
)
4154 else if (l
->u
.def
.value
> r
->u
.def
.value
)
4161 print_all_symbols (asection
*sec
)
4163 input_section_userdata_type
*ud
4164 = (input_section_userdata_type
*) get_userdata (sec
);
4165 struct map_symbol_def
*def
;
4166 struct bfd_link_hash_entry
**entries
;
4172 *ud
->map_symbol_def_tail
= 0;
4174 /* Sort the symbols by address. */
4175 entries
= (struct bfd_link_hash_entry
**)
4176 obstack_alloc (&map_obstack
, ud
->map_symbol_def_count
* sizeof (*entries
));
4178 for (i
= 0, def
= ud
->map_symbol_def_head
; def
; def
= def
->next
, i
++)
4179 entries
[i
] = def
->entry
;
4181 qsort (entries
, ud
->map_symbol_def_count
, sizeof (*entries
),
4182 hash_entry_addr_cmp
);
4184 /* Print the symbols. */
4185 for (i
= 0; i
< ud
->map_symbol_def_count
; i
++)
4186 print_one_symbol (entries
[i
], sec
);
4188 obstack_free (&map_obstack
, entries
);
4191 /* Print information about an input section to the map file. */
4194 print_input_section (asection
*i
, bfd_boolean is_discarded
)
4196 bfd_size_type size
= i
->size
;
4203 minfo ("%s", i
->name
);
4205 len
= 1 + strlen (i
->name
);
4206 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4211 while (len
< SECTION_NAME_MAP_LENGTH
)
4217 if (i
->output_section
!= NULL
4218 && i
->output_section
->owner
== link_info
.output_bfd
)
4219 addr
= i
->output_section
->vma
+ i
->output_offset
;
4227 minfo ("0x%V %W %B\n", addr
, TO_ADDR (size
), i
->owner
);
4229 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
4231 len
= SECTION_NAME_MAP_LENGTH
+ 3;
4243 minfo (_("%W (size before relaxing)\n"), i
->rawsize
);
4246 if (i
->output_section
!= NULL
4247 && i
->output_section
->owner
== link_info
.output_bfd
)
4249 if (link_info
.reduce_memory_overheads
)
4250 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, i
);
4252 print_all_symbols (i
);
4254 /* Update print_dot, but make sure that we do not move it
4255 backwards - this could happen if we have overlays and a
4256 later overlay is shorter than an earier one. */
4257 if (addr
+ TO_ADDR (size
) > print_dot
)
4258 print_dot
= addr
+ TO_ADDR (size
);
4263 print_fill_statement (lang_fill_statement_type
*fill
)
4267 fputs (" FILL mask 0x", config
.map_file
);
4268 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
4269 fprintf (config
.map_file
, "%02x", *p
);
4270 fputs ("\n", config
.map_file
);
4274 print_data_statement (lang_data_statement_type
*data
)
4282 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4285 addr
= data
->output_offset
;
4286 if (data
->output_section
!= NULL
)
4287 addr
+= data
->output_section
->vma
;
4315 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
4317 if (data
->exp
->type
.node_class
!= etree_value
)
4320 exp_print_tree (data
->exp
);
4325 print_dot
= addr
+ TO_ADDR (size
);
4328 /* Print an address statement. These are generated by options like
4332 print_address_statement (lang_address_statement_type
*address
)
4334 minfo (_("Address of section %s set to "), address
->section_name
);
4335 exp_print_tree (address
->address
);
4339 /* Print a reloc statement. */
4342 print_reloc_statement (lang_reloc_statement_type
*reloc
)
4349 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4352 addr
= reloc
->output_offset
;
4353 if (reloc
->output_section
!= NULL
)
4354 addr
+= reloc
->output_section
->vma
;
4356 size
= bfd_get_reloc_size (reloc
->howto
);
4358 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
4360 if (reloc
->name
!= NULL
)
4361 minfo ("%s+", reloc
->name
);
4363 minfo ("%s+", reloc
->section
->name
);
4365 exp_print_tree (reloc
->addend_exp
);
4369 print_dot
= addr
+ TO_ADDR (size
);
4373 print_padding_statement (lang_padding_statement_type
*s
)
4381 len
= sizeof " *fill*" - 1;
4382 while (len
< SECTION_NAME_MAP_LENGTH
)
4388 addr
= s
->output_offset
;
4389 if (s
->output_section
!= NULL
)
4390 addr
+= s
->output_section
->vma
;
4391 minfo ("0x%V %W ", addr
, (bfd_vma
) s
->size
);
4393 if (s
->fill
->size
!= 0)
4397 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
4398 fprintf (config
.map_file
, "%02x", *p
);
4403 print_dot
= addr
+ TO_ADDR (s
->size
);
4407 print_wild_statement (lang_wild_statement_type
*w
,
4408 lang_output_section_statement_type
*os
)
4410 struct wildcard_list
*sec
;
4414 if (w
->filenames_sorted
)
4416 if (w
->filename
!= NULL
)
4417 minfo ("%s", w
->filename
);
4420 if (w
->filenames_sorted
)
4424 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
4426 if (sec
->spec
.sorted
)
4428 if (sec
->spec
.exclude_name_list
!= NULL
)
4431 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
4432 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4433 minfo (" %s", tmp
->name
);
4436 if (sec
->spec
.name
!= NULL
)
4437 minfo ("%s", sec
->spec
.name
);
4440 if (sec
->spec
.sorted
)
4449 print_statement_list (w
->children
.head
, os
);
4452 /* Print a group statement. */
4455 print_group (lang_group_statement_type
*s
,
4456 lang_output_section_statement_type
*os
)
4458 fprintf (config
.map_file
, "START GROUP\n");
4459 print_statement_list (s
->children
.head
, os
);
4460 fprintf (config
.map_file
, "END GROUP\n");
4463 /* Print the list of statements in S.
4464 This can be called for any statement type. */
4467 print_statement_list (lang_statement_union_type
*s
,
4468 lang_output_section_statement_type
*os
)
4472 print_statement (s
, os
);
4477 /* Print the first statement in statement list S.
4478 This can be called for any statement type. */
4481 print_statement (lang_statement_union_type
*s
,
4482 lang_output_section_statement_type
*os
)
4484 switch (s
->header
.type
)
4487 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
4490 case lang_constructors_statement_enum
:
4491 if (constructor_list
.head
!= NULL
)
4493 if (constructors_sorted
)
4494 minfo (" SORT (CONSTRUCTORS)\n");
4496 minfo (" CONSTRUCTORS\n");
4497 print_statement_list (constructor_list
.head
, os
);
4500 case lang_wild_statement_enum
:
4501 print_wild_statement (&s
->wild_statement
, os
);
4503 case lang_address_statement_enum
:
4504 print_address_statement (&s
->address_statement
);
4506 case lang_object_symbols_statement_enum
:
4507 minfo (" CREATE_OBJECT_SYMBOLS\n");
4509 case lang_fill_statement_enum
:
4510 print_fill_statement (&s
->fill_statement
);
4512 case lang_data_statement_enum
:
4513 print_data_statement (&s
->data_statement
);
4515 case lang_reloc_statement_enum
:
4516 print_reloc_statement (&s
->reloc_statement
);
4518 case lang_input_section_enum
:
4519 print_input_section (s
->input_section
.section
, FALSE
);
4521 case lang_padding_statement_enum
:
4522 print_padding_statement (&s
->padding_statement
);
4524 case lang_output_section_statement_enum
:
4525 print_output_section_statement (&s
->output_section_statement
);
4527 case lang_assignment_statement_enum
:
4528 print_assignment (&s
->assignment_statement
, os
);
4530 case lang_target_statement_enum
:
4531 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
4533 case lang_output_statement_enum
:
4534 minfo ("OUTPUT(%s", s
->output_statement
.name
);
4535 if (output_target
!= NULL
)
4536 minfo (" %s", output_target
);
4539 case lang_input_statement_enum
:
4540 print_input_statement (&s
->input_statement
);
4542 case lang_group_statement_enum
:
4543 print_group (&s
->group_statement
, os
);
4545 case lang_insert_statement_enum
:
4546 minfo ("INSERT %s %s\n",
4547 s
->insert_statement
.is_before
? "BEFORE" : "AFTER",
4548 s
->insert_statement
.where
);
4554 print_statements (void)
4556 print_statement_list (statement_list
.head
, abs_output_section
);
4559 /* Print the first N statements in statement list S to STDERR.
4560 If N == 0, nothing is printed.
4561 If N < 0, the entire list is printed.
4562 Intended to be called from GDB. */
4565 dprint_statement (lang_statement_union_type
*s
, int n
)
4567 FILE *map_save
= config
.map_file
;
4569 config
.map_file
= stderr
;
4572 print_statement_list (s
, abs_output_section
);
4575 while (s
&& --n
>= 0)
4577 print_statement (s
, abs_output_section
);
4582 config
.map_file
= map_save
;
4586 insert_pad (lang_statement_union_type
**ptr
,
4588 bfd_size_type alignment_needed
,
4589 asection
*output_section
,
4592 static fill_type zero_fill
;
4593 lang_statement_union_type
*pad
= NULL
;
4595 if (ptr
!= &statement_list
.head
)
4596 pad
= ((lang_statement_union_type
*)
4597 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
4599 && pad
->header
.type
== lang_padding_statement_enum
4600 && pad
->padding_statement
.output_section
== output_section
)
4602 /* Use the existing pad statement. */
4604 else if ((pad
= *ptr
) != NULL
4605 && pad
->header
.type
== lang_padding_statement_enum
4606 && pad
->padding_statement
.output_section
== output_section
)
4608 /* Use the existing pad statement. */
4612 /* Make a new padding statement, linked into existing chain. */
4613 pad
= (lang_statement_union_type
*)
4614 stat_alloc (sizeof (lang_padding_statement_type
));
4615 pad
->header
.next
= *ptr
;
4617 pad
->header
.type
= lang_padding_statement_enum
;
4618 pad
->padding_statement
.output_section
= output_section
;
4621 pad
->padding_statement
.fill
= fill
;
4623 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
4624 pad
->padding_statement
.size
= alignment_needed
;
4625 output_section
->size
= TO_SIZE (dot
+ TO_ADDR (alignment_needed
)
4626 - output_section
->vma
);
4629 /* Work out how much this section will move the dot point. */
4633 (lang_statement_union_type
**this_ptr
,
4634 lang_output_section_statement_type
*output_section_statement
,
4638 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
4639 asection
*i
= is
->section
;
4640 asection
*o
= output_section_statement
->bfd_section
;
4642 if (i
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
4643 i
->output_offset
= i
->vma
- o
->vma
;
4644 else if ((i
->flags
& SEC_EXCLUDE
) != 0)
4645 i
->output_offset
= dot
- o
->vma
;
4648 bfd_size_type alignment_needed
;
4650 /* Align this section first to the input sections requirement,
4651 then to the output section's requirement. If this alignment
4652 is greater than any seen before, then record it too. Perform
4653 the alignment by inserting a magic 'padding' statement. */
4655 if (output_section_statement
->subsection_alignment
!= -1)
4656 i
->alignment_power
= output_section_statement
->subsection_alignment
;
4658 if (o
->alignment_power
< i
->alignment_power
)
4659 o
->alignment_power
= i
->alignment_power
;
4661 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
4663 if (alignment_needed
!= 0)
4665 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
4666 dot
+= alignment_needed
;
4669 /* Remember where in the output section this input section goes. */
4670 i
->output_offset
= dot
- o
->vma
;
4672 /* Mark how big the output section must be to contain this now. */
4673 dot
+= TO_ADDR (i
->size
);
4674 o
->size
= TO_SIZE (dot
- o
->vma
);
4681 sort_sections_by_lma (const void *arg1
, const void *arg2
)
4683 const asection
*sec1
= *(const asection
**) arg1
;
4684 const asection
*sec2
= *(const asection
**) arg2
;
4686 if (bfd_section_lma (sec1
->owner
, sec1
)
4687 < bfd_section_lma (sec2
->owner
, sec2
))
4689 else if (bfd_section_lma (sec1
->owner
, sec1
)
4690 > bfd_section_lma (sec2
->owner
, sec2
))
4692 else if (sec1
->id
< sec2
->id
)
4694 else if (sec1
->id
> sec2
->id
)
4700 #define IGNORE_SECTION(s) \
4701 ((s->flags & SEC_ALLOC) == 0 \
4702 || ((s->flags & SEC_THREAD_LOCAL) != 0 \
4703 && (s->flags & SEC_LOAD) == 0))
4705 /* Check to see if any allocated sections overlap with other allocated
4706 sections. This can happen if a linker script specifies the output
4707 section addresses of the two sections. Also check whether any memory
4708 region has overflowed. */
4711 lang_check_section_addresses (void)
4714 asection
**sections
, **spp
;
4721 lang_memory_region_type
*m
;
4723 if (bfd_count_sections (link_info
.output_bfd
) <= 1)
4726 amt
= bfd_count_sections (link_info
.output_bfd
) * sizeof (asection
*);
4727 sections
= (asection
**) xmalloc (amt
);
4729 /* Scan all sections in the output list. */
4731 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
4733 /* Only consider loadable sections with real contents. */
4734 if (!(s
->flags
& SEC_LOAD
)
4735 || !(s
->flags
& SEC_ALLOC
)
4739 sections
[count
] = s
;
4746 qsort (sections
, (size_t) count
, sizeof (asection
*),
4747 sort_sections_by_lma
);
4752 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
4753 for (count
--; count
; count
--)
4755 /* We must check the sections' LMA addresses not their VMA
4756 addresses because overlay sections can have overlapping VMAs
4757 but they must have distinct LMAs. */
4763 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
4765 /* Look for an overlap. We have sorted sections by lma, so we
4766 know that s_start >= p_start. Besides the obvious case of
4767 overlap when the current section starts before the previous
4768 one ends, we also must have overlap if the previous section
4769 wraps around the address space. */
4770 if (s_start
<= p_end
4772 einfo (_("%X%P: section %s loaded at [%V,%V] overlaps section %s loaded at [%V,%V]\n"),
4773 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
4778 /* If any memory region has overflowed, report by how much.
4779 We do not issue this diagnostic for regions that had sections
4780 explicitly placed outside their bounds; os_region_check's
4781 diagnostics are adequate for that case.
4783 FIXME: It is conceivable that m->current - (m->origin + m->length)
4784 might overflow a 32-bit integer. There is, alas, no way to print
4785 a bfd_vma quantity in decimal. */
4786 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
4787 if (m
->had_full_message
)
4788 einfo (_("%X%P: region `%s' overflowed by %ld bytes\n"),
4789 m
->name_list
.name
, (long)(m
->current
- (m
->origin
+ m
->length
)));
4793 /* Make sure the new address is within the region. We explicitly permit the
4794 current address to be at the exact end of the region when the address is
4795 non-zero, in case the region is at the end of addressable memory and the
4796 calculation wraps around. */
4799 os_region_check (lang_output_section_statement_type
*os
,
4800 lang_memory_region_type
*region
,
4804 if ((region
->current
< region
->origin
4805 || (region
->current
- region
->origin
> region
->length
))
4806 && ((region
->current
!= region
->origin
+ region
->length
)
4811 einfo (_("%X%P: address 0x%v of %B section `%s'"
4812 " is not within region `%s'\n"),
4814 os
->bfd_section
->owner
,
4815 os
->bfd_section
->name
,
4816 region
->name_list
.name
);
4818 else if (!region
->had_full_message
)
4820 region
->had_full_message
= TRUE
;
4822 einfo (_("%X%P: %B section `%s' will not fit in region `%s'\n"),
4823 os
->bfd_section
->owner
,
4824 os
->bfd_section
->name
,
4825 region
->name_list
.name
);
4830 /* Set the sizes for all the output sections. */
4833 lang_size_sections_1
4834 (lang_statement_union_type
**prev
,
4835 lang_output_section_statement_type
*output_section_statement
,
4839 bfd_boolean check_regions
)
4841 lang_statement_union_type
*s
;
4843 /* Size up the sections from their constituent parts. */
4844 for (s
= *prev
; s
!= NULL
; s
= s
->header
.next
)
4846 switch (s
->header
.type
)
4848 case lang_output_section_statement_enum
:
4850 bfd_vma newdot
, after
, dotdelta
;
4851 lang_output_section_statement_type
*os
;
4852 lang_memory_region_type
*r
;
4853 int section_alignment
= 0;
4855 os
= &s
->output_section_statement
;
4856 if (os
->constraint
== -1)
4859 /* FIXME: We shouldn't need to zero section vmas for ld -r
4860 here, in lang_insert_orphan, or in the default linker scripts.
4861 This is covering for coff backend linker bugs. See PR6945. */
4862 if (os
->addr_tree
== NULL
4863 && bfd_link_relocatable (&link_info
)
4864 && (bfd_get_flavour (link_info
.output_bfd
)
4865 == bfd_target_coff_flavour
))
4866 os
->addr_tree
= exp_intop (0);
4867 if (os
->addr_tree
!= NULL
)
4869 os
->processed_vma
= FALSE
;
4870 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
4872 if (expld
.result
.valid_p
)
4874 dot
= expld
.result
.value
;
4875 if (expld
.result
.section
!= NULL
)
4876 dot
+= expld
.result
.section
->vma
;
4878 else if (expld
.phase
!= lang_mark_phase_enum
)
4879 einfo (_("%F%S: non constant or forward reference"
4880 " address expression for section %s\n"),
4881 os
->addr_tree
, os
->name
);
4884 if (os
->bfd_section
== NULL
)
4885 /* This section was removed or never actually created. */
4888 /* If this is a COFF shared library section, use the size and
4889 address from the input section. FIXME: This is COFF
4890 specific; it would be cleaner if there were some other way
4891 to do this, but nothing simple comes to mind. */
4892 if (((bfd_get_flavour (link_info
.output_bfd
)
4893 == bfd_target_ecoff_flavour
)
4894 || (bfd_get_flavour (link_info
.output_bfd
)
4895 == bfd_target_coff_flavour
))
4896 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
4900 if (os
->children
.head
== NULL
4901 || os
->children
.head
->header
.next
!= NULL
4902 || (os
->children
.head
->header
.type
4903 != lang_input_section_enum
))
4904 einfo (_("%P%X: Internal error on COFF shared library"
4905 " section %s\n"), os
->name
);
4907 input
= os
->children
.head
->input_section
.section
;
4908 bfd_set_section_vma (os
->bfd_section
->owner
,
4910 bfd_section_vma (input
->owner
, input
));
4911 os
->bfd_section
->size
= input
->size
;
4917 if (bfd_is_abs_section (os
->bfd_section
))
4919 /* No matter what happens, an abs section starts at zero. */
4920 ASSERT (os
->bfd_section
->vma
== 0);
4924 if (os
->addr_tree
== NULL
)
4926 /* No address specified for this section, get one
4927 from the region specification. */
4928 if (os
->region
== NULL
4929 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
4930 && os
->region
->name_list
.name
[0] == '*'
4931 && strcmp (os
->region
->name_list
.name
,
4932 DEFAULT_MEMORY_REGION
) == 0))
4934 os
->region
= lang_memory_default (os
->bfd_section
);
4937 /* If a loadable section is using the default memory
4938 region, and some non default memory regions were
4939 defined, issue an error message. */
4941 && !IGNORE_SECTION (os
->bfd_section
)
4942 && !bfd_link_relocatable (&link_info
)
4944 && strcmp (os
->region
->name_list
.name
,
4945 DEFAULT_MEMORY_REGION
) == 0
4946 && lang_memory_region_list
!= NULL
4947 && (strcmp (lang_memory_region_list
->name_list
.name
,
4948 DEFAULT_MEMORY_REGION
) != 0
4949 || lang_memory_region_list
->next
!= NULL
)
4950 && expld
.phase
!= lang_mark_phase_enum
)
4952 /* By default this is an error rather than just a
4953 warning because if we allocate the section to the
4954 default memory region we can end up creating an
4955 excessively large binary, or even seg faulting when
4956 attempting to perform a negative seek. See
4957 sources.redhat.com/ml/binutils/2003-04/msg00423.html
4958 for an example of this. This behaviour can be
4959 overridden by the using the --no-check-sections
4961 if (command_line
.check_section_addresses
)
4962 einfo (_("%P%F: error: no memory region specified"
4963 " for loadable section `%s'\n"),
4964 bfd_get_section_name (link_info
.output_bfd
,
4967 einfo (_("%P: warning: no memory region specified"
4968 " for loadable section `%s'\n"),
4969 bfd_get_section_name (link_info
.output_bfd
,
4973 newdot
= os
->region
->current
;
4974 section_alignment
= os
->bfd_section
->alignment_power
;
4977 section_alignment
= os
->section_alignment
;
4979 /* Align to what the section needs. */
4980 if (section_alignment
> 0)
4982 bfd_vma savedot
= newdot
;
4983 newdot
= align_power (newdot
, section_alignment
);
4985 dotdelta
= newdot
- savedot
;
4987 && (config
.warn_section_align
4988 || os
->addr_tree
!= NULL
)
4989 && expld
.phase
!= lang_mark_phase_enum
)
4990 einfo (_("%P: warning: changing start of section"
4991 " %s by %lu bytes\n"),
4992 os
->name
, (unsigned long) dotdelta
);
4995 bfd_set_section_vma (0, os
->bfd_section
, newdot
);
4997 os
->bfd_section
->output_offset
= 0;
5000 lang_size_sections_1 (&os
->children
.head
, os
,
5001 os
->fill
, newdot
, relax
, check_regions
);
5003 os
->processed_vma
= TRUE
;
5005 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5006 /* Except for some special linker created sections,
5007 no output section should change from zero size
5008 after strip_excluded_output_sections. A non-zero
5009 size on an ignored section indicates that some
5010 input section was not sized early enough. */
5011 ASSERT (os
->bfd_section
->size
== 0);
5014 dot
= os
->bfd_section
->vma
;
5016 /* Put the section within the requested block size, or
5017 align at the block boundary. */
5019 + TO_ADDR (os
->bfd_section
->size
)
5020 + os
->block_value
- 1)
5021 & - (bfd_vma
) os
->block_value
);
5023 os
->bfd_section
->size
= TO_SIZE (after
- os
->bfd_section
->vma
);
5026 /* Set section lma. */
5029 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
5033 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
5034 os
->bfd_section
->lma
= lma
;
5036 else if (os
->lma_region
!= NULL
)
5038 bfd_vma lma
= os
->lma_region
->current
;
5040 if (os
->align_lma_with_input
)
5044 /* When LMA_REGION is the same as REGION, align the LMA
5045 as we did for the VMA, possibly including alignment
5046 from the bfd section. If a different region, then
5047 only align according to the value in the output
5049 if (os
->lma_region
!= os
->region
)
5050 section_alignment
= os
->section_alignment
;
5051 if (section_alignment
> 0)
5052 lma
= align_power (lma
, section_alignment
);
5054 os
->bfd_section
->lma
= lma
;
5056 else if (r
->last_os
!= NULL
5057 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5062 last
= r
->last_os
->output_section_statement
.bfd_section
;
5064 /* A backwards move of dot should be accompanied by
5065 an explicit assignment to the section LMA (ie.
5066 os->load_base set) because backwards moves can
5067 create overlapping LMAs. */
5069 && os
->bfd_section
->size
!= 0
5070 && dot
+ os
->bfd_section
->size
<= last
->vma
)
5072 /* If dot moved backwards then leave lma equal to
5073 vma. This is the old default lma, which might
5074 just happen to work when the backwards move is
5075 sufficiently large. Nag if this changes anything,
5076 so people can fix their linker scripts. */
5078 if (last
->vma
!= last
->lma
)
5079 einfo (_("%P: warning: dot moved backwards before `%s'\n"),
5084 /* If this is an overlay, set the current lma to that
5085 at the end of the previous section. */
5086 if (os
->sectype
== overlay_section
)
5087 lma
= last
->lma
+ last
->size
;
5089 /* Otherwise, keep the same lma to vma relationship
5090 as the previous section. */
5092 lma
= dot
+ last
->lma
- last
->vma
;
5094 if (section_alignment
> 0)
5095 lma
= align_power (lma
, section_alignment
);
5096 os
->bfd_section
->lma
= lma
;
5099 os
->processed_lma
= TRUE
;
5101 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5104 /* Keep track of normal sections using the default
5105 lma region. We use this to set the lma for
5106 following sections. Overlays or other linker
5107 script assignment to lma might mean that the
5108 default lma == vma is incorrect.
5109 To avoid warnings about dot moving backwards when using
5110 -Ttext, don't start tracking sections until we find one
5111 of non-zero size or with lma set differently to vma. */
5112 if (((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
5113 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0)
5114 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0
5115 && (os
->bfd_section
->size
!= 0
5116 || (r
->last_os
== NULL
5117 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
5118 || (r
->last_os
!= NULL
5119 && dot
>= (r
->last_os
->output_section_statement
5120 .bfd_section
->vma
)))
5121 && os
->lma_region
== NULL
5122 && !bfd_link_relocatable (&link_info
))
5125 /* .tbss sections effectively have zero size. */
5126 if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
5127 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0
5128 || bfd_link_relocatable (&link_info
))
5129 dotdelta
= TO_ADDR (os
->bfd_section
->size
);
5134 if (os
->update_dot_tree
!= 0)
5135 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5137 /* Update dot in the region ?
5138 We only do this if the section is going to be allocated,
5139 since unallocated sections do not contribute to the region's
5140 overall size in memory. */
5141 if (os
->region
!= NULL
5142 && (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)))
5144 os
->region
->current
= dot
;
5147 /* Make sure the new address is within the region. */
5148 os_region_check (os
, os
->region
, os
->addr_tree
,
5149 os
->bfd_section
->vma
);
5151 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
5152 && ((os
->bfd_section
->flags
& SEC_LOAD
)
5153 || os
->align_lma_with_input
))
5155 os
->lma_region
->current
= os
->bfd_section
->lma
+ dotdelta
;
5158 os_region_check (os
, os
->lma_region
, NULL
,
5159 os
->bfd_section
->lma
);
5165 case lang_constructors_statement_enum
:
5166 dot
= lang_size_sections_1 (&constructor_list
.head
,
5167 output_section_statement
,
5168 fill
, dot
, relax
, check_regions
);
5171 case lang_data_statement_enum
:
5173 unsigned int size
= 0;
5175 s
->data_statement
.output_offset
=
5176 dot
- output_section_statement
->bfd_section
->vma
;
5177 s
->data_statement
.output_section
=
5178 output_section_statement
->bfd_section
;
5180 /* We might refer to provided symbols in the expression, and
5181 need to mark them as needed. */
5182 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5184 switch (s
->data_statement
.type
)
5202 if (size
< TO_SIZE ((unsigned) 1))
5203 size
= TO_SIZE ((unsigned) 1);
5204 dot
+= TO_ADDR (size
);
5205 output_section_statement
->bfd_section
->size
5206 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5211 case lang_reloc_statement_enum
:
5215 s
->reloc_statement
.output_offset
=
5216 dot
- output_section_statement
->bfd_section
->vma
;
5217 s
->reloc_statement
.output_section
=
5218 output_section_statement
->bfd_section
;
5219 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
5220 dot
+= TO_ADDR (size
);
5221 output_section_statement
->bfd_section
->size
5222 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5226 case lang_wild_statement_enum
:
5227 dot
= lang_size_sections_1 (&s
->wild_statement
.children
.head
,
5228 output_section_statement
,
5229 fill
, dot
, relax
, check_regions
);
5232 case lang_object_symbols_statement_enum
:
5233 link_info
.create_object_symbols_section
=
5234 output_section_statement
->bfd_section
;
5237 case lang_output_statement_enum
:
5238 case lang_target_statement_enum
:
5241 case lang_input_section_enum
:
5245 i
= s
->input_section
.section
;
5250 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
5251 einfo (_("%P%F: can't relax section: %E\n"));
5255 dot
= size_input_section (prev
, output_section_statement
,
5260 case lang_input_statement_enum
:
5263 case lang_fill_statement_enum
:
5264 s
->fill_statement
.output_section
=
5265 output_section_statement
->bfd_section
;
5267 fill
= s
->fill_statement
.fill
;
5270 case lang_assignment_statement_enum
:
5272 bfd_vma newdot
= dot
;
5273 etree_type
*tree
= s
->assignment_statement
.exp
;
5275 expld
.dataseg
.relro
= exp_dataseg_relro_none
;
5277 exp_fold_tree (tree
,
5278 output_section_statement
->bfd_section
,
5281 if (expld
.dataseg
.relro
== exp_dataseg_relro_start
)
5283 if (!expld
.dataseg
.relro_start_stat
)
5284 expld
.dataseg
.relro_start_stat
= s
;
5287 ASSERT (expld
.dataseg
.relro_start_stat
== s
);
5290 else if (expld
.dataseg
.relro
== exp_dataseg_relro_end
)
5292 if (!expld
.dataseg
.relro_end_stat
)
5293 expld
.dataseg
.relro_end_stat
= s
;
5296 ASSERT (expld
.dataseg
.relro_end_stat
== s
);
5299 expld
.dataseg
.relro
= exp_dataseg_relro_none
;
5301 /* This symbol may be relative to this section. */
5302 if ((tree
->type
.node_class
== etree_provided
5303 || tree
->type
.node_class
== etree_assign
)
5304 && (tree
->assign
.dst
[0] != '.'
5305 || tree
->assign
.dst
[1] != '\0'))
5306 output_section_statement
->update_dot
= 1;
5308 if (!output_section_statement
->ignored
)
5310 if (output_section_statement
== abs_output_section
)
5312 /* If we don't have an output section, then just adjust
5313 the default memory address. */
5314 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
5315 FALSE
)->current
= newdot
;
5317 else if (newdot
!= dot
)
5319 /* Insert a pad after this statement. We can't
5320 put the pad before when relaxing, in case the
5321 assignment references dot. */
5322 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
5323 output_section_statement
->bfd_section
, dot
);
5325 /* Don't neuter the pad below when relaxing. */
5328 /* If dot is advanced, this implies that the section
5329 should have space allocated to it, unless the
5330 user has explicitly stated that the section
5331 should not be allocated. */
5332 if (output_section_statement
->sectype
!= noalloc_section
5333 && (output_section_statement
->sectype
!= noload_section
5334 || (bfd_get_flavour (link_info
.output_bfd
)
5335 == bfd_target_elf_flavour
)))
5336 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
5343 case lang_padding_statement_enum
:
5344 /* If this is the first time lang_size_sections is called,
5345 we won't have any padding statements. If this is the
5346 second or later passes when relaxing, we should allow
5347 padding to shrink. If padding is needed on this pass, it
5348 will be added back in. */
5349 s
->padding_statement
.size
= 0;
5351 /* Make sure output_offset is valid. If relaxation shrinks
5352 the section and this pad isn't needed, it's possible to
5353 have output_offset larger than the final size of the
5354 section. bfd_set_section_contents will complain even for
5355 a pad size of zero. */
5356 s
->padding_statement
.output_offset
5357 = dot
- output_section_statement
->bfd_section
->vma
;
5360 case lang_group_statement_enum
:
5361 dot
= lang_size_sections_1 (&s
->group_statement
.children
.head
,
5362 output_section_statement
,
5363 fill
, dot
, relax
, check_regions
);
5366 case lang_insert_statement_enum
:
5369 /* We can only get here when relaxing is turned on. */
5370 case lang_address_statement_enum
:
5377 prev
= &s
->header
.next
;
5382 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
5383 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
5384 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
5385 segments. We are allowed an opportunity to override this decision. */
5388 ldlang_override_segment_assignment (struct bfd_link_info
* info ATTRIBUTE_UNUSED
,
5389 bfd
* abfd ATTRIBUTE_UNUSED
,
5390 asection
* current_section
,
5391 asection
* previous_section
,
5392 bfd_boolean new_segment
)
5394 lang_output_section_statement_type
* cur
;
5395 lang_output_section_statement_type
* prev
;
5397 /* The checks below are only necessary when the BFD library has decided
5398 that the two sections ought to be placed into the same segment. */
5402 /* Paranoia checks. */
5403 if (current_section
== NULL
|| previous_section
== NULL
)
5406 /* If this flag is set, the target never wants code and non-code
5407 sections comingled in the same segment. */
5408 if (config
.separate_code
5409 && ((current_section
->flags
^ previous_section
->flags
) & SEC_CODE
))
5412 /* Find the memory regions associated with the two sections.
5413 We call lang_output_section_find() here rather than scanning the list
5414 of output sections looking for a matching section pointer because if
5415 we have a large number of sections then a hash lookup is faster. */
5416 cur
= lang_output_section_find (current_section
->name
);
5417 prev
= lang_output_section_find (previous_section
->name
);
5419 /* More paranoia. */
5420 if (cur
== NULL
|| prev
== NULL
)
5423 /* If the regions are different then force the sections to live in
5424 different segments. See the email thread starting at the following
5425 URL for the reasons why this is necessary:
5426 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
5427 return cur
->region
!= prev
->region
;
5431 one_lang_size_sections_pass (bfd_boolean
*relax
, bfd_boolean check_regions
)
5433 lang_statement_iteration
++;
5434 lang_size_sections_1 (&statement_list
.head
, abs_output_section
,
5435 0, 0, relax
, check_regions
);
5439 lang_size_sections (bfd_boolean
*relax
, bfd_boolean check_regions
)
5441 expld
.phase
= lang_allocating_phase_enum
;
5442 expld
.dataseg
.phase
= exp_dataseg_none
;
5444 one_lang_size_sections_pass (relax
, check_regions
);
5445 if (expld
.dataseg
.phase
== exp_dataseg_end_seen
5446 && link_info
.relro
&& expld
.dataseg
.relro_end
)
5448 bfd_vma initial_base
, relro_end
, desired_end
;
5451 /* Compute the expected PT_GNU_RELRO segment end. */
5452 relro_end
= ((expld
.dataseg
.relro_end
+ expld
.dataseg
.pagesize
- 1)
5453 & ~(expld
.dataseg
.pagesize
- 1));
5455 /* Adjust by the offset arg of DATA_SEGMENT_RELRO_END. */
5456 desired_end
= relro_end
- expld
.dataseg
.relro_offset
;
5458 /* For sections in the relro segment.. */
5459 for (sec
= link_info
.output_bfd
->section_last
; sec
; sec
= sec
->prev
)
5460 if (!IGNORE_SECTION (sec
)
5461 && sec
->vma
>= expld
.dataseg
.base
5462 && sec
->vma
< expld
.dataseg
.relro_end
- expld
.dataseg
.relro_offset
)
5464 /* Where do we want to put this section so that it ends as
5466 bfd_vma start
= sec
->vma
;
5467 bfd_vma end
= start
+ sec
->size
;
5468 bfd_vma bump
= desired_end
- end
;
5469 /* We'd like to increase START by BUMP, but we must heed
5470 alignment so the increase might be less than optimum. */
5471 start
+= bump
& ~(((bfd_vma
) 1 << sec
->alignment_power
) - 1);
5472 /* This is now the desired end for the previous section. */
5473 desired_end
= start
;
5476 expld
.dataseg
.phase
= exp_dataseg_relro_adjust
;
5477 ASSERT (desired_end
>= expld
.dataseg
.base
);
5478 initial_base
= expld
.dataseg
.base
;
5479 expld
.dataseg
.base
= desired_end
;
5480 lang_reset_memory_regions ();
5481 one_lang_size_sections_pass (relax
, check_regions
);
5483 if (expld
.dataseg
.relro_end
> relro_end
)
5485 /* Assignments to dot, or to output section address in a
5486 user script have increased padding over the original.
5488 expld
.dataseg
.base
= initial_base
;
5489 lang_reset_memory_regions ();
5490 one_lang_size_sections_pass (relax
, check_regions
);
5493 link_info
.relro_start
= expld
.dataseg
.base
;
5494 link_info
.relro_end
= expld
.dataseg
.relro_end
;
5496 else if (expld
.dataseg
.phase
== exp_dataseg_end_seen
)
5498 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
5499 a page could be saved in the data segment. */
5500 bfd_vma first
, last
;
5502 first
= -expld
.dataseg
.base
& (expld
.dataseg
.pagesize
- 1);
5503 last
= expld
.dataseg
.end
& (expld
.dataseg
.pagesize
- 1);
5505 && ((expld
.dataseg
.base
& ~(expld
.dataseg
.pagesize
- 1))
5506 != (expld
.dataseg
.end
& ~(expld
.dataseg
.pagesize
- 1)))
5507 && first
+ last
<= expld
.dataseg
.pagesize
)
5509 expld
.dataseg
.phase
= exp_dataseg_adjust
;
5510 lang_reset_memory_regions ();
5511 one_lang_size_sections_pass (relax
, check_regions
);
5514 expld
.dataseg
.phase
= exp_dataseg_done
;
5517 expld
.dataseg
.phase
= exp_dataseg_done
;
5520 static lang_output_section_statement_type
*current_section
;
5521 static lang_assignment_statement_type
*current_assign
;
5522 static bfd_boolean prefer_next_section
;
5524 /* Worker function for lang_do_assignments. Recursiveness goes here. */
5527 lang_do_assignments_1 (lang_statement_union_type
*s
,
5528 lang_output_section_statement_type
*current_os
,
5531 bfd_boolean
*found_end
)
5533 for (; s
!= NULL
; s
= s
->header
.next
)
5535 switch (s
->header
.type
)
5537 case lang_constructors_statement_enum
:
5538 dot
= lang_do_assignments_1 (constructor_list
.head
,
5539 current_os
, fill
, dot
, found_end
);
5542 case lang_output_section_statement_enum
:
5544 lang_output_section_statement_type
*os
;
5546 os
= &(s
->output_section_statement
);
5547 os
->after_end
= *found_end
;
5548 if (os
->bfd_section
!= NULL
&& !os
->ignored
)
5550 if ((os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5552 current_section
= os
;
5553 prefer_next_section
= FALSE
;
5555 dot
= os
->bfd_section
->vma
;
5557 lang_do_assignments_1 (os
->children
.head
,
5558 os
, os
->fill
, dot
, found_end
);
5560 /* .tbss sections effectively have zero size. */
5561 if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
5562 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0
5563 || bfd_link_relocatable (&link_info
))
5564 dot
+= TO_ADDR (os
->bfd_section
->size
);
5566 if (os
->update_dot_tree
!= NULL
)
5567 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5572 case lang_wild_statement_enum
:
5574 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
5575 current_os
, fill
, dot
, found_end
);
5578 case lang_object_symbols_statement_enum
:
5579 case lang_output_statement_enum
:
5580 case lang_target_statement_enum
:
5583 case lang_data_statement_enum
:
5584 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5585 if (expld
.result
.valid_p
)
5587 s
->data_statement
.value
= expld
.result
.value
;
5588 if (expld
.result
.section
!= NULL
)
5589 s
->data_statement
.value
+= expld
.result
.section
->vma
;
5592 einfo (_("%F%P: invalid data statement\n"));
5595 switch (s
->data_statement
.type
)
5613 if (size
< TO_SIZE ((unsigned) 1))
5614 size
= TO_SIZE ((unsigned) 1);
5615 dot
+= TO_ADDR (size
);
5619 case lang_reloc_statement_enum
:
5620 exp_fold_tree (s
->reloc_statement
.addend_exp
,
5621 bfd_abs_section_ptr
, &dot
);
5622 if (expld
.result
.valid_p
)
5623 s
->reloc_statement
.addend_value
= expld
.result
.value
;
5625 einfo (_("%F%P: invalid reloc statement\n"));
5626 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
5629 case lang_input_section_enum
:
5631 asection
*in
= s
->input_section
.section
;
5633 if ((in
->flags
& SEC_EXCLUDE
) == 0)
5634 dot
+= TO_ADDR (in
->size
);
5638 case lang_input_statement_enum
:
5641 case lang_fill_statement_enum
:
5642 fill
= s
->fill_statement
.fill
;
5645 case lang_assignment_statement_enum
:
5646 current_assign
= &s
->assignment_statement
;
5647 if (current_assign
->exp
->type
.node_class
!= etree_assert
)
5649 const char *p
= current_assign
->exp
->assign
.dst
;
5651 if (current_os
== abs_output_section
&& p
[0] == '.' && p
[1] == 0)
5652 prefer_next_section
= TRUE
;
5656 if (strcmp (p
, "end") == 0)
5659 exp_fold_tree (s
->assignment_statement
.exp
,
5660 current_os
->bfd_section
,
5664 case lang_padding_statement_enum
:
5665 dot
+= TO_ADDR (s
->padding_statement
.size
);
5668 case lang_group_statement_enum
:
5669 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
5670 current_os
, fill
, dot
, found_end
);
5673 case lang_insert_statement_enum
:
5676 case lang_address_statement_enum
:
5688 lang_do_assignments (lang_phase_type phase
)
5690 bfd_boolean found_end
= FALSE
;
5692 current_section
= NULL
;
5693 prefer_next_section
= FALSE
;
5694 expld
.phase
= phase
;
5695 lang_statement_iteration
++;
5696 lang_do_assignments_1 (statement_list
.head
,
5697 abs_output_section
, NULL
, 0, &found_end
);
5700 /* For an assignment statement outside of an output section statement,
5701 choose the best of neighbouring output sections to use for values
5705 section_for_dot (void)
5709 /* Assignments belong to the previous output section, unless there
5710 has been an assignment to "dot", in which case following
5711 assignments belong to the next output section. (The assumption
5712 is that an assignment to "dot" is setting up the address for the
5713 next output section.) Except that past the assignment to "_end"
5714 we always associate with the previous section. This exception is
5715 for targets like SH that define an alloc .stack or other
5716 weirdness after non-alloc sections. */
5717 if (current_section
== NULL
|| prefer_next_section
)
5719 lang_statement_union_type
*stmt
;
5720 lang_output_section_statement_type
*os
;
5722 for (stmt
= (lang_statement_union_type
*) current_assign
;
5724 stmt
= stmt
->header
.next
)
5725 if (stmt
->header
.type
== lang_output_section_statement_enum
)
5728 os
= &stmt
->output_section_statement
;
5731 && (os
->bfd_section
== NULL
5732 || (os
->bfd_section
->flags
& SEC_EXCLUDE
) != 0
5733 || bfd_section_removed_from_list (link_info
.output_bfd
,
5737 if (current_section
== NULL
|| os
== NULL
|| !os
->after_end
)
5740 s
= os
->bfd_section
;
5742 s
= link_info
.output_bfd
->section_last
;
5744 && ((s
->flags
& SEC_ALLOC
) == 0
5745 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
5750 return bfd_abs_section_ptr
;
5754 s
= current_section
->bfd_section
;
5756 /* The section may have been stripped. */
5758 && ((s
->flags
& SEC_EXCLUDE
) != 0
5759 || (s
->flags
& SEC_ALLOC
) == 0
5760 || (s
->flags
& SEC_THREAD_LOCAL
) != 0
5761 || bfd_section_removed_from_list (link_info
.output_bfd
, s
)))
5764 s
= link_info
.output_bfd
->sections
;
5766 && ((s
->flags
& SEC_ALLOC
) == 0
5767 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
5772 return bfd_abs_section_ptr
;
5775 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
5776 operator .startof. (section_name), it produces an undefined symbol
5777 .startof.section_name. Similarly, when it sees
5778 .sizeof. (section_name), it produces an undefined symbol
5779 .sizeof.section_name. For all the output sections, we look for
5780 such symbols, and set them to the correct value. */
5783 lang_set_startof (void)
5787 if (bfd_link_relocatable (&link_info
))
5790 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5792 const char *secname
;
5794 struct bfd_link_hash_entry
*h
;
5796 secname
= bfd_get_section_name (link_info
.output_bfd
, s
);
5797 buf
= (char *) xmalloc (10 + strlen (secname
));
5799 sprintf (buf
, ".startof.%s", secname
);
5800 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
5801 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
5803 h
->type
= bfd_link_hash_defined
;
5805 h
->u
.def
.section
= s
;
5808 sprintf (buf
, ".sizeof.%s", secname
);
5809 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
5810 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
5812 h
->type
= bfd_link_hash_defined
;
5813 h
->u
.def
.value
= TO_ADDR (s
->size
);
5814 h
->u
.def
.section
= bfd_abs_section_ptr
;
5824 struct bfd_link_hash_entry
*h
;
5827 if ((bfd_link_relocatable (&link_info
) && !link_info
.gc_sections
)
5828 || bfd_link_dll (&link_info
))
5829 warn
= entry_from_cmdline
;
5833 /* Force the user to specify a root when generating a relocatable with
5835 if (link_info
.gc_sections
&& bfd_link_relocatable (&link_info
)
5836 && !(entry_from_cmdline
|| undef_from_cmdline
))
5837 einfo (_("%P%F: gc-sections requires either an entry or "
5838 "an undefined symbol\n"));
5840 if (entry_symbol
.name
== NULL
)
5842 /* No entry has been specified. Look for the default entry, but
5843 don't warn if we don't find it. */
5844 entry_symbol
.name
= entry_symbol_default
;
5848 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
5849 FALSE
, FALSE
, TRUE
);
5851 && (h
->type
== bfd_link_hash_defined
5852 || h
->type
== bfd_link_hash_defweak
)
5853 && h
->u
.def
.section
->output_section
!= NULL
)
5857 val
= (h
->u
.def
.value
5858 + bfd_get_section_vma (link_info
.output_bfd
,
5859 h
->u
.def
.section
->output_section
)
5860 + h
->u
.def
.section
->output_offset
);
5861 if (! bfd_set_start_address (link_info
.output_bfd
, val
))
5862 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
.name
);
5869 /* We couldn't find the entry symbol. Try parsing it as a
5871 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
5874 if (! bfd_set_start_address (link_info
.output_bfd
, val
))
5875 einfo (_("%P%F: can't set start address\n"));
5881 /* Can't find the entry symbol, and it's not a number. Use
5882 the first address in the text section. */
5883 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
5887 einfo (_("%P: warning: cannot find entry symbol %s;"
5888 " defaulting to %V\n"),
5890 bfd_get_section_vma (link_info
.output_bfd
, ts
));
5891 if (!(bfd_set_start_address
5892 (link_info
.output_bfd
,
5893 bfd_get_section_vma (link_info
.output_bfd
, ts
))))
5894 einfo (_("%P%F: can't set start address\n"));
5899 einfo (_("%P: warning: cannot find entry symbol %s;"
5900 " not setting start address\n"),
5907 /* This is a small function used when we want to ignore errors from
5911 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
5913 /* Don't do anything. */
5916 /* Check that the architecture of all the input files is compatible
5917 with the output file. Also call the backend to let it do any
5918 other checking that is needed. */
5923 lang_statement_union_type
*file
;
5925 const bfd_arch_info_type
*compatible
;
5927 for (file
= file_chain
.head
; file
!= NULL
; file
= file
->input_statement
.next
)
5929 #ifdef ENABLE_PLUGINS
5930 /* Don't check format of files claimed by plugin. */
5931 if (file
->input_statement
.flags
.claimed
)
5933 #endif /* ENABLE_PLUGINS */
5934 input_bfd
= file
->input_statement
.the_bfd
;
5936 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
5937 command_line
.accept_unknown_input_arch
);
5939 /* In general it is not possible to perform a relocatable
5940 link between differing object formats when the input
5941 file has relocations, because the relocations in the
5942 input format may not have equivalent representations in
5943 the output format (and besides BFD does not translate
5944 relocs for other link purposes than a final link). */
5945 if ((bfd_link_relocatable (&link_info
)
5946 || link_info
.emitrelocations
)
5947 && (compatible
== NULL
5948 || (bfd_get_flavour (input_bfd
)
5949 != bfd_get_flavour (link_info
.output_bfd
)))
5950 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
5952 einfo (_("%P%F: Relocatable linking with relocations from"
5953 " format %s (%B) to format %s (%B) is not supported\n"),
5954 bfd_get_target (input_bfd
), input_bfd
,
5955 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
5956 /* einfo with %F exits. */
5959 if (compatible
== NULL
)
5961 if (command_line
.warn_mismatch
)
5962 einfo (_("%P%X: %s architecture of input file `%B'"
5963 " is incompatible with %s output\n"),
5964 bfd_printable_name (input_bfd
), input_bfd
,
5965 bfd_printable_name (link_info
.output_bfd
));
5967 else if (bfd_count_sections (input_bfd
))
5969 /* If the input bfd has no contents, it shouldn't set the
5970 private data of the output bfd. */
5972 bfd_error_handler_type pfn
= NULL
;
5974 /* If we aren't supposed to warn about mismatched input
5975 files, temporarily set the BFD error handler to a
5976 function which will do nothing. We still want to call
5977 bfd_merge_private_bfd_data, since it may set up
5978 information which is needed in the output file. */
5979 if (! command_line
.warn_mismatch
)
5980 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
5981 if (! bfd_merge_private_bfd_data (input_bfd
, link_info
.output_bfd
))
5983 if (command_line
.warn_mismatch
)
5984 einfo (_("%P%X: failed to merge target specific data"
5985 " of file %B\n"), input_bfd
);
5987 if (! command_line
.warn_mismatch
)
5988 bfd_set_error_handler (pfn
);
5993 /* Look through all the global common symbols and attach them to the
5994 correct section. The -sort-common command line switch may be used
5995 to roughly sort the entries by alignment. */
6000 if (command_line
.inhibit_common_definition
)
6002 if (bfd_link_relocatable (&link_info
)
6003 && ! command_line
.force_common_definition
)
6006 if (! config
.sort_common
)
6007 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
6012 if (config
.sort_common
== sort_descending
)
6014 for (power
= 4; power
> 0; power
--)
6015 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6018 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6022 for (power
= 0; power
<= 4; power
++)
6023 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6025 power
= (unsigned int) -1;
6026 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6031 /* Place one common symbol in the correct section. */
6034 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
6036 unsigned int power_of_two
;
6040 if (h
->type
!= bfd_link_hash_common
)
6044 power_of_two
= h
->u
.c
.p
->alignment_power
;
6046 if (config
.sort_common
== sort_descending
6047 && power_of_two
< *(unsigned int *) info
)
6049 else if (config
.sort_common
== sort_ascending
6050 && power_of_two
> *(unsigned int *) info
)
6053 section
= h
->u
.c
.p
->section
;
6054 if (!bfd_define_common_symbol (link_info
.output_bfd
, &link_info
, h
))
6055 einfo (_("%P%F: Could not define common symbol `%T': %E\n"),
6058 if (config
.map_file
!= NULL
)
6060 static bfd_boolean header_printed
;
6065 if (! header_printed
)
6067 minfo (_("\nAllocating common symbols\n"));
6068 minfo (_("Common symbol size file\n\n"));
6069 header_printed
= TRUE
;
6072 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
6073 DMGL_ANSI
| DMGL_PARAMS
);
6076 minfo ("%s", h
->root
.string
);
6077 len
= strlen (h
->root
.string
);
6082 len
= strlen (name
);
6098 if (size
<= 0xffffffff)
6099 sprintf (buf
, "%lx", (unsigned long) size
);
6101 sprintf_vma (buf
, size
);
6111 minfo ("%B\n", section
->owner
);
6117 /* Handle a single orphan section S, placing the orphan into an appropriate
6118 output section. The effects of the --orphan-handling command line
6119 option are handled here. */
6122 ldlang_place_orphan (asection
*s
)
6124 if (config
.orphan_handling
== orphan_handling_discard
)
6126 lang_output_section_statement_type
*os
;
6127 os
= lang_output_section_statement_lookup (DISCARD_SECTION_NAME
, 0,
6129 if (os
->addr_tree
== NULL
6130 && (bfd_link_relocatable (&link_info
)
6131 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6132 os
->addr_tree
= exp_intop (0);
6133 lang_add_section (&os
->children
, s
, NULL
, os
);
6137 lang_output_section_statement_type
*os
;
6138 const char *name
= s
->name
;
6141 if (config
.orphan_handling
== orphan_handling_error
)
6142 einfo ("%X%P: error: unplaced orphan section `%A' from `%B'.\n",
6145 if (config
.unique_orphan_sections
|| unique_section_p (s
, NULL
))
6146 constraint
= SPECIAL
;
6148 os
= ldemul_place_orphan (s
, name
, constraint
);
6151 os
= lang_output_section_statement_lookup (name
, constraint
, TRUE
);
6152 if (os
->addr_tree
== NULL
6153 && (bfd_link_relocatable (&link_info
)
6154 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6155 os
->addr_tree
= exp_intop (0);
6156 lang_add_section (&os
->children
, s
, NULL
, os
);
6159 if (config
.orphan_handling
== orphan_handling_warn
)
6160 einfo ("%P: warning: orphan section `%A' from `%B' being "
6161 "placed in section `%s'.\n",
6162 s
, s
->owner
, os
->name
);
6166 /* Run through the input files and ensure that every input section has
6167 somewhere to go. If one is found without a destination then create
6168 an input request and place it into the statement tree. */
6171 lang_place_orphans (void)
6173 LANG_FOR_EACH_INPUT_STATEMENT (file
)
6177 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6179 if (s
->output_section
== NULL
)
6181 /* This section of the file is not attached, root
6182 around for a sensible place for it to go. */
6184 if (file
->flags
.just_syms
)
6185 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
6186 else if ((s
->flags
& SEC_EXCLUDE
) != 0)
6187 s
->output_section
= bfd_abs_section_ptr
;
6188 else if (strcmp (s
->name
, "COMMON") == 0)
6190 /* This is a lonely common section which must have
6191 come from an archive. We attach to the section
6192 with the wildcard. */
6193 if (!bfd_link_relocatable (&link_info
)
6194 || command_line
.force_common_definition
)
6196 if (default_common_section
== NULL
)
6197 default_common_section
6198 = lang_output_section_statement_lookup (".bss", 0,
6200 lang_add_section (&default_common_section
->children
, s
,
6201 NULL
, default_common_section
);
6205 ldlang_place_orphan (s
);
6212 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
6214 flagword
*ptr_flags
;
6216 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
6222 /* PR 17900: An exclamation mark in the attributes reverses
6223 the sense of any of the attributes that follow. */
6226 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
6230 *ptr_flags
|= SEC_ALLOC
;
6234 *ptr_flags
|= SEC_READONLY
;
6238 *ptr_flags
|= SEC_DATA
;
6242 *ptr_flags
|= SEC_CODE
;
6247 *ptr_flags
|= SEC_LOAD
;
6251 einfo (_("%P%F: invalid character %c (%d) in flags\n"), * flags
, * flags
);
6258 /* Call a function on each input file. This function will be called
6259 on an archive, but not on the elements. */
6262 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
6264 lang_input_statement_type
*f
;
6266 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
6268 f
= (lang_input_statement_type
*) f
->next_real_file
)
6272 /* Call a function on each file. The function will be called on all
6273 the elements of an archive which are included in the link, but will
6274 not be called on the archive file itself. */
6277 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
6279 LANG_FOR_EACH_INPUT_STATEMENT (f
)
6286 ldlang_add_file (lang_input_statement_type
*entry
)
6288 lang_statement_append (&file_chain
,
6289 (lang_statement_union_type
*) entry
,
6292 /* The BFD linker needs to have a list of all input BFDs involved in
6294 ASSERT (entry
->the_bfd
->link
.next
== NULL
);
6295 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
6297 *link_info
.input_bfds_tail
= entry
->the_bfd
;
6298 link_info
.input_bfds_tail
= &entry
->the_bfd
->link
.next
;
6299 entry
->the_bfd
->usrdata
= entry
;
6300 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
6302 /* Look through the sections and check for any which should not be
6303 included in the link. We need to do this now, so that we can
6304 notice when the backend linker tries to report multiple
6305 definition errors for symbols which are in sections we aren't
6306 going to link. FIXME: It might be better to entirely ignore
6307 symbols which are defined in sections which are going to be
6308 discarded. This would require modifying the backend linker for
6309 each backend which might set the SEC_LINK_ONCE flag. If we do
6310 this, we should probably handle SEC_EXCLUDE in the same way. */
6312 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
6316 lang_add_output (const char *name
, int from_script
)
6318 /* Make -o on command line override OUTPUT in script. */
6319 if (!had_output_filename
|| !from_script
)
6321 output_filename
= name
;
6322 had_output_filename
= TRUE
;
6335 for (l
= 0; l
< 32; l
++)
6337 if (i
>= (unsigned int) x
)
6345 lang_output_section_statement_type
*
6346 lang_enter_output_section_statement (const char *output_section_statement_name
,
6347 etree_type
*address_exp
,
6348 enum section_type sectype
,
6350 etree_type
*subalign
,
6353 int align_with_input
)
6355 lang_output_section_statement_type
*os
;
6357 os
= lang_output_section_statement_lookup (output_section_statement_name
,
6359 current_section
= os
;
6361 if (os
->addr_tree
== NULL
)
6363 os
->addr_tree
= address_exp
;
6365 os
->sectype
= sectype
;
6366 if (sectype
!= noload_section
)
6367 os
->flags
= SEC_NO_FLAGS
;
6369 os
->flags
= SEC_NEVER_LOAD
;
6370 os
->block_value
= 1;
6372 /* Make next things chain into subchain of this. */
6373 push_stat_ptr (&os
->children
);
6375 os
->align_lma_with_input
= align_with_input
== ALIGN_WITH_INPUT
;
6376 if (os
->align_lma_with_input
&& align
!= NULL
)
6377 einfo (_("%F%P:%S: error: align with input and explicit align specified\n"), NULL
);
6379 os
->subsection_alignment
=
6380 topower (exp_get_value_int (subalign
, -1, "subsection alignment"));
6381 os
->section_alignment
=
6382 topower (exp_get_value_int (align
, -1, "section alignment"));
6384 os
->load_base
= ebase
;
6391 lang_output_statement_type
*new_stmt
;
6393 new_stmt
= new_stat (lang_output_statement
, stat_ptr
);
6394 new_stmt
->name
= output_filename
;
6397 /* Reset the current counters in the regions. */
6400 lang_reset_memory_regions (void)
6402 lang_memory_region_type
*p
= lang_memory_region_list
;
6404 lang_output_section_statement_type
*os
;
6406 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
6408 p
->current
= p
->origin
;
6412 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
6416 os
->processed_vma
= FALSE
;
6417 os
->processed_lma
= FALSE
;
6420 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6422 /* Save the last size for possible use by bfd_relax_section. */
6423 o
->rawsize
= o
->size
;
6428 /* Worker for lang_gc_sections_1. */
6431 gc_section_callback (lang_wild_statement_type
*ptr
,
6432 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
6434 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
6435 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
6436 void *data ATTRIBUTE_UNUSED
)
6438 /* If the wild pattern was marked KEEP, the member sections
6439 should be as well. */
6440 if (ptr
->keep_sections
)
6441 section
->flags
|= SEC_KEEP
;
6444 /* Iterate over sections marking them against GC. */
6447 lang_gc_sections_1 (lang_statement_union_type
*s
)
6449 for (; s
!= NULL
; s
= s
->header
.next
)
6451 switch (s
->header
.type
)
6453 case lang_wild_statement_enum
:
6454 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
6456 case lang_constructors_statement_enum
:
6457 lang_gc_sections_1 (constructor_list
.head
);
6459 case lang_output_section_statement_enum
:
6460 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
6462 case lang_group_statement_enum
:
6463 lang_gc_sections_1 (s
->group_statement
.children
.head
);
6472 lang_gc_sections (void)
6474 /* Keep all sections so marked in the link script. */
6476 lang_gc_sections_1 (statement_list
.head
);
6478 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
6479 the special case of debug info. (See bfd/stabs.c)
6480 Twiddle the flag here, to simplify later linker code. */
6481 if (bfd_link_relocatable (&link_info
))
6483 LANG_FOR_EACH_INPUT_STATEMENT (f
)
6486 #ifdef ENABLE_PLUGINS
6487 if (f
->flags
.claimed
)
6490 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6491 if ((sec
->flags
& SEC_DEBUGGING
) == 0)
6492 sec
->flags
&= ~SEC_EXCLUDE
;
6496 if (link_info
.gc_sections
)
6497 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
6500 /* Worker for lang_find_relro_sections_1. */
6503 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
6504 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
6506 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
6507 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
6510 /* Discarded, excluded and ignored sections effectively have zero
6512 if (section
->output_section
!= NULL
6513 && section
->output_section
->owner
== link_info
.output_bfd
6514 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
6515 && !IGNORE_SECTION (section
)
6516 && section
->size
!= 0)
6518 bfd_boolean
*has_relro_section
= (bfd_boolean
*) data
;
6519 *has_relro_section
= TRUE
;
6523 /* Iterate over sections for relro sections. */
6526 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
6527 bfd_boolean
*has_relro_section
)
6529 if (*has_relro_section
)
6532 for (; s
!= NULL
; s
= s
->header
.next
)
6534 if (s
== expld
.dataseg
.relro_end_stat
)
6537 switch (s
->header
.type
)
6539 case lang_wild_statement_enum
:
6540 walk_wild (&s
->wild_statement
,
6541 find_relro_section_callback
,
6544 case lang_constructors_statement_enum
:
6545 lang_find_relro_sections_1 (constructor_list
.head
,
6548 case lang_output_section_statement_enum
:
6549 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
6552 case lang_group_statement_enum
:
6553 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
6563 lang_find_relro_sections (void)
6565 bfd_boolean has_relro_section
= FALSE
;
6567 /* Check all sections in the link script. */
6569 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
6570 &has_relro_section
);
6572 if (!has_relro_section
)
6573 link_info
.relro
= FALSE
;
6576 /* Relax all sections until bfd_relax_section gives up. */
6579 lang_relax_sections (bfd_boolean need_layout
)
6581 if (RELAXATION_ENABLED
)
6583 /* We may need more than one relaxation pass. */
6584 int i
= link_info
.relax_pass
;
6586 /* The backend can use it to determine the current pass. */
6587 link_info
.relax_pass
= 0;
6591 /* Keep relaxing until bfd_relax_section gives up. */
6592 bfd_boolean relax_again
;
6594 link_info
.relax_trip
= -1;
6597 link_info
.relax_trip
++;
6599 /* Note: pe-dll.c does something like this also. If you find
6600 you need to change this code, you probably need to change
6601 pe-dll.c also. DJ */
6603 /* Do all the assignments with our current guesses as to
6605 lang_do_assignments (lang_assigning_phase_enum
);
6607 /* We must do this after lang_do_assignments, because it uses
6609 lang_reset_memory_regions ();
6611 /* Perform another relax pass - this time we know where the
6612 globals are, so can make a better guess. */
6613 relax_again
= FALSE
;
6614 lang_size_sections (&relax_again
, FALSE
);
6616 while (relax_again
);
6618 link_info
.relax_pass
++;
6625 /* Final extra sizing to report errors. */
6626 lang_do_assignments (lang_assigning_phase_enum
);
6627 lang_reset_memory_regions ();
6628 lang_size_sections (NULL
, TRUE
);
6632 #ifdef ENABLE_PLUGINS
6633 /* Find the insert point for the plugin's replacement files. We
6634 place them after the first claimed real object file, or if the
6635 first claimed object is an archive member, after the last real
6636 object file immediately preceding the archive. In the event
6637 no objects have been claimed at all, we return the first dummy
6638 object file on the list as the insert point; that works, but
6639 the callee must be careful when relinking the file_chain as it
6640 is not actually on that chain, only the statement_list and the
6641 input_file list; in that case, the replacement files must be
6642 inserted at the head of the file_chain. */
6644 static lang_input_statement_type
*
6645 find_replacements_insert_point (void)
6647 lang_input_statement_type
*claim1
, *lastobject
;
6648 lastobject
= &input_file_chain
.head
->input_statement
;
6649 for (claim1
= &file_chain
.head
->input_statement
;
6651 claim1
= &claim1
->next
->input_statement
)
6653 if (claim1
->flags
.claimed
)
6654 return claim1
->flags
.claim_archive
? lastobject
: claim1
;
6655 /* Update lastobject if this is a real object file. */
6656 if (claim1
->the_bfd
&& (claim1
->the_bfd
->my_archive
== NULL
))
6657 lastobject
= claim1
;
6659 /* No files were claimed by the plugin. Choose the last object
6660 file found on the list (maybe the first, dummy entry) as the
6665 /* Insert SRCLIST into DESTLIST after given element by chaining
6666 on FIELD as the next-pointer. (Counterintuitively does not need
6667 a pointer to the actual after-node itself, just its chain field.) */
6670 lang_list_insert_after (lang_statement_list_type
*destlist
,
6671 lang_statement_list_type
*srclist
,
6672 lang_statement_union_type
**field
)
6674 *(srclist
->tail
) = *field
;
6675 *field
= srclist
->head
;
6676 if (destlist
->tail
== field
)
6677 destlist
->tail
= srclist
->tail
;
6680 /* Detach new nodes added to DESTLIST since the time ORIGLIST
6681 was taken as a copy of it and leave them in ORIGLIST. */
6684 lang_list_remove_tail (lang_statement_list_type
*destlist
,
6685 lang_statement_list_type
*origlist
)
6687 union lang_statement_union
**savetail
;
6688 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
6689 ASSERT (origlist
->head
== destlist
->head
);
6690 savetail
= origlist
->tail
;
6691 origlist
->head
= *(savetail
);
6692 origlist
->tail
= destlist
->tail
;
6693 destlist
->tail
= savetail
;
6696 #endif /* ENABLE_PLUGINS */
6701 /* Finalize dynamic list. */
6702 if (link_info
.dynamic_list
)
6703 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
6705 current_target
= default_target
;
6707 /* Open the output file. */
6708 lang_for_each_statement (ldlang_open_output
);
6711 ldemul_create_output_section_statements ();
6713 /* Add to the hash table all undefineds on the command line. */
6714 lang_place_undefineds ();
6716 if (!bfd_section_already_linked_table_init ())
6717 einfo (_("%P%F: Failed to create hash table\n"));
6719 /* Create a bfd for each input file. */
6720 current_target
= default_target
;
6721 open_input_bfds (statement_list
.head
, OPEN_BFD_NORMAL
);
6723 #ifdef ENABLE_PLUGINS
6724 if (link_info
.lto_plugin_active
)
6726 lang_statement_list_type added
;
6727 lang_statement_list_type files
, inputfiles
;
6729 /* Now all files are read, let the plugin(s) decide if there
6730 are any more to be added to the link before we call the
6731 emulation's after_open hook. We create a private list of
6732 input statements for this purpose, which we will eventually
6733 insert into the global statment list after the first claimed
6736 /* We need to manipulate all three chains in synchrony. */
6738 inputfiles
= input_file_chain
;
6739 if (plugin_call_all_symbols_read ())
6740 einfo (_("%P%F: %s: plugin reported error after all symbols read\n"),
6741 plugin_error_plugin ());
6742 /* Open any newly added files, updating the file chains. */
6743 open_input_bfds (*added
.tail
, OPEN_BFD_NORMAL
);
6744 /* Restore the global list pointer now they have all been added. */
6745 lang_list_remove_tail (stat_ptr
, &added
);
6746 /* And detach the fresh ends of the file lists. */
6747 lang_list_remove_tail (&file_chain
, &files
);
6748 lang_list_remove_tail (&input_file_chain
, &inputfiles
);
6749 /* Were any new files added? */
6750 if (added
.head
!= NULL
)
6752 /* If so, we will insert them into the statement list immediately
6753 after the first input file that was claimed by the plugin. */
6754 plugin_insert
= find_replacements_insert_point ();
6755 /* If a plugin adds input files without having claimed any, we
6756 don't really have a good idea where to place them. Just putting
6757 them at the start or end of the list is liable to leave them
6758 outside the crtbegin...crtend range. */
6759 ASSERT (plugin_insert
!= NULL
);
6760 /* Splice the new statement list into the old one. */
6761 lang_list_insert_after (stat_ptr
, &added
,
6762 &plugin_insert
->header
.next
);
6763 /* Likewise for the file chains. */
6764 lang_list_insert_after (&input_file_chain
, &inputfiles
,
6765 &plugin_insert
->next_real_file
);
6766 /* We must be careful when relinking file_chain; we may need to
6767 insert the new files at the head of the list if the insert
6768 point chosen is the dummy first input file. */
6769 if (plugin_insert
->filename
)
6770 lang_list_insert_after (&file_chain
, &files
, &plugin_insert
->next
);
6772 lang_list_insert_after (&file_chain
, &files
, &file_chain
.head
);
6774 /* Rescan archives in case new undefined symbols have appeared. */
6775 open_input_bfds (statement_list
.head
, OPEN_BFD_RESCAN
);
6778 #endif /* ENABLE_PLUGINS */
6780 link_info
.gc_sym_list
= &entry_symbol
;
6781 if (entry_symbol
.name
== NULL
)
6782 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
6783 if (link_info
.init_function
!= NULL
)
6785 struct bfd_sym_chain
*sym
6786 = (struct bfd_sym_chain
*) stat_alloc (sizeof (*sym
));
6787 sym
->next
= link_info
.gc_sym_list
;
6788 sym
->name
= link_info
.init_function
;
6789 link_info
.gc_sym_list
= sym
;
6791 if (link_info
.fini_function
!= NULL
)
6793 struct bfd_sym_chain
*sym
6794 = (struct bfd_sym_chain
*) stat_alloc (sizeof (*sym
));
6795 sym
->next
= link_info
.gc_sym_list
;
6796 sym
->name
= link_info
.fini_function
;
6797 link_info
.gc_sym_list
= sym
;
6800 ldemul_after_open ();
6801 if (config
.map_file
!= NULL
)
6802 lang_print_asneeded ();
6804 bfd_section_already_linked_table_free ();
6806 /* Make sure that we're not mixing architectures. We call this
6807 after all the input files have been opened, but before we do any
6808 other processing, so that any operations merge_private_bfd_data
6809 does on the output file will be known during the rest of the
6813 /* Handle .exports instead of a version script if we're told to do so. */
6814 if (command_line
.version_exports_section
)
6815 lang_do_version_exports_section ();
6817 /* Build all sets based on the information gathered from the input
6819 ldctor_build_sets ();
6821 /* PR 13683: We must rerun the assignments prior to running garbage
6822 collection in order to make sure that all symbol aliases are resolved. */
6823 lang_do_assignments (lang_mark_phase_enum
);
6825 lang_do_memory_regions();
6826 expld
.phase
= lang_first_phase_enum
;
6828 /* Size up the common data. */
6831 /* Remove unreferenced sections if asked to. */
6832 lang_gc_sections ();
6834 /* Update wild statements. */
6835 update_wild_statements (statement_list
.head
);
6837 /* Run through the contours of the script and attach input sections
6838 to the correct output sections. */
6839 lang_statement_iteration
++;
6840 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
6842 process_insert_statements ();
6844 /* Find any sections not attached explicitly and handle them. */
6845 lang_place_orphans ();
6847 if (!bfd_link_relocatable (&link_info
))
6851 /* Merge SEC_MERGE sections. This has to be done after GC of
6852 sections, so that GCed sections are not merged, but before
6853 assigning dynamic symbols, since removing whole input sections
6855 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
6857 /* Look for a text section and set the readonly attribute in it. */
6858 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
6862 if (config
.text_read_only
)
6863 found
->flags
|= SEC_READONLY
;
6865 found
->flags
&= ~SEC_READONLY
;
6869 /* Do anything special before sizing sections. This is where ELF
6870 and other back-ends size dynamic sections. */
6871 ldemul_before_allocation ();
6873 /* We must record the program headers before we try to fix the
6874 section positions, since they will affect SIZEOF_HEADERS. */
6875 lang_record_phdrs ();
6877 /* Check relro sections. */
6878 if (link_info
.relro
&& !bfd_link_relocatable (&link_info
))
6879 lang_find_relro_sections ();
6881 /* Size up the sections. */
6882 lang_size_sections (NULL
, ! RELAXATION_ENABLED
);
6884 /* See if anything special should be done now we know how big
6885 everything is. This is where relaxation is done. */
6886 ldemul_after_allocation ();
6888 /* Fix any .startof. or .sizeof. symbols. */
6889 lang_set_startof ();
6891 /* Do all the assignments, now that we know the final resting places
6892 of all the symbols. */
6893 lang_do_assignments (lang_final_phase_enum
);
6897 /* Convert absolute symbols to section relative. */
6898 ldexp_finalize_syms ();
6900 /* Make sure that the section addresses make sense. */
6901 if (command_line
.check_section_addresses
)
6902 lang_check_section_addresses ();
6904 /* Check any required symbols are known. */
6905 ldlang_check_require_defined_symbols ();
6910 /* EXPORTED TO YACC */
6913 lang_add_wild (struct wildcard_spec
*filespec
,
6914 struct wildcard_list
*section_list
,
6915 bfd_boolean keep_sections
)
6917 struct wildcard_list
*curr
, *next
;
6918 lang_wild_statement_type
*new_stmt
;
6920 /* Reverse the list as the parser puts it back to front. */
6921 for (curr
= section_list
, section_list
= NULL
;
6923 section_list
= curr
, curr
= next
)
6925 if (curr
->spec
.name
!= NULL
&& strcmp (curr
->spec
.name
, "COMMON") == 0)
6926 placed_commons
= TRUE
;
6929 curr
->next
= section_list
;
6932 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
6934 if (strcmp (filespec
->name
, "*") == 0)
6935 filespec
->name
= NULL
;
6936 else if (! wildcardp (filespec
->name
))
6937 lang_has_input_file
= TRUE
;
6940 new_stmt
= new_stat (lang_wild_statement
, stat_ptr
);
6941 new_stmt
->filename
= NULL
;
6942 new_stmt
->filenames_sorted
= FALSE
;
6943 new_stmt
->section_flag_list
= NULL
;
6944 if (filespec
!= NULL
)
6946 new_stmt
->filename
= filespec
->name
;
6947 new_stmt
->filenames_sorted
= filespec
->sorted
== by_name
;
6948 new_stmt
->section_flag_list
= filespec
->section_flag_list
;
6950 new_stmt
->section_list
= section_list
;
6951 new_stmt
->keep_sections
= keep_sections
;
6952 lang_list_init (&new_stmt
->children
);
6953 analyze_walk_wild_section_handler (new_stmt
);
6957 lang_section_start (const char *name
, etree_type
*address
,
6958 const segment_type
*segment
)
6960 lang_address_statement_type
*ad
;
6962 ad
= new_stat (lang_address_statement
, stat_ptr
);
6963 ad
->section_name
= name
;
6964 ad
->address
= address
;
6965 ad
->segment
= segment
;
6968 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
6969 because of a -e argument on the command line, or zero if this is
6970 called by ENTRY in a linker script. Command line arguments take
6974 lang_add_entry (const char *name
, bfd_boolean cmdline
)
6976 if (entry_symbol
.name
== NULL
6978 || ! entry_from_cmdline
)
6980 entry_symbol
.name
= name
;
6981 entry_from_cmdline
= cmdline
;
6985 /* Set the default start symbol to NAME. .em files should use this,
6986 not lang_add_entry, to override the use of "start" if neither the
6987 linker script nor the command line specifies an entry point. NAME
6988 must be permanently allocated. */
6990 lang_default_entry (const char *name
)
6992 entry_symbol_default
= name
;
6996 lang_add_target (const char *name
)
6998 lang_target_statement_type
*new_stmt
;
7000 new_stmt
= new_stat (lang_target_statement
, stat_ptr
);
7001 new_stmt
->target
= name
;
7005 lang_add_map (const char *name
)
7012 map_option_f
= TRUE
;
7020 lang_add_fill (fill_type
*fill
)
7022 lang_fill_statement_type
*new_stmt
;
7024 new_stmt
= new_stat (lang_fill_statement
, stat_ptr
);
7025 new_stmt
->fill
= fill
;
7029 lang_add_data (int type
, union etree_union
*exp
)
7031 lang_data_statement_type
*new_stmt
;
7033 new_stmt
= new_stat (lang_data_statement
, stat_ptr
);
7034 new_stmt
->exp
= exp
;
7035 new_stmt
->type
= type
;
7038 /* Create a new reloc statement. RELOC is the BFD relocation type to
7039 generate. HOWTO is the corresponding howto structure (we could
7040 look this up, but the caller has already done so). SECTION is the
7041 section to generate a reloc against, or NAME is the name of the
7042 symbol to generate a reloc against. Exactly one of SECTION and
7043 NAME must be NULL. ADDEND is an expression for the addend. */
7046 lang_add_reloc (bfd_reloc_code_real_type reloc
,
7047 reloc_howto_type
*howto
,
7050 union etree_union
*addend
)
7052 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
7056 p
->section
= section
;
7058 p
->addend_exp
= addend
;
7060 p
->addend_value
= 0;
7061 p
->output_section
= NULL
;
7062 p
->output_offset
= 0;
7065 lang_assignment_statement_type
*
7066 lang_add_assignment (etree_type
*exp
)
7068 lang_assignment_statement_type
*new_stmt
;
7070 new_stmt
= new_stat (lang_assignment_statement
, stat_ptr
);
7071 new_stmt
->exp
= exp
;
7076 lang_add_attribute (enum statement_enum attribute
)
7078 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
7082 lang_startup (const char *name
)
7084 if (first_file
->filename
!= NULL
)
7086 einfo (_("%P%F: multiple STARTUP files\n"));
7088 first_file
->filename
= name
;
7089 first_file
->local_sym_name
= name
;
7090 first_file
->flags
.real
= TRUE
;
7094 lang_float (bfd_boolean maybe
)
7096 lang_float_flag
= maybe
;
7100 /* Work out the load- and run-time regions from a script statement, and
7101 store them in *LMA_REGION and *REGION respectively.
7103 MEMSPEC is the name of the run-time region, or the value of
7104 DEFAULT_MEMORY_REGION if the statement didn't specify one.
7105 LMA_MEMSPEC is the name of the load-time region, or null if the
7106 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
7107 had an explicit load address.
7109 It is an error to specify both a load region and a load address. */
7112 lang_get_regions (lang_memory_region_type
**region
,
7113 lang_memory_region_type
**lma_region
,
7114 const char *memspec
,
7115 const char *lma_memspec
,
7116 bfd_boolean have_lma
,
7117 bfd_boolean have_vma
)
7119 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
7121 /* If no runtime region or VMA has been specified, but the load region
7122 has been specified, then use the load region for the runtime region
7124 if (lma_memspec
!= NULL
7126 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
7127 *region
= *lma_region
;
7129 *region
= lang_memory_region_lookup (memspec
, FALSE
);
7131 if (have_lma
&& lma_memspec
!= 0)
7132 einfo (_("%X%P:%S: section has both a load address and a load region\n"),
7137 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
7138 lang_output_section_phdr_list
*phdrs
,
7139 const char *lma_memspec
)
7141 lang_get_regions (¤t_section
->region
,
7142 ¤t_section
->lma_region
,
7143 memspec
, lma_memspec
,
7144 current_section
->load_base
!= NULL
,
7145 current_section
->addr_tree
!= NULL
);
7147 /* If this section has no load region or base, but uses the same
7148 region as the previous section, then propagate the previous
7149 section's load region. */
7151 if (current_section
->lma_region
== NULL
7152 && current_section
->load_base
== NULL
7153 && current_section
->addr_tree
== NULL
7154 && current_section
->region
== current_section
->prev
->region
)
7155 current_section
->lma_region
= current_section
->prev
->lma_region
;
7157 current_section
->fill
= fill
;
7158 current_section
->phdrs
= phdrs
;
7163 lang_statement_append (lang_statement_list_type
*list
,
7164 lang_statement_union_type
*element
,
7165 lang_statement_union_type
**field
)
7167 *(list
->tail
) = element
;
7171 /* Set the output format type. -oformat overrides scripts. */
7174 lang_add_output_format (const char *format
,
7179 if (output_target
== NULL
|| !from_script
)
7181 if (command_line
.endian
== ENDIAN_BIG
7184 else if (command_line
.endian
== ENDIAN_LITTLE
7188 output_target
= format
;
7193 lang_add_insert (const char *where
, int is_before
)
7195 lang_insert_statement_type
*new_stmt
;
7197 new_stmt
= new_stat (lang_insert_statement
, stat_ptr
);
7198 new_stmt
->where
= where
;
7199 new_stmt
->is_before
= is_before
;
7200 saved_script_handle
= previous_script_handle
;
7203 /* Enter a group. This creates a new lang_group_statement, and sets
7204 stat_ptr to build new statements within the group. */
7207 lang_enter_group (void)
7209 lang_group_statement_type
*g
;
7211 g
= new_stat (lang_group_statement
, stat_ptr
);
7212 lang_list_init (&g
->children
);
7213 push_stat_ptr (&g
->children
);
7216 /* Leave a group. This just resets stat_ptr to start writing to the
7217 regular list of statements again. Note that this will not work if
7218 groups can occur inside anything else which can adjust stat_ptr,
7219 but currently they can't. */
7222 lang_leave_group (void)
7227 /* Add a new program header. This is called for each entry in a PHDRS
7228 command in a linker script. */
7231 lang_new_phdr (const char *name
,
7233 bfd_boolean filehdr
,
7238 struct lang_phdr
*n
, **pp
;
7241 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
7244 n
->type
= exp_get_value_int (type
, 0, "program header type");
7245 n
->filehdr
= filehdr
;
7250 hdrs
= n
->type
== 1 && (phdrs
|| filehdr
);
7252 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
7255 && !((*pp
)->filehdr
|| (*pp
)->phdrs
))
7257 einfo (_("%X%P:%S: PHDRS and FILEHDR are not supported"
7258 " when prior PT_LOAD headers lack them\n"), NULL
);
7265 /* Record the program header information in the output BFD. FIXME: We
7266 should not be calling an ELF specific function here. */
7269 lang_record_phdrs (void)
7273 lang_output_section_phdr_list
*last
;
7274 struct lang_phdr
*l
;
7275 lang_output_section_statement_type
*os
;
7278 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
7281 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
7288 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
7292 lang_output_section_phdr_list
*pl
;
7294 if (os
->constraint
< 0)
7302 if (os
->sectype
== noload_section
7303 || os
->bfd_section
== NULL
7304 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
7307 /* Don't add orphans to PT_INTERP header. */
7313 lang_output_section_statement_type
* tmp_os
;
7315 /* If we have not run across a section with a program
7316 header assigned to it yet, then scan forwards to find
7317 one. This prevents inconsistencies in the linker's
7318 behaviour when a script has specified just a single
7319 header and there are sections in that script which are
7320 not assigned to it, and which occur before the first
7321 use of that header. See here for more details:
7322 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
7323 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
7326 last
= tmp_os
->phdrs
;
7330 einfo (_("%F%P: no sections assigned to phdrs\n"));
7335 if (os
->bfd_section
== NULL
)
7338 for (; pl
!= NULL
; pl
= pl
->next
)
7340 if (strcmp (pl
->name
, l
->name
) == 0)
7345 secs
= (asection
**) xrealloc (secs
,
7346 alc
* sizeof (asection
*));
7348 secs
[c
] = os
->bfd_section
;
7355 if (l
->flags
== NULL
)
7358 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
7363 at
= exp_get_vma (l
->at
, 0, "phdr load address");
7365 if (! bfd_record_phdr (link_info
.output_bfd
, l
->type
,
7366 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
7367 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
7368 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
7373 /* Make sure all the phdr assignments succeeded. */
7374 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
7378 lang_output_section_phdr_list
*pl
;
7380 if (os
->constraint
< 0
7381 || os
->bfd_section
== NULL
)
7384 for (pl
= os
->phdrs
;
7387 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
7388 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
7389 os
->name
, pl
->name
);
7393 /* Record a list of sections which may not be cross referenced. */
7396 lang_add_nocrossref (lang_nocrossref_type
*l
)
7398 struct lang_nocrossrefs
*n
;
7400 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
7401 n
->next
= nocrossref_list
;
7403 nocrossref_list
= n
;
7405 /* Set notice_all so that we get informed about all symbols. */
7406 link_info
.notice_all
= TRUE
;
7409 /* Overlay handling. We handle overlays with some static variables. */
7411 /* The overlay virtual address. */
7412 static etree_type
*overlay_vma
;
7413 /* And subsection alignment. */
7414 static etree_type
*overlay_subalign
;
7416 /* An expression for the maximum section size seen so far. */
7417 static etree_type
*overlay_max
;
7419 /* A list of all the sections in this overlay. */
7421 struct overlay_list
{
7422 struct overlay_list
*next
;
7423 lang_output_section_statement_type
*os
;
7426 static struct overlay_list
*overlay_list
;
7428 /* Start handling an overlay. */
7431 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
7433 /* The grammar should prevent nested overlays from occurring. */
7434 ASSERT (overlay_vma
== NULL
7435 && overlay_subalign
== NULL
7436 && overlay_max
== NULL
);
7438 overlay_vma
= vma_expr
;
7439 overlay_subalign
= subalign
;
7442 /* Start a section in an overlay. We handle this by calling
7443 lang_enter_output_section_statement with the correct VMA.
7444 lang_leave_overlay sets up the LMA and memory regions. */
7447 lang_enter_overlay_section (const char *name
)
7449 struct overlay_list
*n
;
7452 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
7453 0, overlay_subalign
, 0, 0, 0);
7455 /* If this is the first section, then base the VMA of future
7456 sections on this one. This will work correctly even if `.' is
7457 used in the addresses. */
7458 if (overlay_list
== NULL
)
7459 overlay_vma
= exp_nameop (ADDR
, name
);
7461 /* Remember the section. */
7462 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
7463 n
->os
= current_section
;
7464 n
->next
= overlay_list
;
7467 size
= exp_nameop (SIZEOF
, name
);
7469 /* Arrange to work out the maximum section end address. */
7470 if (overlay_max
== NULL
)
7473 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
7476 /* Finish a section in an overlay. There isn't any special to do
7480 lang_leave_overlay_section (fill_type
*fill
,
7481 lang_output_section_phdr_list
*phdrs
)
7488 name
= current_section
->name
;
7490 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
7491 region and that no load-time region has been specified. It doesn't
7492 really matter what we say here, since lang_leave_overlay will
7494 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
7496 /* Define the magic symbols. */
7498 clean
= (char *) xmalloc (strlen (name
) + 1);
7500 for (s1
= name
; *s1
!= '\0'; s1
++)
7501 if (ISALNUM (*s1
) || *s1
== '_')
7505 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_start_");
7506 sprintf (buf
, "__load_start_%s", clean
);
7507 lang_add_assignment (exp_provide (buf
,
7508 exp_nameop (LOADADDR
, name
),
7511 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_stop_");
7512 sprintf (buf
, "__load_stop_%s", clean
);
7513 lang_add_assignment (exp_provide (buf
,
7515 exp_nameop (LOADADDR
, name
),
7516 exp_nameop (SIZEOF
, name
)),
7522 /* Finish an overlay. If there are any overlay wide settings, this
7523 looks through all the sections in the overlay and sets them. */
7526 lang_leave_overlay (etree_type
*lma_expr
,
7529 const char *memspec
,
7530 lang_output_section_phdr_list
*phdrs
,
7531 const char *lma_memspec
)
7533 lang_memory_region_type
*region
;
7534 lang_memory_region_type
*lma_region
;
7535 struct overlay_list
*l
;
7536 lang_nocrossref_type
*nocrossref
;
7538 lang_get_regions (®ion
, &lma_region
,
7539 memspec
, lma_memspec
,
7540 lma_expr
!= NULL
, FALSE
);
7544 /* After setting the size of the last section, set '.' to end of the
7546 if (overlay_list
!= NULL
)
7548 overlay_list
->os
->update_dot
= 1;
7549 overlay_list
->os
->update_dot_tree
7550 = exp_assign (".", exp_binop ('+', overlay_vma
, overlay_max
), FALSE
);
7556 struct overlay_list
*next
;
7558 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
7561 l
->os
->region
= region
;
7562 l
->os
->lma_region
= lma_region
;
7564 /* The first section has the load address specified in the
7565 OVERLAY statement. The rest are worked out from that.
7566 The base address is not needed (and should be null) if
7567 an LMA region was specified. */
7570 l
->os
->load_base
= lma_expr
;
7571 l
->os
->sectype
= normal_section
;
7573 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
7574 l
->os
->phdrs
= phdrs
;
7578 lang_nocrossref_type
*nc
;
7580 nc
= (lang_nocrossref_type
*) xmalloc (sizeof *nc
);
7581 nc
->name
= l
->os
->name
;
7582 nc
->next
= nocrossref
;
7591 if (nocrossref
!= NULL
)
7592 lang_add_nocrossref (nocrossref
);
7595 overlay_list
= NULL
;
7599 /* Version handling. This is only useful for ELF. */
7601 /* If PREV is NULL, return first version pattern matching particular symbol.
7602 If PREV is non-NULL, return first version pattern matching particular
7603 symbol after PREV (previously returned by lang_vers_match). */
7605 static struct bfd_elf_version_expr
*
7606 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
7607 struct bfd_elf_version_expr
*prev
,
7611 const char *cxx_sym
= sym
;
7612 const char *java_sym
= sym
;
7613 struct bfd_elf_version_expr
*expr
= NULL
;
7614 enum demangling_styles curr_style
;
7616 curr_style
= CURRENT_DEMANGLING_STYLE
;
7617 cplus_demangle_set_style (no_demangling
);
7618 c_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_NO_OPTS
);
7621 cplus_demangle_set_style (curr_style
);
7623 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
7625 cxx_sym
= bfd_demangle (link_info
.output_bfd
, sym
,
7626 DMGL_PARAMS
| DMGL_ANSI
);
7630 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
7632 java_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_JAVA
);
7637 if (head
->htab
&& (prev
== NULL
|| prev
->literal
))
7639 struct bfd_elf_version_expr e
;
7641 switch (prev
? prev
->mask
: 0)
7644 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
7647 expr
= (struct bfd_elf_version_expr
*)
7648 htab_find ((htab_t
) head
->htab
, &e
);
7649 while (expr
&& strcmp (expr
->pattern
, c_sym
) == 0)
7650 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
7656 case BFD_ELF_VERSION_C_TYPE
:
7657 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
7659 e
.pattern
= cxx_sym
;
7660 expr
= (struct bfd_elf_version_expr
*)
7661 htab_find ((htab_t
) head
->htab
, &e
);
7662 while (expr
&& strcmp (expr
->pattern
, cxx_sym
) == 0)
7663 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
7669 case BFD_ELF_VERSION_CXX_TYPE
:
7670 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
7672 e
.pattern
= java_sym
;
7673 expr
= (struct bfd_elf_version_expr
*)
7674 htab_find ((htab_t
) head
->htab
, &e
);
7675 while (expr
&& strcmp (expr
->pattern
, java_sym
) == 0)
7676 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
7687 /* Finally, try the wildcards. */
7688 if (prev
== NULL
|| prev
->literal
)
7689 expr
= head
->remaining
;
7692 for (; expr
; expr
= expr
->next
)
7699 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
7702 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
7704 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
7708 if (fnmatch (expr
->pattern
, s
, 0) == 0)
7714 free ((char *) c_sym
);
7716 free ((char *) cxx_sym
);
7717 if (java_sym
!= sym
)
7718 free ((char *) java_sym
);
7722 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
7723 return a pointer to the symbol name with any backslash quotes removed. */
7726 realsymbol (const char *pattern
)
7729 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
7730 char *s
, *symbol
= (char *) xmalloc (strlen (pattern
) + 1);
7732 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
7734 /* It is a glob pattern only if there is no preceding
7738 /* Remove the preceding backslash. */
7745 if (*p
== '?' || *p
== '*' || *p
== '[')
7752 backslash
= *p
== '\\';
7768 /* This is called for each variable name or match expression. NEW_NAME is
7769 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
7770 pattern to be matched against symbol names. */
7772 struct bfd_elf_version_expr
*
7773 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
7774 const char *new_name
,
7776 bfd_boolean literal_p
)
7778 struct bfd_elf_version_expr
*ret
;
7780 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
7784 ret
->literal
= TRUE
;
7785 ret
->pattern
= literal_p
? new_name
: realsymbol (new_name
);
7786 if (ret
->pattern
== NULL
)
7788 ret
->pattern
= new_name
;
7789 ret
->literal
= FALSE
;
7792 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
7793 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
7794 else if (strcasecmp (lang
, "C++") == 0)
7795 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
7796 else if (strcasecmp (lang
, "Java") == 0)
7797 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
7800 einfo (_("%X%P: unknown language `%s' in version information\n"),
7802 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
7805 return ldemul_new_vers_pattern (ret
);
7808 /* This is called for each set of variable names and match
7811 struct bfd_elf_version_tree
*
7812 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
7813 struct bfd_elf_version_expr
*locals
)
7815 struct bfd_elf_version_tree
*ret
;
7817 ret
= (struct bfd_elf_version_tree
*) xcalloc (1, sizeof *ret
);
7818 ret
->globals
.list
= globals
;
7819 ret
->locals
.list
= locals
;
7820 ret
->match
= lang_vers_match
;
7821 ret
->name_indx
= (unsigned int) -1;
7825 /* This static variable keeps track of version indices. */
7827 static int version_index
;
7830 version_expr_head_hash (const void *p
)
7832 const struct bfd_elf_version_expr
*e
=
7833 (const struct bfd_elf_version_expr
*) p
;
7835 return htab_hash_string (e
->pattern
);
7839 version_expr_head_eq (const void *p1
, const void *p2
)
7841 const struct bfd_elf_version_expr
*e1
=
7842 (const struct bfd_elf_version_expr
*) p1
;
7843 const struct bfd_elf_version_expr
*e2
=
7844 (const struct bfd_elf_version_expr
*) p2
;
7846 return strcmp (e1
->pattern
, e2
->pattern
) == 0;
7850 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
7853 struct bfd_elf_version_expr
*e
, *next
;
7854 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
7856 for (e
= head
->list
; e
; e
= e
->next
)
7860 head
->mask
|= e
->mask
;
7865 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
7866 version_expr_head_eq
, NULL
);
7867 list_loc
= &head
->list
;
7868 remaining_loc
= &head
->remaining
;
7869 for (e
= head
->list
; e
; e
= next
)
7875 remaining_loc
= &e
->next
;
7879 void **loc
= htab_find_slot ((htab_t
) head
->htab
, e
, INSERT
);
7883 struct bfd_elf_version_expr
*e1
, *last
;
7885 e1
= (struct bfd_elf_version_expr
*) *loc
;
7889 if (e1
->mask
== e
->mask
)
7897 while (e1
&& strcmp (e1
->pattern
, e
->pattern
) == 0);
7901 /* This is a duplicate. */
7902 /* FIXME: Memory leak. Sometimes pattern is not
7903 xmalloced alone, but in larger chunk of memory. */
7904 /* free (e->pattern); */
7909 e
->next
= last
->next
;
7917 list_loc
= &e
->next
;
7921 *remaining_loc
= NULL
;
7922 *list_loc
= head
->remaining
;
7925 head
->remaining
= head
->list
;
7928 /* This is called when we know the name and dependencies of the
7932 lang_register_vers_node (const char *name
,
7933 struct bfd_elf_version_tree
*version
,
7934 struct bfd_elf_version_deps
*deps
)
7936 struct bfd_elf_version_tree
*t
, **pp
;
7937 struct bfd_elf_version_expr
*e1
;
7942 if (link_info
.version_info
!= NULL
7943 && (name
[0] == '\0' || link_info
.version_info
->name
[0] == '\0'))
7945 einfo (_("%X%P: anonymous version tag cannot be combined"
7946 " with other version tags\n"));
7951 /* Make sure this node has a unique name. */
7952 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
7953 if (strcmp (t
->name
, name
) == 0)
7954 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
7956 lang_finalize_version_expr_head (&version
->globals
);
7957 lang_finalize_version_expr_head (&version
->locals
);
7959 /* Check the global and local match names, and make sure there
7960 aren't any duplicates. */
7962 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
7964 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
7966 struct bfd_elf_version_expr
*e2
;
7968 if (t
->locals
.htab
&& e1
->literal
)
7970 e2
= (struct bfd_elf_version_expr
*)
7971 htab_find ((htab_t
) t
->locals
.htab
, e1
);
7972 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
7974 if (e1
->mask
== e2
->mask
)
7975 einfo (_("%X%P: duplicate expression `%s'"
7976 " in version information\n"), e1
->pattern
);
7980 else if (!e1
->literal
)
7981 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
7982 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
7983 && e1
->mask
== e2
->mask
)
7984 einfo (_("%X%P: duplicate expression `%s'"
7985 " in version information\n"), e1
->pattern
);
7989 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
7991 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
7993 struct bfd_elf_version_expr
*e2
;
7995 if (t
->globals
.htab
&& e1
->literal
)
7997 e2
= (struct bfd_elf_version_expr
*)
7998 htab_find ((htab_t
) t
->globals
.htab
, e1
);
7999 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
8001 if (e1
->mask
== e2
->mask
)
8002 einfo (_("%X%P: duplicate expression `%s'"
8003 " in version information\n"),
8008 else if (!e1
->literal
)
8009 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
8010 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
8011 && e1
->mask
== e2
->mask
)
8012 einfo (_("%X%P: duplicate expression `%s'"
8013 " in version information\n"), e1
->pattern
);
8017 version
->deps
= deps
;
8018 version
->name
= name
;
8019 if (name
[0] != '\0')
8022 version
->vernum
= version_index
;
8025 version
->vernum
= 0;
8027 for (pp
= &link_info
.version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
8032 /* This is called when we see a version dependency. */
8034 struct bfd_elf_version_deps
*
8035 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
8037 struct bfd_elf_version_deps
*ret
;
8038 struct bfd_elf_version_tree
*t
;
8040 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
8043 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8045 if (strcmp (t
->name
, name
) == 0)
8047 ret
->version_needed
= t
;
8052 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
8054 ret
->version_needed
= NULL
;
8059 lang_do_version_exports_section (void)
8061 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
8063 LANG_FOR_EACH_INPUT_STATEMENT (is
)
8065 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
8073 contents
= (char *) xmalloc (len
);
8074 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
8075 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
8078 while (p
< contents
+ len
)
8080 greg
= lang_new_vers_pattern (greg
, p
, NULL
, FALSE
);
8081 p
= strchr (p
, '\0') + 1;
8084 /* Do not free the contents, as we used them creating the regex. */
8086 /* Do not include this section in the link. */
8087 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
8090 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, FALSE
);
8091 lang_register_vers_node (command_line
.version_exports_section
,
8092 lang_new_vers_node (greg
, lreg
), NULL
);
8095 /* Evaluate LENGTH and ORIGIN parts of MEMORY spec */
8098 lang_do_memory_regions (void)
8100 lang_memory_region_type
*r
= lang_memory_region_list
;
8102 for (; r
!= NULL
; r
= r
->next
)
8106 exp_fold_tree_no_dot (r
->origin_exp
);
8107 if (expld
.result
.valid_p
)
8109 r
->origin
= expld
.result
.value
;
8110 r
->current
= r
->origin
;
8113 einfo (_("%F%P: invalid origin for memory region %s\n"), r
->name_list
.name
);
8117 exp_fold_tree_no_dot (r
->length_exp
);
8118 if (expld
.result
.valid_p
)
8119 r
->length
= expld
.result
.value
;
8121 einfo (_("%F%P: invalid length for memory region %s\n"), r
->name_list
.name
);
8127 lang_add_unique (const char *name
)
8129 struct unique_sections
*ent
;
8131 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
8132 if (strcmp (ent
->name
, name
) == 0)
8135 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
8136 ent
->name
= xstrdup (name
);
8137 ent
->next
= unique_section_list
;
8138 unique_section_list
= ent
;
8141 /* Append the list of dynamic symbols to the existing one. */
8144 lang_append_dynamic_list (struct bfd_elf_version_expr
*dynamic
)
8146 if (link_info
.dynamic_list
)
8148 struct bfd_elf_version_expr
*tail
;
8149 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
8151 tail
->next
= link_info
.dynamic_list
->head
.list
;
8152 link_info
.dynamic_list
->head
.list
= dynamic
;
8156 struct bfd_elf_dynamic_list
*d
;
8158 d
= (struct bfd_elf_dynamic_list
*) xcalloc (1, sizeof *d
);
8159 d
->head
.list
= dynamic
;
8160 d
->match
= lang_vers_match
;
8161 link_info
.dynamic_list
= d
;
8165 /* Append the list of C++ typeinfo dynamic symbols to the existing
8169 lang_append_dynamic_list_cpp_typeinfo (void)
8171 const char * symbols
[] =
8173 "typeinfo name for*",
8176 struct bfd_elf_version_expr
*dynamic
= NULL
;
8179 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
8180 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
8183 lang_append_dynamic_list (dynamic
);
8186 /* Append the list of C++ operator new and delete dynamic symbols to the
8190 lang_append_dynamic_list_cpp_new (void)
8192 const char * symbols
[] =
8197 struct bfd_elf_version_expr
*dynamic
= NULL
;
8200 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
8201 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
8204 lang_append_dynamic_list (dynamic
);
8207 /* Scan a space and/or comma separated string of features. */
8210 lang_ld_feature (char *str
)
8218 while (*p
== ',' || ISSPACE (*p
))
8223 while (*q
&& *q
!= ',' && !ISSPACE (*q
))
8227 if (strcasecmp (p
, "SANE_EXPR") == 0)
8228 config
.sane_expr
= TRUE
;
8230 einfo (_("%X%P: unknown feature `%s'\n"), p
);
8236 /* Pretty print memory amount. */
8239 lang_print_memory_size (bfd_vma sz
)
8241 if ((sz
& 0x3fffffff) == 0)
8242 printf ("%10" BFD_VMA_FMT
"u GB", sz
>> 30);
8243 else if ((sz
& 0xfffff) == 0)
8244 printf ("%10" BFD_VMA_FMT
"u MB", sz
>> 20);
8245 else if ((sz
& 0x3ff) == 0)
8246 printf ("%10" BFD_VMA_FMT
"u KB", sz
>> 10);
8248 printf (" %10" BFD_VMA_FMT
"u B", sz
);
8251 /* Implement --print-memory-usage: disply per region memory usage. */
8254 lang_print_memory_usage (void)
8256 lang_memory_region_type
*r
;
8258 printf ("Memory region Used Size Region Size %%age Used\n");
8259 for (r
= lang_memory_region_list
; r
->next
!= NULL
; r
= r
->next
)
8261 bfd_vma used_length
= r
->current
- r
->origin
;
8264 printf ("%16s: ",r
->name_list
.name
);
8265 lang_print_memory_size (used_length
);
8266 lang_print_memory_size ((bfd_vma
) r
->length
);
8268 percent
= used_length
* 100.0 / r
->length
;
8270 printf (" %6.2f%%\n", percent
);