1 /* Linker command language support.
2 Copyright (C) 1991-2016 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 /* Convert between addresses in bytes and sizes in octets.
53 For currently supported targets, octets_per_byte is always a power
54 of two, so we can use shifts. */
55 #define TO_ADDR(X) ((X) >> opb_shift)
56 #define TO_SIZE(X) ((X) << opb_shift)
58 /* Local variables. */
59 static struct obstack stat_obstack
;
60 static struct obstack map_obstack
;
62 #define obstack_chunk_alloc xmalloc
63 #define obstack_chunk_free free
64 static const char *entry_symbol_default
= "start";
65 static bfd_boolean placed_commons
= FALSE
;
66 static bfd_boolean map_head_is_link_order
= FALSE
;
67 static lang_output_section_statement_type
*default_common_section
;
68 static bfd_boolean map_option_f
;
69 static bfd_vma print_dot
;
70 static lang_input_statement_type
*first_file
;
71 static const char *current_target
;
72 static lang_statement_list_type statement_list
;
73 static lang_statement_list_type
*stat_save
[10];
74 static lang_statement_list_type
**stat_save_ptr
= &stat_save
[0];
75 static struct unique_sections
*unique_section_list
;
76 static struct asneeded_minfo
*asneeded_list_head
;
77 static unsigned int opb_shift
= 0;
79 /* Forward declarations. */
80 static void exp_init_os (etree_type
*);
81 static lang_input_statement_type
*lookup_name (const char *);
82 static void insert_undefined (const char *);
83 static bfd_boolean
sort_def_symbol (struct bfd_link_hash_entry
*, void *);
84 static void print_statement (lang_statement_union_type
*,
85 lang_output_section_statement_type
*);
86 static void print_statement_list (lang_statement_union_type
*,
87 lang_output_section_statement_type
*);
88 static void print_statements (void);
89 static void print_input_section (asection
*, bfd_boolean
);
90 static bfd_boolean
lang_one_common (struct bfd_link_hash_entry
*, void *);
91 static void lang_record_phdrs (void);
92 static void lang_do_version_exports_section (void);
93 static void lang_finalize_version_expr_head
94 (struct bfd_elf_version_expr_head
*);
95 static void lang_do_memory_regions (void);
97 /* Exported variables. */
98 const char *output_target
;
99 lang_output_section_statement_type
*abs_output_section
;
100 lang_statement_list_type lang_output_section_statement
;
101 lang_statement_list_type
*stat_ptr
= &statement_list
;
102 lang_statement_list_type file_chain
= { NULL
, NULL
};
103 lang_statement_list_type input_file_chain
;
104 struct bfd_sym_chain entry_symbol
= { NULL
, NULL
};
105 const char *entry_section
= ".text";
106 struct lang_input_statement_flags input_flags
;
107 bfd_boolean entry_from_cmdline
;
108 bfd_boolean undef_from_cmdline
;
109 bfd_boolean lang_has_input_file
= FALSE
;
110 bfd_boolean had_output_filename
= FALSE
;
111 bfd_boolean lang_float_flag
= FALSE
;
112 bfd_boolean delete_output_file_on_failure
= FALSE
;
113 struct lang_phdr
*lang_phdr_list
;
114 struct lang_nocrossrefs
*nocrossref_list
;
115 struct asneeded_minfo
**asneeded_list_tail
;
117 /* Functions that traverse the linker script and might evaluate
118 DEFINED() need to increment this at the start of the traversal. */
119 int lang_statement_iteration
= 0;
121 /* Return TRUE if the PATTERN argument is a wildcard pattern.
122 Although backslashes are treated specially if a pattern contains
123 wildcards, we do not consider the mere presence of a backslash to
124 be enough to cause the pattern to be treated as a wildcard.
125 That lets us handle DOS filenames more naturally. */
126 #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
128 #define new_stat(x, y) \
129 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
131 #define outside_section_address(q) \
132 ((q)->output_offset + (q)->output_section->vma)
134 #define outside_symbol_address(q) \
135 ((q)->value + outside_section_address (q->section))
137 #define SECTION_NAME_MAP_LENGTH (16)
140 stat_alloc (size_t size
)
142 return obstack_alloc (&stat_obstack
, size
);
146 name_match (const char *pattern
, const char *name
)
148 if (wildcardp (pattern
))
149 return fnmatch (pattern
, name
, 0);
150 return strcmp (pattern
, name
);
153 /* If PATTERN is of the form archive:file, return a pointer to the
154 separator. If not, return NULL. */
157 archive_path (const char *pattern
)
161 if (link_info
.path_separator
== 0)
164 p
= strchr (pattern
, link_info
.path_separator
);
165 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
166 if (p
== NULL
|| link_info
.path_separator
!= ':')
169 /* Assume a match on the second char is part of drive specifier,
170 as in "c:\silly.dos". */
171 if (p
== pattern
+ 1 && ISALPHA (*pattern
))
172 p
= strchr (p
+ 1, link_info
.path_separator
);
177 /* Given that FILE_SPEC results in a non-NULL SEP result from archive_path,
178 return whether F matches FILE_SPEC. */
181 input_statement_is_archive_path (const char *file_spec
, char *sep
,
182 lang_input_statement_type
*f
)
184 bfd_boolean match
= FALSE
;
187 || name_match (sep
+ 1, f
->filename
) == 0)
188 && ((sep
!= file_spec
)
189 == (f
->the_bfd
!= NULL
&& f
->the_bfd
->my_archive
!= NULL
)))
193 if (sep
!= file_spec
)
195 const char *aname
= f
->the_bfd
->my_archive
->filename
;
197 match
= name_match (file_spec
, aname
) == 0;
198 *sep
= link_info
.path_separator
;
205 unique_section_p (const asection
*sec
,
206 const lang_output_section_statement_type
*os
)
208 struct unique_sections
*unam
;
211 if (bfd_link_relocatable (&link_info
)
212 && sec
->owner
!= NULL
213 && bfd_is_group_section (sec
->owner
, sec
))
215 && strcmp (os
->name
, DISCARD_SECTION_NAME
) == 0);
218 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
219 if (name_match (unam
->name
, secnam
) == 0)
225 /* Generic traversal routines for finding matching sections. */
227 /* Try processing a section against a wildcard. This just calls
228 the callback unless the filename exclusion list is present
229 and excludes the file. It's hardly ever present so this
230 function is very fast. */
233 walk_wild_consider_section (lang_wild_statement_type
*ptr
,
234 lang_input_statement_type
*file
,
236 struct wildcard_list
*sec
,
240 struct name_list
*list_tmp
;
242 /* Don't process sections from files which were excluded. */
243 for (list_tmp
= sec
->spec
.exclude_name_list
;
245 list_tmp
= list_tmp
->next
)
247 char *p
= archive_path (list_tmp
->name
);
251 if (input_statement_is_archive_path (list_tmp
->name
, p
, file
))
255 else if (name_match (list_tmp
->name
, file
->filename
) == 0)
258 /* FIXME: Perhaps remove the following at some stage? Matching
259 unadorned archives like this was never documented and has
260 been superceded by the archive:path syntax. */
261 else if (file
->the_bfd
!= NULL
262 && file
->the_bfd
->my_archive
!= NULL
263 && name_match (list_tmp
->name
,
264 file
->the_bfd
->my_archive
->filename
) == 0)
268 (*callback
) (ptr
, sec
, s
, ptr
->section_flag_list
, file
, data
);
271 /* Lowest common denominator routine that can handle everything correctly,
275 walk_wild_section_general (lang_wild_statement_type
*ptr
,
276 lang_input_statement_type
*file
,
281 struct wildcard_list
*sec
;
283 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
285 sec
= ptr
->section_list
;
287 (*callback
) (ptr
, sec
, s
, ptr
->section_flag_list
, file
, data
);
291 bfd_boolean skip
= FALSE
;
293 if (sec
->spec
.name
!= NULL
)
295 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
297 skip
= name_match (sec
->spec
.name
, sname
) != 0;
301 walk_wild_consider_section (ptr
, file
, s
, sec
, callback
, data
);
308 /* Routines to find a single section given its name. If there's more
309 than one section with that name, we report that. */
313 asection
*found_section
;
314 bfd_boolean multiple_sections_found
;
315 } section_iterator_callback_data
;
318 section_iterator_callback (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*s
, void *data
)
320 section_iterator_callback_data
*d
= (section_iterator_callback_data
*) data
;
322 if (d
->found_section
!= NULL
)
324 d
->multiple_sections_found
= TRUE
;
328 d
->found_section
= s
;
333 find_section (lang_input_statement_type
*file
,
334 struct wildcard_list
*sec
,
335 bfd_boolean
*multiple_sections_found
)
337 section_iterator_callback_data cb_data
= { NULL
, FALSE
};
339 bfd_get_section_by_name_if (file
->the_bfd
, sec
->spec
.name
,
340 section_iterator_callback
, &cb_data
);
341 *multiple_sections_found
= cb_data
.multiple_sections_found
;
342 return cb_data
.found_section
;
345 /* Code for handling simple wildcards without going through fnmatch,
346 which can be expensive because of charset translations etc. */
348 /* A simple wild is a literal string followed by a single '*',
349 where the literal part is at least 4 characters long. */
352 is_simple_wild (const char *name
)
354 size_t len
= strcspn (name
, "*?[");
355 return len
>= 4 && name
[len
] == '*' && name
[len
+ 1] == '\0';
359 match_simple_wild (const char *pattern
, const char *name
)
361 /* The first four characters of the pattern are guaranteed valid
362 non-wildcard characters. So we can go faster. */
363 if (pattern
[0] != name
[0] || pattern
[1] != name
[1]
364 || pattern
[2] != name
[2] || pattern
[3] != name
[3])
369 while (*pattern
!= '*')
370 if (*name
++ != *pattern
++)
376 /* Return the numerical value of the init_priority attribute from
377 section name NAME. */
380 get_init_priority (const char *name
)
383 unsigned long init_priority
;
385 /* GCC uses the following section names for the init_priority
386 attribute with numerical values 101 and 65535 inclusive. A
387 lower value means a higher priority.
389 1: .init_array.NNNN/.fini_array.NNNN: Where NNNN is the
390 decimal numerical value of the init_priority attribute.
391 The order of execution in .init_array is forward and
392 .fini_array is backward.
393 2: .ctors.NNNN/.dtors.NNNN: Where NNNN is 65535 minus the
394 decimal numerical value of the init_priority attribute.
395 The order of execution in .ctors is backward and .dtors
398 if (strncmp (name
, ".init_array.", 12) == 0
399 || strncmp (name
, ".fini_array.", 12) == 0)
401 init_priority
= strtoul (name
+ 12, &end
, 10);
402 return *end
? 0 : init_priority
;
404 else if (strncmp (name
, ".ctors.", 7) == 0
405 || strncmp (name
, ".dtors.", 7) == 0)
407 init_priority
= strtoul (name
+ 7, &end
, 10);
408 return *end
? 0 : 65535 - init_priority
;
414 /* Compare sections ASEC and BSEC according to SORT. */
417 compare_section (sort_type sort
, asection
*asec
, asection
*bsec
)
420 unsigned long ainit_priority
, binit_priority
;
427 case by_init_priority
:
429 = get_init_priority (bfd_get_section_name (asec
->owner
, asec
));
431 = get_init_priority (bfd_get_section_name (bsec
->owner
, bsec
));
432 if (ainit_priority
== 0 || binit_priority
== 0)
434 ret
= ainit_priority
- binit_priority
;
440 case by_alignment_name
:
441 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
442 - bfd_section_alignment (asec
->owner
, asec
));
449 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
450 bfd_get_section_name (bsec
->owner
, bsec
));
453 case by_name_alignment
:
454 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
455 bfd_get_section_name (bsec
->owner
, bsec
));
461 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
462 - bfd_section_alignment (asec
->owner
, asec
));
469 /* Build a Binary Search Tree to sort sections, unlike insertion sort
470 used in wild_sort(). BST is considerably faster if the number of
471 of sections are large. */
473 static lang_section_bst_type
**
474 wild_sort_fast (lang_wild_statement_type
*wild
,
475 struct wildcard_list
*sec
,
476 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
479 lang_section_bst_type
**tree
;
482 if (!wild
->filenames_sorted
483 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
485 /* Append at the right end of tree. */
487 tree
= &((*tree
)->right
);
493 /* Find the correct node to append this section. */
494 if (compare_section (sec
->spec
.sorted
, section
, (*tree
)->section
) < 0)
495 tree
= &((*tree
)->left
);
497 tree
= &((*tree
)->right
);
503 /* Use wild_sort_fast to build a BST to sort sections. */
506 output_section_callback_fast (lang_wild_statement_type
*ptr
,
507 struct wildcard_list
*sec
,
509 struct flag_info
*sflag_list ATTRIBUTE_UNUSED
,
510 lang_input_statement_type
*file
,
513 lang_section_bst_type
*node
;
514 lang_section_bst_type
**tree
;
515 lang_output_section_statement_type
*os
;
517 os
= (lang_output_section_statement_type
*) output
;
519 if (unique_section_p (section
, os
))
522 node
= (lang_section_bst_type
*) xmalloc (sizeof (lang_section_bst_type
));
525 node
->section
= section
;
527 tree
= wild_sort_fast (ptr
, sec
, file
, section
);
532 /* Convert a sorted sections' BST back to list form. */
535 output_section_callback_tree_to_list (lang_wild_statement_type
*ptr
,
536 lang_section_bst_type
*tree
,
540 output_section_callback_tree_to_list (ptr
, tree
->left
, output
);
542 lang_add_section (&ptr
->children
, tree
->section
, NULL
,
543 (lang_output_section_statement_type
*) output
);
546 output_section_callback_tree_to_list (ptr
, tree
->right
, output
);
551 /* Specialized, optimized routines for handling different kinds of
555 walk_wild_section_specs1_wild0 (lang_wild_statement_type
*ptr
,
556 lang_input_statement_type
*file
,
560 /* We can just do a hash lookup for the section with the right name.
561 But if that lookup discovers more than one section with the name
562 (should be rare), we fall back to the general algorithm because
563 we would otherwise have to sort the sections to make sure they
564 get processed in the bfd's order. */
565 bfd_boolean multiple_sections_found
;
566 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
567 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
569 if (multiple_sections_found
)
570 walk_wild_section_general (ptr
, file
, callback
, data
);
572 walk_wild_consider_section (ptr
, file
, s0
, sec0
, callback
, data
);
576 walk_wild_section_specs1_wild1 (lang_wild_statement_type
*ptr
,
577 lang_input_statement_type
*file
,
582 struct wildcard_list
*wildsec0
= ptr
->handler_data
[0];
584 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
586 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
587 bfd_boolean skip
= !match_simple_wild (wildsec0
->spec
.name
, sname
);
590 walk_wild_consider_section (ptr
, file
, s
, wildsec0
, callback
, data
);
595 walk_wild_section_specs2_wild1 (lang_wild_statement_type
*ptr
,
596 lang_input_statement_type
*file
,
601 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
602 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
603 bfd_boolean multiple_sections_found
;
604 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
606 if (multiple_sections_found
)
608 walk_wild_section_general (ptr
, file
, callback
, data
);
612 /* Note that if the section was not found, s0 is NULL and
613 we'll simply never succeed the s == s0 test below. */
614 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
616 /* Recall that in this code path, a section cannot satisfy more
617 than one spec, so if s == s0 then it cannot match
620 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
623 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
624 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
627 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
,
634 walk_wild_section_specs3_wild2 (lang_wild_statement_type
*ptr
,
635 lang_input_statement_type
*file
,
640 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
641 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
642 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
643 bfd_boolean multiple_sections_found
;
644 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
646 if (multiple_sections_found
)
648 walk_wild_section_general (ptr
, file
, callback
, data
);
652 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
655 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
658 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
659 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
662 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
, data
);
665 skip
= !match_simple_wild (wildsec2
->spec
.name
, sname
);
667 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
675 walk_wild_section_specs4_wild2 (lang_wild_statement_type
*ptr
,
676 lang_input_statement_type
*file
,
681 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
682 struct wildcard_list
*sec1
= ptr
->handler_data
[1];
683 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
684 struct wildcard_list
*wildsec3
= ptr
->handler_data
[3];
685 bfd_boolean multiple_sections_found
;
686 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
), *s1
;
688 if (multiple_sections_found
)
690 walk_wild_section_general (ptr
, file
, callback
, data
);
694 s1
= find_section (file
, sec1
, &multiple_sections_found
);
695 if (multiple_sections_found
)
697 walk_wild_section_general (ptr
, file
, callback
, data
);
701 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
704 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
707 walk_wild_consider_section (ptr
, file
, s
, sec1
, callback
, data
);
710 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
711 bfd_boolean skip
= !match_simple_wild (wildsec2
->spec
.name
,
715 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
719 skip
= !match_simple_wild (wildsec3
->spec
.name
, sname
);
721 walk_wild_consider_section (ptr
, file
, s
, wildsec3
,
729 walk_wild_section (lang_wild_statement_type
*ptr
,
730 lang_input_statement_type
*file
,
734 if (file
->flags
.just_syms
)
737 (*ptr
->walk_wild_section_handler
) (ptr
, file
, callback
, data
);
740 /* Returns TRUE when name1 is a wildcard spec that might match
741 something name2 can match. We're conservative: we return FALSE
742 only if the prefixes of name1 and name2 are different up to the
743 first wildcard character. */
746 wild_spec_can_overlap (const char *name1
, const char *name2
)
748 size_t prefix1_len
= strcspn (name1
, "?*[");
749 size_t prefix2_len
= strcspn (name2
, "?*[");
750 size_t min_prefix_len
;
752 /* Note that if there is no wildcard character, then we treat the
753 terminating 0 as part of the prefix. Thus ".text" won't match
754 ".text." or ".text.*", for example. */
755 if (name1
[prefix1_len
] == '\0')
757 if (name2
[prefix2_len
] == '\0')
760 min_prefix_len
= prefix1_len
< prefix2_len
? prefix1_len
: prefix2_len
;
762 return memcmp (name1
, name2
, min_prefix_len
) == 0;
765 /* Select specialized code to handle various kinds of wildcard
769 analyze_walk_wild_section_handler (lang_wild_statement_type
*ptr
)
772 int wild_name_count
= 0;
773 struct wildcard_list
*sec
;
777 ptr
->walk_wild_section_handler
= walk_wild_section_general
;
778 ptr
->handler_data
[0] = NULL
;
779 ptr
->handler_data
[1] = NULL
;
780 ptr
->handler_data
[2] = NULL
;
781 ptr
->handler_data
[3] = NULL
;
784 /* Count how many wildcard_specs there are, and how many of those
785 actually use wildcards in the name. Also, bail out if any of the
786 wildcard names are NULL. (Can this actually happen?
787 walk_wild_section used to test for it.) And bail out if any
788 of the wildcards are more complex than a simple string
789 ending in a single '*'. */
790 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
793 if (sec
->spec
.name
== NULL
)
795 if (wildcardp (sec
->spec
.name
))
798 if (!is_simple_wild (sec
->spec
.name
))
803 /* The zero-spec case would be easy to optimize but it doesn't
804 happen in practice. Likewise, more than 4 specs doesn't
805 happen in practice. */
806 if (sec_count
== 0 || sec_count
> 4)
809 /* Check that no two specs can match the same section. */
810 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
812 struct wildcard_list
*sec2
;
813 for (sec2
= sec
->next
; sec2
!= NULL
; sec2
= sec2
->next
)
815 if (wild_spec_can_overlap (sec
->spec
.name
, sec2
->spec
.name
))
820 signature
= (sec_count
<< 8) + wild_name_count
;
824 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild0
;
827 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild1
;
830 ptr
->walk_wild_section_handler
= walk_wild_section_specs2_wild1
;
833 ptr
->walk_wild_section_handler
= walk_wild_section_specs3_wild2
;
836 ptr
->walk_wild_section_handler
= walk_wild_section_specs4_wild2
;
842 /* Now fill the data array with pointers to the specs, first the
843 specs with non-wildcard names, then the specs with wildcard
844 names. It's OK to process the specs in different order from the
845 given order, because we've already determined that no section
846 will match more than one spec. */
848 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
849 if (!wildcardp (sec
->spec
.name
))
850 ptr
->handler_data
[data_counter
++] = sec
;
851 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
852 if (wildcardp (sec
->spec
.name
))
853 ptr
->handler_data
[data_counter
++] = sec
;
856 /* Handle a wild statement for a single file F. */
859 walk_wild_file (lang_wild_statement_type
*s
,
860 lang_input_statement_type
*f
,
864 if (f
->the_bfd
== NULL
865 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
866 walk_wild_section (s
, f
, callback
, data
);
871 /* This is an archive file. We must map each member of the
872 archive separately. */
873 member
= bfd_openr_next_archived_file (f
->the_bfd
, NULL
);
874 while (member
!= NULL
)
876 /* When lookup_name is called, it will call the add_symbols
877 entry point for the archive. For each element of the
878 archive which is included, BFD will call ldlang_add_file,
879 which will set the usrdata field of the member to the
880 lang_input_statement. */
881 if (member
->usrdata
!= NULL
)
883 walk_wild_section (s
,
884 (lang_input_statement_type
*) member
->usrdata
,
888 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
894 walk_wild (lang_wild_statement_type
*s
, callback_t callback
, void *data
)
896 const char *file_spec
= s
->filename
;
899 if (file_spec
== NULL
)
901 /* Perform the iteration over all files in the list. */
902 LANG_FOR_EACH_INPUT_STATEMENT (f
)
904 walk_wild_file (s
, f
, callback
, data
);
907 else if ((p
= archive_path (file_spec
)) != NULL
)
909 LANG_FOR_EACH_INPUT_STATEMENT (f
)
911 if (input_statement_is_archive_path (file_spec
, p
, f
))
912 walk_wild_file (s
, f
, callback
, data
);
915 else if (wildcardp (file_spec
))
917 LANG_FOR_EACH_INPUT_STATEMENT (f
)
919 if (fnmatch (file_spec
, f
->filename
, 0) == 0)
920 walk_wild_file (s
, f
, callback
, data
);
925 lang_input_statement_type
*f
;
927 /* Perform the iteration over a single file. */
928 f
= lookup_name (file_spec
);
930 walk_wild_file (s
, f
, callback
, data
);
934 /* lang_for_each_statement walks the parse tree and calls the provided
935 function for each node, except those inside output section statements
936 with constraint set to -1. */
939 lang_for_each_statement_worker (void (*func
) (lang_statement_union_type
*),
940 lang_statement_union_type
*s
)
942 for (; s
!= NULL
; s
= s
->header
.next
)
946 switch (s
->header
.type
)
948 case lang_constructors_statement_enum
:
949 lang_for_each_statement_worker (func
, constructor_list
.head
);
951 case lang_output_section_statement_enum
:
952 if (s
->output_section_statement
.constraint
!= -1)
953 lang_for_each_statement_worker
954 (func
, s
->output_section_statement
.children
.head
);
956 case lang_wild_statement_enum
:
957 lang_for_each_statement_worker (func
,
958 s
->wild_statement
.children
.head
);
960 case lang_group_statement_enum
:
961 lang_for_each_statement_worker (func
,
962 s
->group_statement
.children
.head
);
964 case lang_data_statement_enum
:
965 case lang_reloc_statement_enum
:
966 case lang_object_symbols_statement_enum
:
967 case lang_output_statement_enum
:
968 case lang_target_statement_enum
:
969 case lang_input_section_enum
:
970 case lang_input_statement_enum
:
971 case lang_assignment_statement_enum
:
972 case lang_padding_statement_enum
:
973 case lang_address_statement_enum
:
974 case lang_fill_statement_enum
:
975 case lang_insert_statement_enum
:
985 lang_for_each_statement (void (*func
) (lang_statement_union_type
*))
987 lang_for_each_statement_worker (func
, statement_list
.head
);
990 /*----------------------------------------------------------------------*/
993 lang_list_init (lang_statement_list_type
*list
)
996 list
->tail
= &list
->head
;
1000 push_stat_ptr (lang_statement_list_type
*new_ptr
)
1002 if (stat_save_ptr
>= stat_save
+ sizeof (stat_save
) / sizeof (stat_save
[0]))
1004 *stat_save_ptr
++ = stat_ptr
;
1011 if (stat_save_ptr
<= stat_save
)
1013 stat_ptr
= *--stat_save_ptr
;
1016 /* Build a new statement node for the parse tree. */
1018 static lang_statement_union_type
*
1019 new_statement (enum statement_enum type
,
1021 lang_statement_list_type
*list
)
1023 lang_statement_union_type
*new_stmt
;
1025 new_stmt
= (lang_statement_union_type
*) stat_alloc (size
);
1026 new_stmt
->header
.type
= type
;
1027 new_stmt
->header
.next
= NULL
;
1028 lang_statement_append (list
, new_stmt
, &new_stmt
->header
.next
);
1032 /* Build a new input file node for the language. There are several
1033 ways in which we treat an input file, eg, we only look at symbols,
1034 or prefix it with a -l etc.
1036 We can be supplied with requests for input files more than once;
1037 they may, for example be split over several lines like foo.o(.text)
1038 foo.o(.data) etc, so when asked for a file we check that we haven't
1039 got it already so we don't duplicate the bfd. */
1041 static lang_input_statement_type
*
1042 new_afile (const char *name
,
1043 lang_input_file_enum_type file_type
,
1045 bfd_boolean add_to_list
)
1047 lang_input_statement_type
*p
;
1049 lang_has_input_file
= TRUE
;
1052 p
= (lang_input_statement_type
*) new_stat (lang_input_statement
, stat_ptr
);
1055 p
= (lang_input_statement_type
*)
1056 stat_alloc (sizeof (lang_input_statement_type
));
1057 p
->header
.type
= lang_input_statement_enum
;
1058 p
->header
.next
= NULL
;
1061 memset (&p
->the_bfd
, 0,
1062 sizeof (*p
) - offsetof (lang_input_statement_type
, the_bfd
));
1064 p
->flags
.dynamic
= input_flags
.dynamic
;
1065 p
->flags
.add_DT_NEEDED_for_dynamic
= input_flags
.add_DT_NEEDED_for_dynamic
;
1066 p
->flags
.add_DT_NEEDED_for_regular
= input_flags
.add_DT_NEEDED_for_regular
;
1067 p
->flags
.whole_archive
= input_flags
.whole_archive
;
1068 p
->flags
.sysrooted
= input_flags
.sysrooted
;
1072 case lang_input_file_is_symbols_only_enum
:
1074 p
->local_sym_name
= name
;
1075 p
->flags
.real
= TRUE
;
1076 p
->flags
.just_syms
= TRUE
;
1078 case lang_input_file_is_fake_enum
:
1080 p
->local_sym_name
= name
;
1082 case lang_input_file_is_l_enum
:
1083 if (name
[0] == ':' && name
[1] != '\0')
1085 p
->filename
= name
+ 1;
1086 p
->flags
.full_name_provided
= TRUE
;
1090 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
1091 p
->flags
.maybe_archive
= TRUE
;
1092 p
->flags
.real
= TRUE
;
1093 p
->flags
.search_dirs
= TRUE
;
1095 case lang_input_file_is_marker_enum
:
1097 p
->local_sym_name
= name
;
1098 p
->flags
.search_dirs
= TRUE
;
1100 case lang_input_file_is_search_file_enum
:
1102 p
->local_sym_name
= name
;
1103 p
->flags
.real
= TRUE
;
1104 p
->flags
.search_dirs
= TRUE
;
1106 case lang_input_file_is_file_enum
:
1108 p
->local_sym_name
= name
;
1109 p
->flags
.real
= TRUE
;
1115 lang_statement_append (&input_file_chain
,
1116 (lang_statement_union_type
*) p
,
1117 &p
->next_real_file
);
1121 lang_input_statement_type
*
1122 lang_add_input_file (const char *name
,
1123 lang_input_file_enum_type file_type
,
1126 if (name
!= NULL
&& *name
== '=')
1128 lang_input_statement_type
*ret
;
1129 char *sysrooted_name
1130 = concat (ld_sysroot
, name
+ 1, (const char *) NULL
);
1132 /* We've now forcibly prepended the sysroot, making the input
1133 file independent of the context. Therefore, temporarily
1134 force a non-sysrooted context for this statement, so it won't
1135 get the sysroot prepended again when opened. (N.B. if it's a
1136 script, any child nodes with input files starting with "/"
1137 will be handled as "sysrooted" as they'll be found to be
1138 within the sysroot subdirectory.) */
1139 unsigned int outer_sysrooted
= input_flags
.sysrooted
;
1140 input_flags
.sysrooted
= 0;
1141 ret
= new_afile (sysrooted_name
, file_type
, target
, TRUE
);
1142 input_flags
.sysrooted
= outer_sysrooted
;
1146 return new_afile (name
, file_type
, target
, TRUE
);
1149 struct out_section_hash_entry
1151 struct bfd_hash_entry root
;
1152 lang_statement_union_type s
;
1155 /* The hash table. */
1157 static struct bfd_hash_table output_section_statement_table
;
1159 /* Support routines for the hash table used by lang_output_section_find,
1160 initialize the table, fill in an entry and remove the table. */
1162 static struct bfd_hash_entry
*
1163 output_section_statement_newfunc (struct bfd_hash_entry
*entry
,
1164 struct bfd_hash_table
*table
,
1167 lang_output_section_statement_type
**nextp
;
1168 struct out_section_hash_entry
*ret
;
1172 entry
= (struct bfd_hash_entry
*) bfd_hash_allocate (table
,
1178 entry
= bfd_hash_newfunc (entry
, table
, string
);
1182 ret
= (struct out_section_hash_entry
*) entry
;
1183 memset (&ret
->s
, 0, sizeof (ret
->s
));
1184 ret
->s
.header
.type
= lang_output_section_statement_enum
;
1185 ret
->s
.output_section_statement
.subsection_alignment
= -1;
1186 ret
->s
.output_section_statement
.section_alignment
= -1;
1187 ret
->s
.output_section_statement
.block_value
= 1;
1188 lang_list_init (&ret
->s
.output_section_statement
.children
);
1189 lang_statement_append (stat_ptr
, &ret
->s
, &ret
->s
.header
.next
);
1191 /* For every output section statement added to the list, except the
1192 first one, lang_output_section_statement.tail points to the "next"
1193 field of the last element of the list. */
1194 if (lang_output_section_statement
.head
!= NULL
)
1195 ret
->s
.output_section_statement
.prev
1196 = ((lang_output_section_statement_type
*)
1197 ((char *) lang_output_section_statement
.tail
1198 - offsetof (lang_output_section_statement_type
, next
)));
1200 /* GCC's strict aliasing rules prevent us from just casting the
1201 address, so we store the pointer in a variable and cast that
1203 nextp
= &ret
->s
.output_section_statement
.next
;
1204 lang_statement_append (&lang_output_section_statement
,
1206 (lang_statement_union_type
**) nextp
);
1211 output_section_statement_table_init (void)
1213 if (!bfd_hash_table_init_n (&output_section_statement_table
,
1214 output_section_statement_newfunc
,
1215 sizeof (struct out_section_hash_entry
),
1217 einfo (_("%P%F: can not create hash table: %E\n"));
1221 output_section_statement_table_free (void)
1223 bfd_hash_table_free (&output_section_statement_table
);
1226 /* Build enough state so that the parser can build its tree. */
1231 obstack_begin (&stat_obstack
, 1000);
1233 stat_ptr
= &statement_list
;
1235 output_section_statement_table_init ();
1237 lang_list_init (stat_ptr
);
1239 lang_list_init (&input_file_chain
);
1240 lang_list_init (&lang_output_section_statement
);
1241 lang_list_init (&file_chain
);
1242 first_file
= lang_add_input_file (NULL
, lang_input_file_is_marker_enum
,
1244 abs_output_section
=
1245 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
, 0, TRUE
);
1247 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
1249 asneeded_list_head
= NULL
;
1250 asneeded_list_tail
= &asneeded_list_head
;
1256 output_section_statement_table_free ();
1259 /*----------------------------------------------------------------------
1260 A region is an area of memory declared with the
1261 MEMORY { name:org=exp, len=exp ... }
1264 We maintain a list of all the regions here.
1266 If no regions are specified in the script, then the default is used
1267 which is created when looked up to be the entire data space.
1269 If create is true we are creating a region inside a MEMORY block.
1270 In this case it is probably an error to create a region that has
1271 already been created. If we are not inside a MEMORY block it is
1272 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1273 and so we issue a warning.
1275 Each region has at least one name. The first name is either
1276 DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add
1277 alias names to an existing region within a script with
1278 REGION_ALIAS (alias, region_name). Each name corresponds to at most one
1281 static lang_memory_region_type
*lang_memory_region_list
;
1282 static lang_memory_region_type
**lang_memory_region_list_tail
1283 = &lang_memory_region_list
;
1285 lang_memory_region_type
*
1286 lang_memory_region_lookup (const char *const name
, bfd_boolean create
)
1288 lang_memory_region_name
*n
;
1289 lang_memory_region_type
*r
;
1290 lang_memory_region_type
*new_region
;
1292 /* NAME is NULL for LMA memspecs if no region was specified. */
1296 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1297 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1298 if (strcmp (n
->name
, name
) == 0)
1301 einfo (_("%P:%S: warning: redeclaration of memory region `%s'\n"),
1306 if (!create
&& strcmp (name
, DEFAULT_MEMORY_REGION
))
1307 einfo (_("%P:%S: warning: memory region `%s' not declared\n"),
1310 new_region
= (lang_memory_region_type
*)
1311 stat_alloc (sizeof (lang_memory_region_type
));
1313 new_region
->name_list
.name
= xstrdup (name
);
1314 new_region
->name_list
.next
= NULL
;
1315 new_region
->next
= NULL
;
1316 new_region
->origin_exp
= NULL
;
1317 new_region
->origin
= 0;
1318 new_region
->length_exp
= NULL
;
1319 new_region
->length
= ~(bfd_size_type
) 0;
1320 new_region
->current
= 0;
1321 new_region
->last_os
= NULL
;
1322 new_region
->flags
= 0;
1323 new_region
->not_flags
= 0;
1324 new_region
->had_full_message
= FALSE
;
1326 *lang_memory_region_list_tail
= new_region
;
1327 lang_memory_region_list_tail
= &new_region
->next
;
1333 lang_memory_region_alias (const char * alias
, const char * region_name
)
1335 lang_memory_region_name
* n
;
1336 lang_memory_region_type
* r
;
1337 lang_memory_region_type
* region
;
1339 /* The default region must be unique. This ensures that it is not necessary
1340 to iterate through the name list if someone wants the check if a region is
1341 the default memory region. */
1342 if (strcmp (region_name
, DEFAULT_MEMORY_REGION
) == 0
1343 || strcmp (alias
, DEFAULT_MEMORY_REGION
) == 0)
1344 einfo (_("%F%P:%S: error: alias for default memory region\n"), NULL
);
1346 /* Look for the target region and check if the alias is not already
1349 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1350 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1352 if (region
== NULL
&& strcmp (n
->name
, region_name
) == 0)
1354 if (strcmp (n
->name
, alias
) == 0)
1355 einfo (_("%F%P:%S: error: redefinition of memory region "
1360 /* Check if the target region exists. */
1362 einfo (_("%F%P:%S: error: memory region `%s' "
1363 "for alias `%s' does not exist\n"),
1364 NULL
, region_name
, alias
);
1366 /* Add alias to region name list. */
1367 n
= (lang_memory_region_name
*) stat_alloc (sizeof (lang_memory_region_name
));
1368 n
->name
= xstrdup (alias
);
1369 n
->next
= region
->name_list
.next
;
1370 region
->name_list
.next
= n
;
1373 static lang_memory_region_type
*
1374 lang_memory_default (asection
* section
)
1376 lang_memory_region_type
*p
;
1378 flagword sec_flags
= section
->flags
;
1380 /* Override SEC_DATA to mean a writable section. */
1381 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
1382 sec_flags
|= SEC_DATA
;
1384 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
1386 if ((p
->flags
& sec_flags
) != 0
1387 && (p
->not_flags
& sec_flags
) == 0)
1392 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
1395 /* Get the output section statement directly from the userdata. */
1397 lang_output_section_statement_type
*
1398 lang_output_section_get (const asection
*output_section
)
1400 return get_userdata (output_section
);
1403 /* Find or create an output_section_statement with the given NAME.
1404 If CONSTRAINT is non-zero match one with that constraint, otherwise
1405 match any non-negative constraint. If CREATE, always make a
1406 new output_section_statement for SPECIAL CONSTRAINT. */
1408 lang_output_section_statement_type
*
1409 lang_output_section_statement_lookup (const char *name
,
1413 struct out_section_hash_entry
*entry
;
1415 entry
= ((struct out_section_hash_entry
*)
1416 bfd_hash_lookup (&output_section_statement_table
, name
,
1421 einfo (_("%P%F: failed creating section `%s': %E\n"), name
);
1425 if (entry
->s
.output_section_statement
.name
!= NULL
)
1427 /* We have a section of this name, but it might not have the correct
1429 struct out_section_hash_entry
*last_ent
;
1431 name
= entry
->s
.output_section_statement
.name
;
1432 if (create
&& constraint
== SPECIAL
)
1433 /* Not traversing to the end reverses the order of the second
1434 and subsequent SPECIAL sections in the hash table chain,
1435 but that shouldn't matter. */
1440 if (constraint
== entry
->s
.output_section_statement
.constraint
1442 && entry
->s
.output_section_statement
.constraint
>= 0))
1443 return &entry
->s
.output_section_statement
;
1445 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1447 while (entry
!= NULL
1448 && name
== entry
->s
.output_section_statement
.name
);
1454 = ((struct out_section_hash_entry
*)
1455 output_section_statement_newfunc (NULL
,
1456 &output_section_statement_table
,
1460 einfo (_("%P%F: failed creating section `%s': %E\n"), name
);
1463 entry
->root
= last_ent
->root
;
1464 last_ent
->root
.next
= &entry
->root
;
1467 entry
->s
.output_section_statement
.name
= name
;
1468 entry
->s
.output_section_statement
.constraint
= constraint
;
1469 return &entry
->s
.output_section_statement
;
1472 /* Find the next output_section_statement with the same name as OS.
1473 If CONSTRAINT is non-zero, find one with that constraint otherwise
1474 match any non-negative constraint. */
1476 lang_output_section_statement_type
*
1477 next_matching_output_section_statement (lang_output_section_statement_type
*os
,
1480 /* All output_section_statements are actually part of a
1481 struct out_section_hash_entry. */
1482 struct out_section_hash_entry
*entry
= (struct out_section_hash_entry
*)
1484 - offsetof (struct out_section_hash_entry
, s
.output_section_statement
));
1485 const char *name
= os
->name
;
1487 ASSERT (name
== entry
->root
.string
);
1490 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1492 || name
!= entry
->s
.output_section_statement
.name
)
1495 while (constraint
!= entry
->s
.output_section_statement
.constraint
1497 || entry
->s
.output_section_statement
.constraint
< 0));
1499 return &entry
->s
.output_section_statement
;
1502 /* A variant of lang_output_section_find used by place_orphan.
1503 Returns the output statement that should precede a new output
1504 statement for SEC. If an exact match is found on certain flags,
1507 lang_output_section_statement_type
*
1508 lang_output_section_find_by_flags (const asection
*sec
,
1510 lang_output_section_statement_type
**exact
,
1511 lang_match_sec_type_func match_type
)
1513 lang_output_section_statement_type
*first
, *look
, *found
;
1514 flagword look_flags
, differ
;
1516 /* We know the first statement on this list is *ABS*. May as well
1518 first
= &lang_output_section_statement
.head
->output_section_statement
;
1519 first
= first
->next
;
1521 /* First try for an exact match. */
1523 for (look
= first
; look
; look
= look
->next
)
1525 look_flags
= look
->flags
;
1526 if (look
->bfd_section
!= NULL
)
1528 look_flags
= look
->bfd_section
->flags
;
1529 if (match_type
&& !match_type (link_info
.output_bfd
,
1534 differ
= look_flags
^ sec_flags
;
1535 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1536 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1546 if ((sec_flags
& SEC_CODE
) != 0
1547 && (sec_flags
& SEC_ALLOC
) != 0)
1549 /* Try for a rw code section. */
1550 for (look
= first
; look
; look
= look
->next
)
1552 look_flags
= look
->flags
;
1553 if (look
->bfd_section
!= NULL
)
1555 look_flags
= look
->bfd_section
->flags
;
1556 if (match_type
&& !match_type (link_info
.output_bfd
,
1561 differ
= look_flags
^ sec_flags
;
1562 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1563 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1567 else if ((sec_flags
& SEC_READONLY
) != 0
1568 && (sec_flags
& SEC_ALLOC
) != 0)
1570 /* .rodata can go after .text, .sdata2 after .rodata. */
1571 for (look
= first
; look
; look
= look
->next
)
1573 look_flags
= look
->flags
;
1574 if (look
->bfd_section
!= NULL
)
1576 look_flags
= look
->bfd_section
->flags
;
1577 if (match_type
&& !match_type (link_info
.output_bfd
,
1582 differ
= look_flags
^ sec_flags
;
1583 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1584 | SEC_READONLY
| SEC_SMALL_DATA
))
1585 || (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1587 && !(look_flags
& SEC_SMALL_DATA
)))
1591 else if ((sec_flags
& SEC_THREAD_LOCAL
) != 0
1592 && (sec_flags
& SEC_ALLOC
) != 0)
1594 /* .tdata can go after .data, .tbss after .tdata. Treat .tbss
1595 as if it were a loaded section, and don't use match_type. */
1596 bfd_boolean seen_thread_local
= FALSE
;
1599 for (look
= first
; look
; look
= look
->next
)
1601 look_flags
= look
->flags
;
1602 if (look
->bfd_section
!= NULL
)
1603 look_flags
= look
->bfd_section
->flags
;
1605 differ
= look_flags
^ (sec_flags
| SEC_LOAD
| SEC_HAS_CONTENTS
);
1606 if (!(differ
& (SEC_THREAD_LOCAL
| SEC_ALLOC
)))
1608 /* .tdata and .tbss must be adjacent and in that order. */
1609 if (!(look_flags
& SEC_LOAD
)
1610 && (sec_flags
& SEC_LOAD
))
1611 /* ..so if we're at a .tbss section and we're placing
1612 a .tdata section stop looking and return the
1613 previous section. */
1616 seen_thread_local
= TRUE
;
1618 else if (seen_thread_local
)
1620 else if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
)))
1624 else if ((sec_flags
& SEC_SMALL_DATA
) != 0
1625 && (sec_flags
& SEC_ALLOC
) != 0)
1627 /* .sdata goes after .data, .sbss after .sdata. */
1628 for (look
= first
; look
; look
= look
->next
)
1630 look_flags
= look
->flags
;
1631 if (look
->bfd_section
!= NULL
)
1633 look_flags
= look
->bfd_section
->flags
;
1634 if (match_type
&& !match_type (link_info
.output_bfd
,
1639 differ
= look_flags
^ sec_flags
;
1640 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1641 | SEC_THREAD_LOCAL
))
1642 || ((look_flags
& SEC_SMALL_DATA
)
1643 && !(sec_flags
& SEC_HAS_CONTENTS
)))
1647 else if ((sec_flags
& SEC_HAS_CONTENTS
) != 0
1648 && (sec_flags
& SEC_ALLOC
) != 0)
1650 /* .data goes after .rodata. */
1651 for (look
= first
; look
; look
= look
->next
)
1653 look_flags
= look
->flags
;
1654 if (look
->bfd_section
!= NULL
)
1656 look_flags
= look
->bfd_section
->flags
;
1657 if (match_type
&& !match_type (link_info
.output_bfd
,
1662 differ
= look_flags
^ sec_flags
;
1663 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1664 | SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1668 else if ((sec_flags
& SEC_ALLOC
) != 0)
1670 /* .bss goes after any other alloc section. */
1671 for (look
= first
; look
; look
= look
->next
)
1673 look_flags
= look
->flags
;
1674 if (look
->bfd_section
!= NULL
)
1676 look_flags
= look
->bfd_section
->flags
;
1677 if (match_type
&& !match_type (link_info
.output_bfd
,
1682 differ
= look_flags
^ sec_flags
;
1683 if (!(differ
& SEC_ALLOC
))
1689 /* non-alloc go last. */
1690 for (look
= first
; look
; look
= look
->next
)
1692 look_flags
= look
->flags
;
1693 if (look
->bfd_section
!= NULL
)
1694 look_flags
= look
->bfd_section
->flags
;
1695 differ
= look_flags
^ sec_flags
;
1696 if (!(differ
& SEC_DEBUGGING
))
1702 if (found
|| !match_type
)
1705 return lang_output_section_find_by_flags (sec
, sec_flags
, NULL
, NULL
);
1708 /* Find the last output section before given output statement.
1709 Used by place_orphan. */
1712 output_prev_sec_find (lang_output_section_statement_type
*os
)
1714 lang_output_section_statement_type
*lookup
;
1716 for (lookup
= os
->prev
; lookup
!= NULL
; lookup
= lookup
->prev
)
1718 if (lookup
->constraint
< 0)
1721 if (lookup
->bfd_section
!= NULL
&& lookup
->bfd_section
->owner
!= NULL
)
1722 return lookup
->bfd_section
;
1728 /* Look for a suitable place for a new output section statement. The
1729 idea is to skip over anything that might be inside a SECTIONS {}
1730 statement in a script, before we find another output section
1731 statement. Assignments to "dot" before an output section statement
1732 are assumed to belong to it, except in two cases; The first
1733 assignment to dot, and assignments before non-alloc sections.
1734 Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
1735 similar assignments that set the initial address, or we might
1736 insert non-alloc note sections among assignments setting end of
1739 static lang_statement_union_type
**
1740 insert_os_after (lang_output_section_statement_type
*after
)
1742 lang_statement_union_type
**where
;
1743 lang_statement_union_type
**assign
= NULL
;
1744 bfd_boolean ignore_first
;
1747 = after
== &lang_output_section_statement
.head
->output_section_statement
;
1749 for (where
= &after
->header
.next
;
1751 where
= &(*where
)->header
.next
)
1753 switch ((*where
)->header
.type
)
1755 case lang_assignment_statement_enum
:
1758 lang_assignment_statement_type
*ass
;
1760 ass
= &(*where
)->assignment_statement
;
1761 if (ass
->exp
->type
.node_class
!= etree_assert
1762 && ass
->exp
->assign
.dst
[0] == '.'
1763 && ass
->exp
->assign
.dst
[1] == 0
1767 ignore_first
= FALSE
;
1769 case lang_wild_statement_enum
:
1770 case lang_input_section_enum
:
1771 case lang_object_symbols_statement_enum
:
1772 case lang_fill_statement_enum
:
1773 case lang_data_statement_enum
:
1774 case lang_reloc_statement_enum
:
1775 case lang_padding_statement_enum
:
1776 case lang_constructors_statement_enum
:
1779 case lang_output_section_statement_enum
:
1782 asection
*s
= (*where
)->output_section_statement
.bfd_section
;
1785 || s
->map_head
.s
== NULL
1786 || (s
->flags
& SEC_ALLOC
) != 0)
1790 case lang_input_statement_enum
:
1791 case lang_address_statement_enum
:
1792 case lang_target_statement_enum
:
1793 case lang_output_statement_enum
:
1794 case lang_group_statement_enum
:
1795 case lang_insert_statement_enum
:
1804 lang_output_section_statement_type
*
1805 lang_insert_orphan (asection
*s
,
1806 const char *secname
,
1808 lang_output_section_statement_type
*after
,
1809 struct orphan_save
*place
,
1810 etree_type
*address
,
1811 lang_statement_list_type
*add_child
)
1813 lang_statement_list_type add
;
1815 lang_assignment_statement_type
*start_assign
;
1816 lang_output_section_statement_type
*os
;
1817 lang_output_section_statement_type
**os_tail
;
1819 /* If we have found an appropriate place for the output section
1820 statements for this orphan, add them to our own private list,
1821 inserting them later into the global statement list. */
1824 lang_list_init (&add
);
1825 push_stat_ptr (&add
);
1828 if (bfd_link_relocatable (&link_info
)
1829 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
1830 address
= exp_intop (0);
1832 os_tail
= ((lang_output_section_statement_type
**)
1833 lang_output_section_statement
.tail
);
1834 os
= lang_enter_output_section_statement (secname
, address
, normal_section
,
1835 NULL
, NULL
, NULL
, constraint
, 0);
1838 start_assign
= NULL
;
1839 if (config
.build_constructors
&& *os_tail
== os
)
1841 /* If the name of the section is representable in C, then create
1842 symbols to mark the start and the end of the section. */
1843 for (ps
= secname
; *ps
!= '\0'; ps
++)
1844 if (! ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
1850 symname
= (char *) xmalloc (ps
- secname
+ sizeof "__start_" + 1);
1851 symname
[0] = bfd_get_symbol_leading_char (link_info
.output_bfd
);
1852 sprintf (symname
+ (symname
[0] != 0), "__start_%s", secname
);
1854 = lang_add_assignment (exp_provide (symname
,
1855 exp_nameop (NAME
, "."),
1860 if (add_child
== NULL
)
1861 add_child
= &os
->children
;
1862 lang_add_section (add_child
, s
, NULL
, os
);
1864 if (after
&& (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) != 0)
1866 const char *region
= (after
->region
1867 ? after
->region
->name_list
.name
1868 : DEFAULT_MEMORY_REGION
);
1869 const char *lma_region
= (after
->lma_region
1870 ? after
->lma_region
->name_list
.name
1872 lang_leave_output_section_statement (NULL
, region
, after
->phdrs
,
1876 lang_leave_output_section_statement (NULL
, DEFAULT_MEMORY_REGION
, NULL
,
1879 if (start_assign
!= NULL
)
1882 lang_assignment_statement_type
*stop_assign
;
1885 symname
= (char *) xmalloc (ps
- secname
+ sizeof "__stop_" + 1);
1886 symname
[0] = bfd_get_symbol_leading_char (link_info
.output_bfd
);
1887 sprintf (symname
+ (symname
[0] != 0), "__stop_%s", secname
);
1889 = lang_add_assignment (exp_provide (symname
,
1890 exp_nameop (NAME
, "."),
1892 /* Evaluate the expression to define the symbol if referenced,
1893 before sizing dynamic sections. */
1894 dot
= os
->bfd_section
->vma
;
1895 exp_fold_tree (start_assign
->exp
, os
->bfd_section
, &dot
);
1896 dot
+= TO_ADDR (s
->size
);
1897 exp_fold_tree (stop_assign
->exp
, os
->bfd_section
, &dot
);
1900 /* Restore the global list pointer. */
1904 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
1906 asection
*snew
, *as
;
1908 snew
= os
->bfd_section
;
1910 /* Shuffle the bfd section list to make the output file look
1911 neater. This is really only cosmetic. */
1912 if (place
->section
== NULL
1913 && after
!= (&lang_output_section_statement
.head
1914 ->output_section_statement
))
1916 asection
*bfd_section
= after
->bfd_section
;
1918 /* If the output statement hasn't been used to place any input
1919 sections (and thus doesn't have an output bfd_section),
1920 look for the closest prior output statement having an
1922 if (bfd_section
== NULL
)
1923 bfd_section
= output_prev_sec_find (after
);
1925 if (bfd_section
!= NULL
&& bfd_section
!= snew
)
1926 place
->section
= &bfd_section
->next
;
1929 if (place
->section
== NULL
)
1930 place
->section
= &link_info
.output_bfd
->sections
;
1932 as
= *place
->section
;
1936 /* Put the section at the end of the list. */
1938 /* Unlink the section. */
1939 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1941 /* Now tack it back on in the right place. */
1942 bfd_section_list_append (link_info
.output_bfd
, snew
);
1944 else if (as
!= snew
&& as
->prev
!= snew
)
1946 /* Unlink the section. */
1947 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1949 /* Now tack it back on in the right place. */
1950 bfd_section_list_insert_before (link_info
.output_bfd
, as
, snew
);
1953 /* Save the end of this list. Further ophans of this type will
1954 follow the one we've just added. */
1955 place
->section
= &snew
->next
;
1957 /* The following is non-cosmetic. We try to put the output
1958 statements in some sort of reasonable order here, because they
1959 determine the final load addresses of the orphan sections.
1960 In addition, placing output statements in the wrong order may
1961 require extra segments. For instance, given a typical
1962 situation of all read-only sections placed in one segment and
1963 following that a segment containing all the read-write
1964 sections, we wouldn't want to place an orphan read/write
1965 section before or amongst the read-only ones. */
1966 if (add
.head
!= NULL
)
1968 lang_output_section_statement_type
*newly_added_os
;
1970 if (place
->stmt
== NULL
)
1972 lang_statement_union_type
**where
= insert_os_after (after
);
1977 place
->os_tail
= &after
->next
;
1981 /* Put it after the last orphan statement we added. */
1982 *add
.tail
= *place
->stmt
;
1983 *place
->stmt
= add
.head
;
1986 /* Fix the global list pointer if we happened to tack our
1987 new list at the tail. */
1988 if (*stat_ptr
->tail
== add
.head
)
1989 stat_ptr
->tail
= add
.tail
;
1991 /* Save the end of this list. */
1992 place
->stmt
= add
.tail
;
1994 /* Do the same for the list of output section statements. */
1995 newly_added_os
= *os_tail
;
1997 newly_added_os
->prev
= (lang_output_section_statement_type
*)
1998 ((char *) place
->os_tail
1999 - offsetof (lang_output_section_statement_type
, next
));
2000 newly_added_os
->next
= *place
->os_tail
;
2001 if (newly_added_os
->next
!= NULL
)
2002 newly_added_os
->next
->prev
= newly_added_os
;
2003 *place
->os_tail
= newly_added_os
;
2004 place
->os_tail
= &newly_added_os
->next
;
2006 /* Fixing the global list pointer here is a little different.
2007 We added to the list in lang_enter_output_section_statement,
2008 trimmed off the new output_section_statment above when
2009 assigning *os_tail = NULL, but possibly added it back in
2010 the same place when assigning *place->os_tail. */
2011 if (*os_tail
== NULL
)
2012 lang_output_section_statement
.tail
2013 = (lang_statement_union_type
**) os_tail
;
2020 lang_print_asneeded (void)
2022 struct asneeded_minfo
*m
;
2025 if (asneeded_list_head
== NULL
)
2028 sprintf (buf
, _("\nAs-needed library included "
2029 "to satisfy reference by file (symbol)\n\n"));
2032 for (m
= asneeded_list_head
; m
!= NULL
; m
= m
->next
)
2036 minfo ("%s", m
->soname
);
2037 len
= strlen (m
->soname
);
2051 minfo ("%B ", m
->ref
);
2052 minfo ("(%T)\n", m
->name
);
2057 lang_map_flags (flagword flag
)
2059 if (flag
& SEC_ALLOC
)
2062 if (flag
& SEC_CODE
)
2065 if (flag
& SEC_READONLY
)
2068 if (flag
& SEC_DATA
)
2071 if (flag
& SEC_LOAD
)
2078 lang_memory_region_type
*m
;
2079 bfd_boolean dis_header_printed
= FALSE
;
2081 LANG_FOR_EACH_INPUT_STATEMENT (file
)
2085 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
2086 || file
->flags
.just_syms
)
2089 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2090 if ((s
->output_section
== NULL
2091 || s
->output_section
->owner
!= link_info
.output_bfd
)
2092 && (s
->flags
& (SEC_LINKER_CREATED
| SEC_KEEP
)) == 0)
2094 if (! dis_header_printed
)
2096 fprintf (config
.map_file
, _("\nDiscarded input sections\n\n"));
2097 dis_header_printed
= TRUE
;
2100 print_input_section (s
, TRUE
);
2104 minfo (_("\nMemory Configuration\n\n"));
2105 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
2106 _("Name"), _("Origin"), _("Length"), _("Attributes"));
2108 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
2113 fprintf (config
.map_file
, "%-16s ", m
->name_list
.name
);
2115 sprintf_vma (buf
, m
->origin
);
2116 minfo ("0x%s ", buf
);
2124 minfo ("0x%V", m
->length
);
2125 if (m
->flags
|| m
->not_flags
)
2133 lang_map_flags (m
->flags
);
2139 lang_map_flags (m
->not_flags
);
2146 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
2148 if (! link_info
.reduce_memory_overheads
)
2150 obstack_begin (&map_obstack
, 1000);
2151 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
2153 lang_statement_iteration
++;
2154 print_statements ();
2156 ldemul_extra_map_file_text (link_info
.output_bfd
, &link_info
, config
.map_file
);
2160 sort_def_symbol (struct bfd_link_hash_entry
*hash_entry
,
2161 void *info ATTRIBUTE_UNUSED
)
2163 if ((hash_entry
->type
== bfd_link_hash_defined
2164 || hash_entry
->type
== bfd_link_hash_defweak
)
2165 && hash_entry
->u
.def
.section
->owner
!= link_info
.output_bfd
2166 && hash_entry
->u
.def
.section
->owner
!= NULL
)
2168 input_section_userdata_type
*ud
;
2169 struct map_symbol_def
*def
;
2171 ud
= ((input_section_userdata_type
*)
2172 get_userdata (hash_entry
->u
.def
.section
));
2175 ud
= (input_section_userdata_type
*) stat_alloc (sizeof (*ud
));
2176 get_userdata (hash_entry
->u
.def
.section
) = ud
;
2177 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2178 ud
->map_symbol_def_count
= 0;
2180 else if (!ud
->map_symbol_def_tail
)
2181 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2183 def
= (struct map_symbol_def
*) obstack_alloc (&map_obstack
, sizeof *def
);
2184 def
->entry
= hash_entry
;
2185 *(ud
->map_symbol_def_tail
) = def
;
2186 ud
->map_symbol_def_tail
= &def
->next
;
2187 ud
->map_symbol_def_count
++;
2192 /* Initialize an output section. */
2195 init_os (lang_output_section_statement_type
*s
, flagword flags
)
2197 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
2198 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
2200 if (s
->constraint
!= SPECIAL
)
2201 s
->bfd_section
= bfd_get_section_by_name (link_info
.output_bfd
, s
->name
);
2202 if (s
->bfd_section
== NULL
)
2203 s
->bfd_section
= bfd_make_section_anyway_with_flags (link_info
.output_bfd
,
2205 if (s
->bfd_section
== NULL
)
2207 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
2208 link_info
.output_bfd
->xvec
->name
, s
->name
);
2210 s
->bfd_section
->output_section
= s
->bfd_section
;
2211 s
->bfd_section
->output_offset
= 0;
2213 /* Set the userdata of the output section to the output section
2214 statement to avoid lookup. */
2215 get_userdata (s
->bfd_section
) = s
;
2217 /* If there is a base address, make sure that any sections it might
2218 mention are initialized. */
2219 if (s
->addr_tree
!= NULL
)
2220 exp_init_os (s
->addr_tree
);
2222 if (s
->load_base
!= NULL
)
2223 exp_init_os (s
->load_base
);
2225 /* If supplied an alignment, set it. */
2226 if (s
->section_alignment
!= -1)
2227 s
->bfd_section
->alignment_power
= s
->section_alignment
;
2230 /* Make sure that all output sections mentioned in an expression are
2234 exp_init_os (etree_type
*exp
)
2236 switch (exp
->type
.node_class
)
2240 exp_init_os (exp
->assign
.src
);
2244 exp_init_os (exp
->binary
.lhs
);
2245 exp_init_os (exp
->binary
.rhs
);
2249 exp_init_os (exp
->trinary
.cond
);
2250 exp_init_os (exp
->trinary
.lhs
);
2251 exp_init_os (exp
->trinary
.rhs
);
2255 exp_init_os (exp
->assert_s
.child
);
2259 exp_init_os (exp
->unary
.child
);
2263 switch (exp
->type
.node_code
)
2269 lang_output_section_statement_type
*os
;
2271 os
= lang_output_section_find (exp
->name
.name
);
2272 if (os
!= NULL
&& os
->bfd_section
== NULL
)
2284 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
2286 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
2288 /* If we are only reading symbols from this object, then we want to
2289 discard all sections. */
2290 if (entry
->flags
.just_syms
)
2292 bfd_link_just_syms (abfd
, sec
, &link_info
);
2296 if (!(abfd
->flags
& DYNAMIC
))
2297 bfd_section_already_linked (abfd
, sec
, &link_info
);
2300 /* The wild routines.
2302 These expand statements like *(.text) and foo.o to a list of
2303 explicit actions, like foo.o(.text), bar.o(.text) and
2304 foo.o(.text, .data). */
2306 /* Add SECTION to the output section OUTPUT. Do this by creating a
2307 lang_input_section statement which is placed at PTR. */
2310 lang_add_section (lang_statement_list_type
*ptr
,
2312 struct flag_info
*sflag_info
,
2313 lang_output_section_statement_type
*output
)
2315 flagword flags
= section
->flags
;
2317 bfd_boolean discard
;
2318 lang_input_section_type
*new_section
;
2319 bfd
*abfd
= link_info
.output_bfd
;
2321 /* Discard sections marked with SEC_EXCLUDE. */
2322 discard
= (flags
& SEC_EXCLUDE
) != 0;
2324 /* Discard input sections which are assigned to a section named
2325 DISCARD_SECTION_NAME. */
2326 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
2329 /* Discard debugging sections if we are stripping debugging
2331 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
2332 && (flags
& SEC_DEBUGGING
) != 0)
2337 if (section
->output_section
== NULL
)
2339 /* This prevents future calls from assigning this section. */
2340 section
->output_section
= bfd_abs_section_ptr
;
2349 keep
= bfd_lookup_section_flags (&link_info
, sflag_info
, section
);
2354 if (section
->output_section
!= NULL
)
2357 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2358 to an output section, because we want to be able to include a
2359 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2360 section (I don't know why we want to do this, but we do).
2361 build_link_order in ldwrite.c handles this case by turning
2362 the embedded SEC_NEVER_LOAD section into a fill. */
2363 flags
&= ~ SEC_NEVER_LOAD
;
2365 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2366 already been processed. One reason to do this is that on pe
2367 format targets, .text$foo sections go into .text and it's odd
2368 to see .text with SEC_LINK_ONCE set. */
2370 if (!bfd_link_relocatable (&link_info
))
2371 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2373 switch (output
->sectype
)
2375 case normal_section
:
2376 case overlay_section
:
2378 case noalloc_section
:
2379 flags
&= ~SEC_ALLOC
;
2381 case noload_section
:
2383 flags
|= SEC_NEVER_LOAD
;
2384 /* Unfortunately GNU ld has managed to evolve two different
2385 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2386 alloc, no contents section. All others get a noload, noalloc
2388 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
2389 flags
&= ~SEC_HAS_CONTENTS
;
2391 flags
&= ~SEC_ALLOC
;
2395 if (output
->bfd_section
== NULL
)
2396 init_os (output
, flags
);
2398 /* If SEC_READONLY is not set in the input section, then clear
2399 it from the output section. */
2400 output
->bfd_section
->flags
&= flags
| ~SEC_READONLY
;
2402 if (output
->bfd_section
->linker_has_input
)
2404 /* Only set SEC_READONLY flag on the first input section. */
2405 flags
&= ~ SEC_READONLY
;
2407 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2408 if ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2409 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2410 || ((flags
& SEC_MERGE
) != 0
2411 && output
->bfd_section
->entsize
!= section
->entsize
))
2413 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2414 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2417 output
->bfd_section
->flags
|= flags
;
2419 if (!output
->bfd_section
->linker_has_input
)
2421 output
->bfd_section
->linker_has_input
= 1;
2422 /* This must happen after flags have been updated. The output
2423 section may have been created before we saw its first input
2424 section, eg. for a data statement. */
2425 bfd_init_private_section_data (section
->owner
, section
,
2426 link_info
.output_bfd
,
2427 output
->bfd_section
,
2429 if ((flags
& SEC_MERGE
) != 0)
2430 output
->bfd_section
->entsize
= section
->entsize
;
2433 if ((flags
& SEC_TIC54X_BLOCK
) != 0
2434 && bfd_get_arch (section
->owner
) == bfd_arch_tic54x
)
2436 /* FIXME: This value should really be obtained from the bfd... */
2437 output
->block_value
= 128;
2440 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2441 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2443 section
->output_section
= output
->bfd_section
;
2445 if (!map_head_is_link_order
)
2447 asection
*s
= output
->bfd_section
->map_tail
.s
;
2448 output
->bfd_section
->map_tail
.s
= section
;
2449 section
->map_head
.s
= NULL
;
2450 section
->map_tail
.s
= s
;
2452 s
->map_head
.s
= section
;
2454 output
->bfd_section
->map_head
.s
= section
;
2457 /* Add a section reference to the list. */
2458 new_section
= new_stat (lang_input_section
, ptr
);
2459 new_section
->section
= section
;
2462 /* Handle wildcard sorting. This returns the lang_input_section which
2463 should follow the one we are going to create for SECTION and FILE,
2464 based on the sorting requirements of WILD. It returns NULL if the
2465 new section should just go at the end of the current list. */
2467 static lang_statement_union_type
*
2468 wild_sort (lang_wild_statement_type
*wild
,
2469 struct wildcard_list
*sec
,
2470 lang_input_statement_type
*file
,
2473 lang_statement_union_type
*l
;
2475 if (!wild
->filenames_sorted
2476 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
2479 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
2481 lang_input_section_type
*ls
;
2483 if (l
->header
.type
!= lang_input_section_enum
)
2485 ls
= &l
->input_section
;
2487 /* Sorting by filename takes precedence over sorting by section
2490 if (wild
->filenames_sorted
)
2492 const char *fn
, *ln
;
2496 /* The PE support for the .idata section as generated by
2497 dlltool assumes that files will be sorted by the name of
2498 the archive and then the name of the file within the
2501 if (file
->the_bfd
!= NULL
2502 && bfd_my_archive (file
->the_bfd
) != NULL
)
2504 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
2509 fn
= file
->filename
;
2513 if (bfd_my_archive (ls
->section
->owner
) != NULL
)
2515 ln
= bfd_get_filename (bfd_my_archive (ls
->section
->owner
));
2520 ln
= ls
->section
->owner
->filename
;
2524 i
= filename_cmp (fn
, ln
);
2533 fn
= file
->filename
;
2535 ln
= ls
->section
->owner
->filename
;
2537 i
= filename_cmp (fn
, ln
);
2545 /* Here either the files are not sorted by name, or we are
2546 looking at the sections for this file. */
2549 && sec
->spec
.sorted
!= none
2550 && sec
->spec
.sorted
!= by_none
)
2551 if (compare_section (sec
->spec
.sorted
, section
, ls
->section
) < 0)
2558 /* Expand a wild statement for a particular FILE. SECTION may be
2559 NULL, in which case it is a wild card. */
2562 output_section_callback (lang_wild_statement_type
*ptr
,
2563 struct wildcard_list
*sec
,
2565 struct flag_info
*sflag_info
,
2566 lang_input_statement_type
*file
,
2569 lang_statement_union_type
*before
;
2570 lang_output_section_statement_type
*os
;
2572 os
= (lang_output_section_statement_type
*) output
;
2574 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2575 if (unique_section_p (section
, os
))
2578 before
= wild_sort (ptr
, sec
, file
, section
);
2580 /* Here BEFORE points to the lang_input_section which
2581 should follow the one we are about to add. If BEFORE
2582 is NULL, then the section should just go at the end
2583 of the current list. */
2586 lang_add_section (&ptr
->children
, section
, sflag_info
, os
);
2589 lang_statement_list_type list
;
2590 lang_statement_union_type
**pp
;
2592 lang_list_init (&list
);
2593 lang_add_section (&list
, section
, sflag_info
, os
);
2595 /* If we are discarding the section, LIST.HEAD will
2597 if (list
.head
!= NULL
)
2599 ASSERT (list
.head
->header
.next
== NULL
);
2601 for (pp
= &ptr
->children
.head
;
2603 pp
= &(*pp
)->header
.next
)
2604 ASSERT (*pp
!= NULL
);
2606 list
.head
->header
.next
= *pp
;
2612 /* Check if all sections in a wild statement for a particular FILE
2616 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2617 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2619 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
2620 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2623 lang_output_section_statement_type
*os
;
2625 os
= (lang_output_section_statement_type
*) output
;
2627 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2628 if (unique_section_p (section
, os
))
2631 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2632 os
->all_input_readonly
= FALSE
;
2635 /* This is passed a file name which must have been seen already and
2636 added to the statement tree. We will see if it has been opened
2637 already and had its symbols read. If not then we'll read it. */
2639 static lang_input_statement_type
*
2640 lookup_name (const char *name
)
2642 lang_input_statement_type
*search
;
2644 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
2646 search
= (lang_input_statement_type
*) search
->next_real_file
)
2648 /* Use the local_sym_name as the name of the file that has
2649 already been loaded as filename might have been transformed
2650 via the search directory lookup mechanism. */
2651 const char *filename
= search
->local_sym_name
;
2653 if (filename
!= NULL
2654 && filename_cmp (filename
, name
) == 0)
2659 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2660 default_target
, FALSE
);
2662 /* If we have already added this file, or this file is not real
2663 don't add this file. */
2664 if (search
->flags
.loaded
|| !search
->flags
.real
)
2667 if (! load_symbols (search
, NULL
))
2673 /* Save LIST as a list of libraries whose symbols should not be exported. */
2678 struct excluded_lib
*next
;
2680 static struct excluded_lib
*excluded_libs
;
2683 add_excluded_libs (const char *list
)
2685 const char *p
= list
, *end
;
2689 struct excluded_lib
*entry
;
2690 end
= strpbrk (p
, ",:");
2692 end
= p
+ strlen (p
);
2693 entry
= (struct excluded_lib
*) xmalloc (sizeof (*entry
));
2694 entry
->next
= excluded_libs
;
2695 entry
->name
= (char *) xmalloc (end
- p
+ 1);
2696 memcpy (entry
->name
, p
, end
- p
);
2697 entry
->name
[end
- p
] = '\0';
2698 excluded_libs
= entry
;
2706 check_excluded_libs (bfd
*abfd
)
2708 struct excluded_lib
*lib
= excluded_libs
;
2712 int len
= strlen (lib
->name
);
2713 const char *filename
= lbasename (abfd
->filename
);
2715 if (strcmp (lib
->name
, "ALL") == 0)
2717 abfd
->no_export
= TRUE
;
2721 if (filename_ncmp (lib
->name
, filename
, len
) == 0
2722 && (filename
[len
] == '\0'
2723 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
2724 && filename
[len
+ 2] == '\0')))
2726 abfd
->no_export
= TRUE
;
2734 /* Get the symbols for an input file. */
2737 load_symbols (lang_input_statement_type
*entry
,
2738 lang_statement_list_type
*place
)
2742 if (entry
->flags
.loaded
)
2745 ldfile_open_file (entry
);
2747 /* Do not process further if the file was missing. */
2748 if (entry
->flags
.missing_file
)
2751 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
2752 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
2755 struct lang_input_statement_flags save_flags
;
2758 err
= bfd_get_error ();
2760 /* See if the emulation has some special knowledge. */
2761 if (ldemul_unrecognized_file (entry
))
2764 if (err
== bfd_error_file_ambiguously_recognized
)
2768 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
2769 einfo (_("%B: matching formats:"), entry
->the_bfd
);
2770 for (p
= matching
; *p
!= NULL
; p
++)
2774 else if (err
!= bfd_error_file_not_recognized
2776 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
2778 bfd_close (entry
->the_bfd
);
2779 entry
->the_bfd
= NULL
;
2781 /* Try to interpret the file as a linker script. */
2782 save_flags
= input_flags
;
2783 ldfile_open_command_file (entry
->filename
);
2785 push_stat_ptr (place
);
2786 input_flags
.add_DT_NEEDED_for_regular
2787 = entry
->flags
.add_DT_NEEDED_for_regular
;
2788 input_flags
.add_DT_NEEDED_for_dynamic
2789 = entry
->flags
.add_DT_NEEDED_for_dynamic
;
2790 input_flags
.whole_archive
= entry
->flags
.whole_archive
;
2791 input_flags
.dynamic
= entry
->flags
.dynamic
;
2793 ldfile_assumed_script
= TRUE
;
2794 parser_input
= input_script
;
2796 ldfile_assumed_script
= FALSE
;
2798 /* missing_file is sticky. sysrooted will already have been
2799 restored when seeing EOF in yyparse, but no harm to restore
2801 save_flags
.missing_file
|= input_flags
.missing_file
;
2802 input_flags
= save_flags
;
2806 entry
->flags
.loaded
= TRUE
;
2811 if (ldemul_recognized_file (entry
))
2814 /* We don't call ldlang_add_file for an archive. Instead, the
2815 add_symbols entry point will call ldlang_add_file, via the
2816 add_archive_element callback, for each element of the archive
2818 switch (bfd_get_format (entry
->the_bfd
))
2824 if (!entry
->flags
.reload
)
2825 ldlang_add_file (entry
);
2826 if (trace_files
|| verbose
)
2827 info_msg ("%I\n", entry
);
2831 check_excluded_libs (entry
->the_bfd
);
2833 if (entry
->flags
.whole_archive
)
2836 bfd_boolean loaded
= TRUE
;
2841 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
2846 if (! bfd_check_format (member
, bfd_object
))
2848 einfo (_("%F%B: member %B in archive is not an object\n"),
2849 entry
->the_bfd
, member
);
2854 if (!(*link_info
.callbacks
2855 ->add_archive_element
) (&link_info
, member
,
2856 "--whole-archive", &subsbfd
))
2859 /* Potentially, the add_archive_element hook may have set a
2860 substitute BFD for us. */
2861 if (!bfd_link_add_symbols (subsbfd
, &link_info
))
2863 einfo (_("%F%B: error adding symbols: %E\n"), member
);
2868 entry
->flags
.loaded
= loaded
;
2874 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
2875 entry
->flags
.loaded
= TRUE
;
2877 einfo (_("%F%B: error adding symbols: %E\n"), entry
->the_bfd
);
2879 return entry
->flags
.loaded
;
2882 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
2883 may be NULL, indicating that it is a wildcard. Separate
2884 lang_input_section statements are created for each part of the
2885 expansion; they are added after the wild statement S. OUTPUT is
2886 the output section. */
2889 wild (lang_wild_statement_type
*s
,
2890 const char *target ATTRIBUTE_UNUSED
,
2891 lang_output_section_statement_type
*output
)
2893 struct wildcard_list
*sec
;
2895 if (s
->handler_data
[0]
2896 && s
->handler_data
[0]->spec
.sorted
== by_name
2897 && !s
->filenames_sorted
)
2899 lang_section_bst_type
*tree
;
2901 walk_wild (s
, output_section_callback_fast
, output
);
2906 output_section_callback_tree_to_list (s
, tree
, output
);
2911 walk_wild (s
, output_section_callback
, output
);
2913 if (default_common_section
== NULL
)
2914 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
2915 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
2917 /* Remember the section that common is going to in case we
2918 later get something which doesn't know where to put it. */
2919 default_common_section
= output
;
2924 /* Return TRUE iff target is the sought target. */
2927 get_target (const bfd_target
*target
, void *data
)
2929 const char *sought
= (const char *) data
;
2931 return strcmp (target
->name
, sought
) == 0;
2934 /* Like strcpy() but convert to lower case as well. */
2937 stricpy (char *dest
, char *src
)
2941 while ((c
= *src
++) != 0)
2942 *dest
++ = TOLOWER (c
);
2947 /* Remove the first occurrence of needle (if any) in haystack
2951 strcut (char *haystack
, char *needle
)
2953 haystack
= strstr (haystack
, needle
);
2959 for (src
= haystack
+ strlen (needle
); *src
;)
2960 *haystack
++ = *src
++;
2966 /* Compare two target format name strings.
2967 Return a value indicating how "similar" they are. */
2970 name_compare (char *first
, char *second
)
2976 copy1
= (char *) xmalloc (strlen (first
) + 1);
2977 copy2
= (char *) xmalloc (strlen (second
) + 1);
2979 /* Convert the names to lower case. */
2980 stricpy (copy1
, first
);
2981 stricpy (copy2
, second
);
2983 /* Remove size and endian strings from the name. */
2984 strcut (copy1
, "big");
2985 strcut (copy1
, "little");
2986 strcut (copy2
, "big");
2987 strcut (copy2
, "little");
2989 /* Return a value based on how many characters match,
2990 starting from the beginning. If both strings are
2991 the same then return 10 * their length. */
2992 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
2993 if (copy1
[result
] == 0)
3005 /* Set by closest_target_match() below. */
3006 static const bfd_target
*winner
;
3008 /* Scan all the valid bfd targets looking for one that has the endianness
3009 requirement that was specified on the command line, and is the nearest
3010 match to the original output target. */
3013 closest_target_match (const bfd_target
*target
, void *data
)
3015 const bfd_target
*original
= (const bfd_target
*) data
;
3017 if (command_line
.endian
== ENDIAN_BIG
3018 && target
->byteorder
!= BFD_ENDIAN_BIG
)
3021 if (command_line
.endian
== ENDIAN_LITTLE
3022 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
3025 /* Must be the same flavour. */
3026 if (target
->flavour
!= original
->flavour
)
3029 /* Ignore generic big and little endian elf vectors. */
3030 if (strcmp (target
->name
, "elf32-big") == 0
3031 || strcmp (target
->name
, "elf64-big") == 0
3032 || strcmp (target
->name
, "elf32-little") == 0
3033 || strcmp (target
->name
, "elf64-little") == 0)
3036 /* If we have not found a potential winner yet, then record this one. */
3043 /* Oh dear, we now have two potential candidates for a successful match.
3044 Compare their names and choose the better one. */
3045 if (name_compare (target
->name
, original
->name
)
3046 > name_compare (winner
->name
, original
->name
))
3049 /* Keep on searching until wqe have checked them all. */
3053 /* Return the BFD target format of the first input file. */
3056 get_first_input_target (void)
3058 char *target
= NULL
;
3060 LANG_FOR_EACH_INPUT_STATEMENT (s
)
3062 if (s
->header
.type
== lang_input_statement_enum
3065 ldfile_open_file (s
);
3067 if (s
->the_bfd
!= NULL
3068 && bfd_check_format (s
->the_bfd
, bfd_object
))
3070 target
= bfd_get_target (s
->the_bfd
);
3082 lang_get_output_target (void)
3086 /* Has the user told us which output format to use? */
3087 if (output_target
!= NULL
)
3088 return output_target
;
3090 /* No - has the current target been set to something other than
3092 if (current_target
!= default_target
&& current_target
!= NULL
)
3093 return current_target
;
3095 /* No - can we determine the format of the first input file? */
3096 target
= get_first_input_target ();
3100 /* Failed - use the default output target. */
3101 return default_target
;
3104 /* Open the output file. */
3107 open_output (const char *name
)
3109 output_target
= lang_get_output_target ();
3111 /* Has the user requested a particular endianness on the command
3113 if (command_line
.endian
!= ENDIAN_UNSET
)
3115 const bfd_target
*target
;
3116 enum bfd_endian desired_endian
;
3118 /* Get the chosen target. */
3119 target
= bfd_search_for_target (get_target
, (void *) output_target
);
3121 /* If the target is not supported, we cannot do anything. */
3124 if (command_line
.endian
== ENDIAN_BIG
)
3125 desired_endian
= BFD_ENDIAN_BIG
;
3127 desired_endian
= BFD_ENDIAN_LITTLE
;
3129 /* See if the target has the wrong endianness. This should
3130 not happen if the linker script has provided big and
3131 little endian alternatives, but some scrips don't do
3133 if (target
->byteorder
!= desired_endian
)
3135 /* If it does, then see if the target provides
3136 an alternative with the correct endianness. */
3137 if (target
->alternative_target
!= NULL
3138 && (target
->alternative_target
->byteorder
== desired_endian
))
3139 output_target
= target
->alternative_target
->name
;
3142 /* Try to find a target as similar as possible to
3143 the default target, but which has the desired
3144 endian characteristic. */
3145 bfd_search_for_target (closest_target_match
,
3148 /* Oh dear - we could not find any targets that
3149 satisfy our requirements. */
3151 einfo (_("%P: warning: could not find any targets"
3152 " that match endianness requirement\n"));
3154 output_target
= winner
->name
;
3160 link_info
.output_bfd
= bfd_openw (name
, output_target
);
3162 if (link_info
.output_bfd
== NULL
)
3164 if (bfd_get_error () == bfd_error_invalid_target
)
3165 einfo (_("%P%F: target %s not found\n"), output_target
);
3167 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
3170 delete_output_file_on_failure
= TRUE
;
3172 if (! bfd_set_format (link_info
.output_bfd
, bfd_object
))
3173 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
3174 if (! bfd_set_arch_mach (link_info
.output_bfd
,
3175 ldfile_output_architecture
,
3176 ldfile_output_machine
))
3177 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
3179 link_info
.hash
= bfd_link_hash_table_create (link_info
.output_bfd
);
3180 if (link_info
.hash
== NULL
)
3181 einfo (_("%P%F: can not create hash table: %E\n"));
3183 bfd_set_gp_size (link_info
.output_bfd
, g_switch_value
);
3187 ldlang_open_output (lang_statement_union_type
*statement
)
3189 switch (statement
->header
.type
)
3191 case lang_output_statement_enum
:
3192 ASSERT (link_info
.output_bfd
== NULL
);
3193 open_output (statement
->output_statement
.name
);
3194 ldemul_set_output_arch ();
3195 if (config
.magic_demand_paged
3196 && !bfd_link_relocatable (&link_info
))
3197 link_info
.output_bfd
->flags
|= D_PAGED
;
3199 link_info
.output_bfd
->flags
&= ~D_PAGED
;
3200 if (config
.text_read_only
)
3201 link_info
.output_bfd
->flags
|= WP_TEXT
;
3203 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
3204 if (link_info
.traditional_format
)
3205 link_info
.output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
3207 link_info
.output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
3210 case lang_target_statement_enum
:
3211 current_target
= statement
->target_statement
.target
;
3221 unsigned x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3222 ldfile_output_machine
);
3225 while ((x
& 1) == 0)
3233 /* Open all the input files. */
3237 OPEN_BFD_NORMAL
= 0,
3241 #ifdef ENABLE_PLUGINS
3242 static lang_input_statement_type
*plugin_insert
= NULL
;
3246 open_input_bfds (lang_statement_union_type
*s
, enum open_bfd_mode mode
)
3248 for (; s
!= NULL
; s
= s
->header
.next
)
3250 switch (s
->header
.type
)
3252 case lang_constructors_statement_enum
:
3253 open_input_bfds (constructor_list
.head
, mode
);
3255 case lang_output_section_statement_enum
:
3256 open_input_bfds (s
->output_section_statement
.children
.head
, mode
);
3258 case lang_wild_statement_enum
:
3259 /* Maybe we should load the file's symbols. */
3260 if ((mode
& OPEN_BFD_RESCAN
) == 0
3261 && s
->wild_statement
.filename
3262 && !wildcardp (s
->wild_statement
.filename
)
3263 && !archive_path (s
->wild_statement
.filename
))
3264 lookup_name (s
->wild_statement
.filename
);
3265 open_input_bfds (s
->wild_statement
.children
.head
, mode
);
3267 case lang_group_statement_enum
:
3269 struct bfd_link_hash_entry
*undefs
;
3271 /* We must continually search the entries in the group
3272 until no new symbols are added to the list of undefined
3277 undefs
= link_info
.hash
->undefs_tail
;
3278 open_input_bfds (s
->group_statement
.children
.head
,
3279 mode
| OPEN_BFD_FORCE
);
3281 while (undefs
!= link_info
.hash
->undefs_tail
);
3284 case lang_target_statement_enum
:
3285 current_target
= s
->target_statement
.target
;
3287 case lang_input_statement_enum
:
3288 if (s
->input_statement
.flags
.real
)
3290 lang_statement_union_type
**os_tail
;
3291 lang_statement_list_type add
;
3294 s
->input_statement
.target
= current_target
;
3296 /* If we are being called from within a group, and this
3297 is an archive which has already been searched, then
3298 force it to be researched unless the whole archive
3299 has been loaded already. Do the same for a rescan.
3300 Likewise reload --as-needed shared libs. */
3301 if (mode
!= OPEN_BFD_NORMAL
3302 #ifdef ENABLE_PLUGINS
3303 && ((mode
& OPEN_BFD_RESCAN
) == 0
3304 || plugin_insert
== NULL
)
3306 && s
->input_statement
.flags
.loaded
3307 && (abfd
= s
->input_statement
.the_bfd
) != NULL
3308 && ((bfd_get_format (abfd
) == bfd_archive
3309 && !s
->input_statement
.flags
.whole_archive
)
3310 || (bfd_get_format (abfd
) == bfd_object
3311 && ((abfd
->flags
) & DYNAMIC
) != 0
3312 && s
->input_statement
.flags
.add_DT_NEEDED_for_regular
3313 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3314 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)))
3316 s
->input_statement
.flags
.loaded
= FALSE
;
3317 s
->input_statement
.flags
.reload
= TRUE
;
3320 os_tail
= lang_output_section_statement
.tail
;
3321 lang_list_init (&add
);
3323 if (! load_symbols (&s
->input_statement
, &add
))
3324 config
.make_executable
= FALSE
;
3326 if (add
.head
!= NULL
)
3328 /* If this was a script with output sections then
3329 tack any added statements on to the end of the
3330 list. This avoids having to reorder the output
3331 section statement list. Very likely the user
3332 forgot -T, and whatever we do here will not meet
3333 naive user expectations. */
3334 if (os_tail
!= lang_output_section_statement
.tail
)
3336 einfo (_("%P: warning: %s contains output sections;"
3337 " did you forget -T?\n"),
3338 s
->input_statement
.filename
);
3339 *stat_ptr
->tail
= add
.head
;
3340 stat_ptr
->tail
= add
.tail
;
3344 *add
.tail
= s
->header
.next
;
3345 s
->header
.next
= add
.head
;
3349 #ifdef ENABLE_PLUGINS
3350 /* If we have found the point at which a plugin added new
3351 files, clear plugin_insert to enable archive rescan. */
3352 if (&s
->input_statement
== plugin_insert
)
3353 plugin_insert
= NULL
;
3356 case lang_assignment_statement_enum
:
3357 if (s
->assignment_statement
.exp
->assign
.defsym
)
3358 /* This is from a --defsym on the command line. */
3359 exp_fold_tree_no_dot (s
->assignment_statement
.exp
);
3366 /* Exit if any of the files were missing. */
3367 if (input_flags
.missing_file
)
3371 /* Add the supplied name to the symbol table as an undefined reference.
3372 This is a two step process as the symbol table doesn't even exist at
3373 the time the ld command line is processed. First we put the name
3374 on a list, then, once the output file has been opened, transfer the
3375 name to the symbol table. */
3377 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3379 #define ldlang_undef_chain_list_head entry_symbol.next
3382 ldlang_add_undef (const char *const name
, bfd_boolean cmdline
)
3384 ldlang_undef_chain_list_type
*new_undef
;
3386 undef_from_cmdline
= undef_from_cmdline
|| cmdline
;
3387 new_undef
= (ldlang_undef_chain_list_type
*) stat_alloc (sizeof (*new_undef
));
3388 new_undef
->next
= ldlang_undef_chain_list_head
;
3389 ldlang_undef_chain_list_head
= new_undef
;
3391 new_undef
->name
= xstrdup (name
);
3393 if (link_info
.output_bfd
!= NULL
)
3394 insert_undefined (new_undef
->name
);
3397 /* Insert NAME as undefined in the symbol table. */
3400 insert_undefined (const char *name
)
3402 struct bfd_link_hash_entry
*h
;
3404 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
3406 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3407 if (h
->type
== bfd_link_hash_new
)
3409 h
->type
= bfd_link_hash_undefined
;
3410 h
->u
.undef
.abfd
= NULL
;
3411 bfd_link_add_undef (link_info
.hash
, h
);
3415 /* Run through the list of undefineds created above and place them
3416 into the linker hash table as undefined symbols belonging to the
3420 lang_place_undefineds (void)
3422 ldlang_undef_chain_list_type
*ptr
;
3424 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3425 insert_undefined (ptr
->name
);
3428 /* Structure used to build the list of symbols that the user has required
3431 struct require_defined_symbol
3434 struct require_defined_symbol
*next
;
3437 /* The list of symbols that the user has required be defined. */
3439 static struct require_defined_symbol
*require_defined_symbol_list
;
3441 /* Add a new symbol NAME to the list of symbols that are required to be
3445 ldlang_add_require_defined (const char * const name
)
3447 struct require_defined_symbol
*ptr
;
3449 ldlang_add_undef (name
, TRUE
);
3450 ptr
= (struct require_defined_symbol
*) stat_alloc (sizeof (*ptr
));
3451 ptr
->next
= require_defined_symbol_list
;
3452 ptr
->name
= strdup (name
);
3453 require_defined_symbol_list
= ptr
;
3456 /* Check that all symbols the user required to be defined, are defined,
3457 raise an error if we find a symbol that is not defined. */
3460 ldlang_check_require_defined_symbols (void)
3462 struct require_defined_symbol
*ptr
;
3464 for (ptr
= require_defined_symbol_list
; ptr
!= NULL
; ptr
= ptr
->next
)
3466 struct bfd_link_hash_entry
*h
;
3468 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
,
3469 FALSE
, FALSE
, TRUE
);
3471 || (h
->type
!= bfd_link_hash_defined
3472 && h
->type
!= bfd_link_hash_defweak
))
3473 einfo(_("%P%X: required symbol `%s' not defined\n"), ptr
->name
);
3477 /* Check for all readonly or some readwrite sections. */
3480 check_input_sections
3481 (lang_statement_union_type
*s
,
3482 lang_output_section_statement_type
*output_section_statement
)
3484 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
3486 switch (s
->header
.type
)
3488 case lang_wild_statement_enum
:
3489 walk_wild (&s
->wild_statement
, check_section_callback
,
3490 output_section_statement
);
3491 if (! output_section_statement
->all_input_readonly
)
3494 case lang_constructors_statement_enum
:
3495 check_input_sections (constructor_list
.head
,
3496 output_section_statement
);
3497 if (! output_section_statement
->all_input_readonly
)
3500 case lang_group_statement_enum
:
3501 check_input_sections (s
->group_statement
.children
.head
,
3502 output_section_statement
);
3503 if (! output_section_statement
->all_input_readonly
)
3512 /* Update wildcard statements if needed. */
3515 update_wild_statements (lang_statement_union_type
*s
)
3517 struct wildcard_list
*sec
;
3519 switch (sort_section
)
3529 for (; s
!= NULL
; s
= s
->header
.next
)
3531 switch (s
->header
.type
)
3536 case lang_wild_statement_enum
:
3537 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
3540 switch (sec
->spec
.sorted
)
3543 sec
->spec
.sorted
= sort_section
;
3546 if (sort_section
== by_alignment
)
3547 sec
->spec
.sorted
= by_name_alignment
;
3550 if (sort_section
== by_name
)
3551 sec
->spec
.sorted
= by_alignment_name
;
3559 case lang_constructors_statement_enum
:
3560 update_wild_statements (constructor_list
.head
);
3563 case lang_output_section_statement_enum
:
3564 /* Don't sort .init/.fini sections. */
3565 if (strcmp (s
->output_section_statement
.name
, ".init") != 0
3566 && strcmp (s
->output_section_statement
.name
, ".fini") != 0)
3567 update_wild_statements
3568 (s
->output_section_statement
.children
.head
);
3571 case lang_group_statement_enum
:
3572 update_wild_statements (s
->group_statement
.children
.head
);
3580 /* Open input files and attach to output sections. */
3583 map_input_to_output_sections
3584 (lang_statement_union_type
*s
, const char *target
,
3585 lang_output_section_statement_type
*os
)
3587 for (; s
!= NULL
; s
= s
->header
.next
)
3589 lang_output_section_statement_type
*tos
;
3592 switch (s
->header
.type
)
3594 case lang_wild_statement_enum
:
3595 wild (&s
->wild_statement
, target
, os
);
3597 case lang_constructors_statement_enum
:
3598 map_input_to_output_sections (constructor_list
.head
,
3602 case lang_output_section_statement_enum
:
3603 tos
= &s
->output_section_statement
;
3604 if (tos
->constraint
!= 0)
3606 if (tos
->constraint
!= ONLY_IF_RW
3607 && tos
->constraint
!= ONLY_IF_RO
)
3609 tos
->all_input_readonly
= TRUE
;
3610 check_input_sections (tos
->children
.head
, tos
);
3611 if (tos
->all_input_readonly
!= (tos
->constraint
== ONLY_IF_RO
))
3613 tos
->constraint
= -1;
3617 map_input_to_output_sections (tos
->children
.head
,
3621 case lang_output_statement_enum
:
3623 case lang_target_statement_enum
:
3624 target
= s
->target_statement
.target
;
3626 case lang_group_statement_enum
:
3627 map_input_to_output_sections (s
->group_statement
.children
.head
,
3631 case lang_data_statement_enum
:
3632 /* Make sure that any sections mentioned in the expression
3634 exp_init_os (s
->data_statement
.exp
);
3635 /* The output section gets CONTENTS, ALLOC and LOAD, but
3636 these may be overridden by the script. */
3637 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
;
3638 switch (os
->sectype
)
3640 case normal_section
:
3641 case overlay_section
:
3643 case noalloc_section
:
3644 flags
= SEC_HAS_CONTENTS
;
3646 case noload_section
:
3647 if (bfd_get_flavour (link_info
.output_bfd
)
3648 == bfd_target_elf_flavour
)
3649 flags
= SEC_NEVER_LOAD
| SEC_ALLOC
;
3651 flags
= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
;
3654 if (os
->bfd_section
== NULL
)
3655 init_os (os
, flags
);
3657 os
->bfd_section
->flags
|= flags
;
3659 case lang_input_section_enum
:
3661 case lang_fill_statement_enum
:
3662 case lang_object_symbols_statement_enum
:
3663 case lang_reloc_statement_enum
:
3664 case lang_padding_statement_enum
:
3665 case lang_input_statement_enum
:
3666 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3669 case lang_assignment_statement_enum
:
3670 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3673 /* Make sure that any sections mentioned in the assignment
3675 exp_init_os (s
->assignment_statement
.exp
);
3677 case lang_address_statement_enum
:
3678 /* Mark the specified section with the supplied address.
3679 If this section was actually a segment marker, then the
3680 directive is ignored if the linker script explicitly
3681 processed the segment marker. Originally, the linker
3682 treated segment directives (like -Ttext on the
3683 command-line) as section directives. We honor the
3684 section directive semantics for backwards compatibilty;
3685 linker scripts that do not specifically check for
3686 SEGMENT_START automatically get the old semantics. */
3687 if (!s
->address_statement
.segment
3688 || !s
->address_statement
.segment
->used
)
3690 const char *name
= s
->address_statement
.section_name
;
3692 /* Create the output section statement here so that
3693 orphans with a set address will be placed after other
3694 script sections. If we let the orphan placement code
3695 place them in amongst other sections then the address
3696 will affect following script sections, which is
3697 likely to surprise naive users. */
3698 tos
= lang_output_section_statement_lookup (name
, 0, TRUE
);
3699 tos
->addr_tree
= s
->address_statement
.address
;
3700 if (tos
->bfd_section
== NULL
)
3704 case lang_insert_statement_enum
:
3710 /* An insert statement snips out all the linker statements from the
3711 start of the list and places them after the output section
3712 statement specified by the insert. This operation is complicated
3713 by the fact that we keep a doubly linked list of output section
3714 statements as well as the singly linked list of all statements. */
3717 process_insert_statements (void)
3719 lang_statement_union_type
**s
;
3720 lang_output_section_statement_type
*first_os
= NULL
;
3721 lang_output_section_statement_type
*last_os
= NULL
;
3722 lang_output_section_statement_type
*os
;
3724 /* "start of list" is actually the statement immediately after
3725 the special abs_section output statement, so that it isn't
3727 s
= &lang_output_section_statement
.head
;
3728 while (*(s
= &(*s
)->header
.next
) != NULL
)
3730 if ((*s
)->header
.type
== lang_output_section_statement_enum
)
3732 /* Keep pointers to the first and last output section
3733 statement in the sequence we may be about to move. */
3734 os
= &(*s
)->output_section_statement
;
3736 ASSERT (last_os
== NULL
|| last_os
->next
== os
);
3739 /* Set constraint negative so that lang_output_section_find
3740 won't match this output section statement. At this
3741 stage in linking constraint has values in the range
3742 [-1, ONLY_IN_RW]. */
3743 last_os
->constraint
= -2 - last_os
->constraint
;
3744 if (first_os
== NULL
)
3747 else if ((*s
)->header
.type
== lang_insert_statement_enum
)
3749 lang_insert_statement_type
*i
= &(*s
)->insert_statement
;
3750 lang_output_section_statement_type
*where
;
3751 lang_statement_union_type
**ptr
;
3752 lang_statement_union_type
*first
;
3754 where
= lang_output_section_find (i
->where
);
3755 if (where
!= NULL
&& i
->is_before
)
3758 where
= where
->prev
;
3759 while (where
!= NULL
&& where
->constraint
< 0);
3763 einfo (_("%F%P: %s not found for insert\n"), i
->where
);
3767 /* Deal with reordering the output section statement list. */
3768 if (last_os
!= NULL
)
3770 asection
*first_sec
, *last_sec
;
3771 struct lang_output_section_statement_struct
**next
;
3773 /* Snip out the output sections we are moving. */
3774 first_os
->prev
->next
= last_os
->next
;
3775 if (last_os
->next
== NULL
)
3777 next
= &first_os
->prev
->next
;
3778 lang_output_section_statement
.tail
3779 = (lang_statement_union_type
**) next
;
3782 last_os
->next
->prev
= first_os
->prev
;
3783 /* Add them in at the new position. */
3784 last_os
->next
= where
->next
;
3785 if (where
->next
== NULL
)
3787 next
= &last_os
->next
;
3788 lang_output_section_statement
.tail
3789 = (lang_statement_union_type
**) next
;
3792 where
->next
->prev
= last_os
;
3793 first_os
->prev
= where
;
3794 where
->next
= first_os
;
3796 /* Move the bfd sections in the same way. */
3799 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
3801 os
->constraint
= -2 - os
->constraint
;
3802 if (os
->bfd_section
!= NULL
3803 && os
->bfd_section
->owner
!= NULL
)
3805 last_sec
= os
->bfd_section
;
3806 if (first_sec
== NULL
)
3807 first_sec
= last_sec
;
3812 if (last_sec
!= NULL
)
3814 asection
*sec
= where
->bfd_section
;
3816 sec
= output_prev_sec_find (where
);
3818 /* The place we want to insert must come after the
3819 sections we are moving. So if we find no
3820 section or if the section is the same as our
3821 last section, then no move is needed. */
3822 if (sec
!= NULL
&& sec
!= last_sec
)
3824 /* Trim them off. */
3825 if (first_sec
->prev
!= NULL
)
3826 first_sec
->prev
->next
= last_sec
->next
;
3828 link_info
.output_bfd
->sections
= last_sec
->next
;
3829 if (last_sec
->next
!= NULL
)
3830 last_sec
->next
->prev
= first_sec
->prev
;
3832 link_info
.output_bfd
->section_last
= first_sec
->prev
;
3834 last_sec
->next
= sec
->next
;
3835 if (sec
->next
!= NULL
)
3836 sec
->next
->prev
= last_sec
;
3838 link_info
.output_bfd
->section_last
= last_sec
;
3839 first_sec
->prev
= sec
;
3840 sec
->next
= first_sec
;
3848 ptr
= insert_os_after (where
);
3849 /* Snip everything after the abs_section output statement we
3850 know is at the start of the list, up to and including
3851 the insert statement we are currently processing. */
3852 first
= lang_output_section_statement
.head
->header
.next
;
3853 lang_output_section_statement
.head
->header
.next
= (*s
)->header
.next
;
3854 /* Add them back where they belong. */
3857 statement_list
.tail
= s
;
3859 s
= &lang_output_section_statement
.head
;
3863 /* Undo constraint twiddling. */
3864 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
3866 os
->constraint
= -2 - os
->constraint
;
3872 /* An output section might have been removed after its statement was
3873 added. For example, ldemul_before_allocation can remove dynamic
3874 sections if they turn out to be not needed. Clean them up here. */
3877 strip_excluded_output_sections (void)
3879 lang_output_section_statement_type
*os
;
3881 /* Run lang_size_sections (if not already done). */
3882 if (expld
.phase
!= lang_mark_phase_enum
)
3884 expld
.phase
= lang_mark_phase_enum
;
3885 expld
.dataseg
.phase
= exp_dataseg_none
;
3886 one_lang_size_sections_pass (NULL
, FALSE
);
3887 lang_reset_memory_regions ();
3890 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
3894 asection
*output_section
;
3895 bfd_boolean exclude
;
3897 if (os
->constraint
< 0)
3900 output_section
= os
->bfd_section
;
3901 if (output_section
== NULL
)
3904 exclude
= (output_section
->rawsize
== 0
3905 && (output_section
->flags
& SEC_KEEP
) == 0
3906 && !bfd_section_removed_from_list (link_info
.output_bfd
,
3909 /* Some sections have not yet been sized, notably .gnu.version,
3910 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
3911 input sections, so don't drop output sections that have such
3912 input sections unless they are also marked SEC_EXCLUDE. */
3913 if (exclude
&& output_section
->map_head
.s
!= NULL
)
3917 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
3918 if ((s
->flags
& SEC_EXCLUDE
) == 0
3919 && ((s
->flags
& SEC_LINKER_CREATED
) != 0
3920 || link_info
.emitrelocations
))
3929 /* We don't set bfd_section to NULL since bfd_section of the
3930 removed output section statement may still be used. */
3931 if (!os
->update_dot
)
3933 output_section
->flags
|= SEC_EXCLUDE
;
3934 bfd_section_list_remove (link_info
.output_bfd
, output_section
);
3935 link_info
.output_bfd
->section_count
--;
3940 /* Called from ldwrite to clear out asection.map_head and
3941 asection.map_tail for use as link_orders in ldwrite.
3942 FIXME: Except for sh64elf.em which starts creating link_orders in
3943 its after_allocation routine so needs to call it early. */
3946 lang_clear_os_map (void)
3948 lang_output_section_statement_type
*os
;
3950 if (map_head_is_link_order
)
3953 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
3957 asection
*output_section
;
3959 if (os
->constraint
< 0)
3962 output_section
= os
->bfd_section
;
3963 if (output_section
== NULL
)
3966 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
3967 output_section
->map_head
.link_order
= NULL
;
3968 output_section
->map_tail
.link_order
= NULL
;
3971 /* Stop future calls to lang_add_section from messing with map_head
3972 and map_tail link_order fields. */
3973 map_head_is_link_order
= TRUE
;
3977 print_output_section_statement
3978 (lang_output_section_statement_type
*output_section_statement
)
3980 asection
*section
= output_section_statement
->bfd_section
;
3983 if (output_section_statement
!= abs_output_section
)
3985 minfo ("\n%s", output_section_statement
->name
);
3987 if (section
!= NULL
)
3989 print_dot
= section
->vma
;
3991 len
= strlen (output_section_statement
->name
);
3992 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
3997 while (len
< SECTION_NAME_MAP_LENGTH
)
4003 minfo ("0x%V %W", section
->vma
, TO_ADDR (section
->size
));
4005 if (section
->vma
!= section
->lma
)
4006 minfo (_(" load address 0x%V"), section
->lma
);
4008 if (output_section_statement
->update_dot_tree
!= NULL
)
4009 exp_fold_tree (output_section_statement
->update_dot_tree
,
4010 bfd_abs_section_ptr
, &print_dot
);
4016 print_statement_list (output_section_statement
->children
.head
,
4017 output_section_statement
);
4021 print_assignment (lang_assignment_statement_type
*assignment
,
4022 lang_output_section_statement_type
*output_section
)
4029 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4032 if (assignment
->exp
->type
.node_class
== etree_assert
)
4035 tree
= assignment
->exp
->assert_s
.child
;
4039 const char *dst
= assignment
->exp
->assign
.dst
;
4041 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
4043 expld
.assign_name
= dst
;
4044 tree
= assignment
->exp
->assign
.src
;
4047 osec
= output_section
->bfd_section
;
4049 osec
= bfd_abs_section_ptr
;
4051 if (assignment
->exp
->type
.node_class
!= etree_provide
)
4052 exp_fold_tree (tree
, osec
, &print_dot
);
4054 expld
.result
.valid_p
= FALSE
;
4056 if (expld
.result
.valid_p
)
4060 if (assignment
->exp
->type
.node_class
== etree_assert
4062 || expld
.assign_name
!= NULL
)
4064 value
= expld
.result
.value
;
4066 if (expld
.result
.section
!= NULL
)
4067 value
+= expld
.result
.section
->vma
;
4069 minfo ("0x%V", value
);
4075 struct bfd_link_hash_entry
*h
;
4077 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
4078 FALSE
, FALSE
, TRUE
);
4081 value
= h
->u
.def
.value
;
4082 value
+= h
->u
.def
.section
->output_section
->vma
;
4083 value
+= h
->u
.def
.section
->output_offset
;
4085 minfo ("[0x%V]", value
);
4088 minfo ("[unresolved]");
4093 if (assignment
->exp
->type
.node_class
== etree_provide
)
4094 minfo ("[!provide]");
4101 expld
.assign_name
= NULL
;
4104 exp_print_tree (assignment
->exp
);
4109 print_input_statement (lang_input_statement_type
*statm
)
4111 if (statm
->filename
!= NULL
4112 && (statm
->the_bfd
== NULL
4113 || (statm
->the_bfd
->flags
& BFD_LINKER_CREATED
) == 0))
4114 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
4117 /* Print all symbols defined in a particular section. This is called
4118 via bfd_link_hash_traverse, or by print_all_symbols. */
4121 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
4123 asection
*sec
= (asection
*) ptr
;
4125 if ((hash_entry
->type
== bfd_link_hash_defined
4126 || hash_entry
->type
== bfd_link_hash_defweak
)
4127 && sec
== hash_entry
->u
.def
.section
)
4131 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4134 (hash_entry
->u
.def
.value
4135 + hash_entry
->u
.def
.section
->output_offset
4136 + hash_entry
->u
.def
.section
->output_section
->vma
));
4138 minfo (" %T\n", hash_entry
->root
.string
);
4145 hash_entry_addr_cmp (const void *a
, const void *b
)
4147 const struct bfd_link_hash_entry
*l
= *(const struct bfd_link_hash_entry
**)a
;
4148 const struct bfd_link_hash_entry
*r
= *(const struct bfd_link_hash_entry
**)b
;
4150 if (l
->u
.def
.value
< r
->u
.def
.value
)
4152 else if (l
->u
.def
.value
> r
->u
.def
.value
)
4159 print_all_symbols (asection
*sec
)
4161 input_section_userdata_type
*ud
4162 = (input_section_userdata_type
*) get_userdata (sec
);
4163 struct map_symbol_def
*def
;
4164 struct bfd_link_hash_entry
**entries
;
4170 *ud
->map_symbol_def_tail
= 0;
4172 /* Sort the symbols by address. */
4173 entries
= (struct bfd_link_hash_entry
**)
4174 obstack_alloc (&map_obstack
, ud
->map_symbol_def_count
* sizeof (*entries
));
4176 for (i
= 0, def
= ud
->map_symbol_def_head
; def
; def
= def
->next
, i
++)
4177 entries
[i
] = def
->entry
;
4179 qsort (entries
, ud
->map_symbol_def_count
, sizeof (*entries
),
4180 hash_entry_addr_cmp
);
4182 /* Print the symbols. */
4183 for (i
= 0; i
< ud
->map_symbol_def_count
; i
++)
4184 print_one_symbol (entries
[i
], sec
);
4186 obstack_free (&map_obstack
, entries
);
4189 /* Print information about an input section to the map file. */
4192 print_input_section (asection
*i
, bfd_boolean is_discarded
)
4194 bfd_size_type size
= i
->size
;
4201 minfo ("%s", i
->name
);
4203 len
= 1 + strlen (i
->name
);
4204 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4209 while (len
< SECTION_NAME_MAP_LENGTH
)
4215 if (i
->output_section
!= NULL
4216 && i
->output_section
->owner
== link_info
.output_bfd
)
4217 addr
= i
->output_section
->vma
+ i
->output_offset
;
4225 minfo ("0x%V %W %B\n", addr
, size
, i
->owner
);
4227 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
4229 len
= SECTION_NAME_MAP_LENGTH
+ 3;
4241 minfo (_("%W (size before relaxing)\n"), i
->rawsize
);
4244 if (i
->output_section
!= NULL
4245 && i
->output_section
->owner
== link_info
.output_bfd
)
4247 if (link_info
.reduce_memory_overheads
)
4248 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, i
);
4250 print_all_symbols (i
);
4252 /* Update print_dot, but make sure that we do not move it
4253 backwards - this could happen if we have overlays and a
4254 later overlay is shorter than an earier one. */
4255 if (addr
+ TO_ADDR (size
) > print_dot
)
4256 print_dot
= addr
+ TO_ADDR (size
);
4261 print_fill_statement (lang_fill_statement_type
*fill
)
4265 fputs (" FILL mask 0x", config
.map_file
);
4266 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
4267 fprintf (config
.map_file
, "%02x", *p
);
4268 fputs ("\n", config
.map_file
);
4272 print_data_statement (lang_data_statement_type
*data
)
4280 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4283 addr
= data
->output_offset
;
4284 if (data
->output_section
!= NULL
)
4285 addr
+= data
->output_section
->vma
;
4313 if (size
< TO_SIZE ((unsigned) 1))
4314 size
= TO_SIZE ((unsigned) 1);
4315 minfo ("0x%V %W %s 0x%v", addr
, TO_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
, TO_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
, TO_ADDR (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
);
4687 sort_sections_by_lma (const void *arg1
, const void *arg2
)
4689 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
4690 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
4692 if (sec1
->lma
< sec2
->lma
)
4694 else if (sec1
->lma
> sec2
->lma
)
4696 else if (sec1
->id
< sec2
->id
)
4698 else if (sec1
->id
> sec2
->id
)
4705 sort_sections_by_vma (const void *arg1
, const void *arg2
)
4707 const asection
*sec1
= ((const struct check_sec
*) arg1
)->sec
;
4708 const asection
*sec2
= ((const struct check_sec
*) arg2
)->sec
;
4710 if (sec1
->vma
< sec2
->vma
)
4712 else if (sec1
->vma
> sec2
->vma
)
4714 else if (sec1
->id
< sec2
->id
)
4716 else if (sec1
->id
> sec2
->id
)
4722 #define IS_TBSS(s) \
4723 ((s->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == SEC_THREAD_LOCAL)
4725 #define IGNORE_SECTION(s) \
4726 ((s->flags & SEC_ALLOC) == 0 || IS_TBSS (s))
4728 /* Check to see if any allocated sections overlap with other allocated
4729 sections. This can happen if a linker script specifies the output
4730 section addresses of the two sections. Also check whether any memory
4731 region has overflowed. */
4734 lang_check_section_addresses (void)
4737 struct check_sec
*sections
;
4741 bfd_vma p_start
= 0;
4743 lang_memory_region_type
*m
;
4744 bfd_boolean overlays
;
4746 if (bfd_count_sections (link_info
.output_bfd
) <= 1)
4749 count
= bfd_count_sections (link_info
.output_bfd
);
4750 sections
= XNEWVEC (struct check_sec
, count
);
4752 /* Scan all sections in the output list. */
4754 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
4756 if (IGNORE_SECTION (s
)
4760 sections
[count
].sec
= s
;
4761 sections
[count
].warned
= FALSE
;
4771 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_lma
);
4773 /* First check section LMAs. There should be no overlap of LMAs on
4774 loadable sections, even with overlays. */
4775 for (p
= NULL
, i
= 0; i
< count
; i
++)
4777 s
= sections
[i
].sec
;
4778 if ((s
->flags
& SEC_LOAD
) != 0)
4781 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
4783 /* Look for an overlap. We have sorted sections by lma, so
4784 we know that s_start >= p_start. Besides the obvious
4785 case of overlap when the current section starts before
4786 the previous one ends, we also must have overlap if the
4787 previous section wraps around the address space. */
4789 && (s_start
<= p_end
4790 || p_end
< p_start
))
4792 einfo (_("%X%P: section %s LMA [%V,%V]"
4793 " overlaps section %s LMA [%V,%V]\n"),
4794 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
4795 sections
[i
].warned
= TRUE
;
4803 /* If any non-zero size allocated section (excluding tbss) starts at
4804 exactly the same VMA as another such section, then we have
4805 overlays. Overlays generated by the OVERLAY keyword will have
4806 this property. It is possible to intentionally generate overlays
4807 that fail this test, but it would be unusual. */
4808 qsort (sections
, count
, sizeof (*sections
), sort_sections_by_vma
);
4810 p_start
= sections
[0].sec
->vma
;
4811 for (i
= 1; i
< count
; i
++)
4813 s_start
= sections
[i
].sec
->vma
;
4814 if (p_start
== s_start
)
4822 /* Now check section VMAs if no overlays were detected. */
4825 for (p
= NULL
, i
= 0; i
< count
; i
++)
4827 s
= sections
[i
].sec
;
4829 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
4832 && !sections
[i
].warned
4833 && (s_start
<= p_end
4834 || p_end
< p_start
))
4835 einfo (_("%X%P: section %s VMA [%V,%V]"
4836 " overlaps section %s VMA [%V,%V]\n"),
4837 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
4846 /* If any memory region has overflowed, report by how much.
4847 We do not issue this diagnostic for regions that had sections
4848 explicitly placed outside their bounds; os_region_check's
4849 diagnostics are adequate for that case.
4851 FIXME: It is conceivable that m->current - (m->origin + m->length)
4852 might overflow a 32-bit integer. There is, alas, no way to print
4853 a bfd_vma quantity in decimal. */
4854 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
4855 if (m
->had_full_message
)
4856 einfo (_("%X%P: region `%s' overflowed by %ld bytes\n"),
4857 m
->name_list
.name
, (long)(m
->current
- (m
->origin
+ m
->length
)));
4860 /* Make sure the new address is within the region. We explicitly permit the
4861 current address to be at the exact end of the region when the address is
4862 non-zero, in case the region is at the end of addressable memory and the
4863 calculation wraps around. */
4866 os_region_check (lang_output_section_statement_type
*os
,
4867 lang_memory_region_type
*region
,
4871 if ((region
->current
< region
->origin
4872 || (region
->current
- region
->origin
> region
->length
))
4873 && ((region
->current
!= region
->origin
+ region
->length
)
4878 einfo (_("%X%P: address 0x%v of %B section `%s'"
4879 " is not within region `%s'\n"),
4881 os
->bfd_section
->owner
,
4882 os
->bfd_section
->name
,
4883 region
->name_list
.name
);
4885 else if (!region
->had_full_message
)
4887 region
->had_full_message
= TRUE
;
4889 einfo (_("%X%P: %B section `%s' will not fit in region `%s'\n"),
4890 os
->bfd_section
->owner
,
4891 os
->bfd_section
->name
,
4892 region
->name_list
.name
);
4897 /* Set the sizes for all the output sections. */
4900 lang_size_sections_1
4901 (lang_statement_union_type
**prev
,
4902 lang_output_section_statement_type
*output_section_statement
,
4906 bfd_boolean check_regions
)
4908 lang_statement_union_type
*s
;
4910 /* Size up the sections from their constituent parts. */
4911 for (s
= *prev
; s
!= NULL
; s
= s
->header
.next
)
4913 switch (s
->header
.type
)
4915 case lang_output_section_statement_enum
:
4917 bfd_vma newdot
, after
, dotdelta
;
4918 lang_output_section_statement_type
*os
;
4919 lang_memory_region_type
*r
;
4920 int section_alignment
= 0;
4922 os
= &s
->output_section_statement
;
4923 if (os
->constraint
== -1)
4926 /* FIXME: We shouldn't need to zero section vmas for ld -r
4927 here, in lang_insert_orphan, or in the default linker scripts.
4928 This is covering for coff backend linker bugs. See PR6945. */
4929 if (os
->addr_tree
== NULL
4930 && bfd_link_relocatable (&link_info
)
4931 && (bfd_get_flavour (link_info
.output_bfd
)
4932 == bfd_target_coff_flavour
))
4933 os
->addr_tree
= exp_intop (0);
4934 if (os
->addr_tree
!= NULL
)
4936 os
->processed_vma
= FALSE
;
4937 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
4939 if (expld
.result
.valid_p
)
4941 dot
= expld
.result
.value
;
4942 if (expld
.result
.section
!= NULL
)
4943 dot
+= expld
.result
.section
->vma
;
4945 else if (expld
.phase
!= lang_mark_phase_enum
)
4946 einfo (_("%F%S: non constant or forward reference"
4947 " address expression for section %s\n"),
4948 os
->addr_tree
, os
->name
);
4951 if (os
->bfd_section
== NULL
)
4952 /* This section was removed or never actually created. */
4955 /* If this is a COFF shared library section, use the size and
4956 address from the input section. FIXME: This is COFF
4957 specific; it would be cleaner if there were some other way
4958 to do this, but nothing simple comes to mind. */
4959 if (((bfd_get_flavour (link_info
.output_bfd
)
4960 == bfd_target_ecoff_flavour
)
4961 || (bfd_get_flavour (link_info
.output_bfd
)
4962 == bfd_target_coff_flavour
))
4963 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
4967 if (os
->children
.head
== NULL
4968 || os
->children
.head
->header
.next
!= NULL
4969 || (os
->children
.head
->header
.type
4970 != lang_input_section_enum
))
4971 einfo (_("%P%X: Internal error on COFF shared library"
4972 " section %s\n"), os
->name
);
4974 input
= os
->children
.head
->input_section
.section
;
4975 bfd_set_section_vma (os
->bfd_section
->owner
,
4977 bfd_section_vma (input
->owner
, input
));
4978 os
->bfd_section
->size
= input
->size
;
4984 if (bfd_is_abs_section (os
->bfd_section
))
4986 /* No matter what happens, an abs section starts at zero. */
4987 ASSERT (os
->bfd_section
->vma
== 0);
4991 if (os
->addr_tree
== NULL
)
4993 /* No address specified for this section, get one
4994 from the region specification. */
4995 if (os
->region
== NULL
4996 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
4997 && os
->region
->name_list
.name
[0] == '*'
4998 && strcmp (os
->region
->name_list
.name
,
4999 DEFAULT_MEMORY_REGION
) == 0))
5001 os
->region
= lang_memory_default (os
->bfd_section
);
5004 /* If a loadable section is using the default memory
5005 region, and some non default memory regions were
5006 defined, issue an error message. */
5008 && !IGNORE_SECTION (os
->bfd_section
)
5009 && !bfd_link_relocatable (&link_info
)
5011 && strcmp (os
->region
->name_list
.name
,
5012 DEFAULT_MEMORY_REGION
) == 0
5013 && lang_memory_region_list
!= NULL
5014 && (strcmp (lang_memory_region_list
->name_list
.name
,
5015 DEFAULT_MEMORY_REGION
) != 0
5016 || lang_memory_region_list
->next
!= NULL
)
5017 && expld
.phase
!= lang_mark_phase_enum
)
5019 /* By default this is an error rather than just a
5020 warning because if we allocate the section to the
5021 default memory region we can end up creating an
5022 excessively large binary, or even seg faulting when
5023 attempting to perform a negative seek. See
5024 sources.redhat.com/ml/binutils/2003-04/msg00423.html
5025 for an example of this. This behaviour can be
5026 overridden by the using the --no-check-sections
5028 if (command_line
.check_section_addresses
)
5029 einfo (_("%P%F: error: no memory region specified"
5030 " for loadable section `%s'\n"),
5031 bfd_get_section_name (link_info
.output_bfd
,
5034 einfo (_("%P: warning: no memory region specified"
5035 " for loadable section `%s'\n"),
5036 bfd_get_section_name (link_info
.output_bfd
,
5040 newdot
= os
->region
->current
;
5041 section_alignment
= os
->bfd_section
->alignment_power
;
5044 section_alignment
= os
->section_alignment
;
5046 /* Align to what the section needs. */
5047 if (section_alignment
> 0)
5049 bfd_vma savedot
= newdot
;
5050 newdot
= align_power (newdot
, section_alignment
);
5052 dotdelta
= newdot
- savedot
;
5054 && (config
.warn_section_align
5055 || os
->addr_tree
!= NULL
)
5056 && expld
.phase
!= lang_mark_phase_enum
)
5057 einfo (_("%P: warning: changing start of section"
5058 " %s by %lu bytes\n"),
5059 os
->name
, (unsigned long) dotdelta
);
5062 bfd_set_section_vma (0, os
->bfd_section
, newdot
);
5064 os
->bfd_section
->output_offset
= 0;
5067 lang_size_sections_1 (&os
->children
.head
, os
,
5068 os
->fill
, newdot
, relax
, check_regions
);
5070 os
->processed_vma
= TRUE
;
5072 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5073 /* Except for some special linker created sections,
5074 no output section should change from zero size
5075 after strip_excluded_output_sections. A non-zero
5076 size on an ignored section indicates that some
5077 input section was not sized early enough. */
5078 ASSERT (os
->bfd_section
->size
== 0);
5081 dot
= os
->bfd_section
->vma
;
5083 /* Put the section within the requested block size, or
5084 align at the block boundary. */
5086 + TO_ADDR (os
->bfd_section
->size
)
5087 + os
->block_value
- 1)
5088 & - (bfd_vma
) os
->block_value
);
5090 os
->bfd_section
->size
= TO_SIZE (after
- os
->bfd_section
->vma
);
5093 /* Set section lma. */
5096 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
5100 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
5101 os
->bfd_section
->lma
= lma
;
5103 else if (os
->lma_region
!= NULL
)
5105 bfd_vma lma
= os
->lma_region
->current
;
5107 if (os
->align_lma_with_input
)
5111 /* When LMA_REGION is the same as REGION, align the LMA
5112 as we did for the VMA, possibly including alignment
5113 from the bfd section. If a different region, then
5114 only align according to the value in the output
5116 if (os
->lma_region
!= os
->region
)
5117 section_alignment
= os
->section_alignment
;
5118 if (section_alignment
> 0)
5119 lma
= align_power (lma
, section_alignment
);
5121 os
->bfd_section
->lma
= lma
;
5123 else if (r
->last_os
!= NULL
5124 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5129 last
= r
->last_os
->output_section_statement
.bfd_section
;
5131 /* A backwards move of dot should be accompanied by
5132 an explicit assignment to the section LMA (ie.
5133 os->load_base set) because backwards moves can
5134 create overlapping LMAs. */
5136 && os
->bfd_section
->size
!= 0
5137 && dot
+ TO_ADDR (os
->bfd_section
->size
) <= last
->vma
)
5139 /* If dot moved backwards then leave lma equal to
5140 vma. This is the old default lma, which might
5141 just happen to work when the backwards move is
5142 sufficiently large. Nag if this changes anything,
5143 so people can fix their linker scripts. */
5145 if (last
->vma
!= last
->lma
)
5146 einfo (_("%P: warning: dot moved backwards before `%s'\n"),
5151 /* If this is an overlay, set the current lma to that
5152 at the end of the previous section. */
5153 if (os
->sectype
== overlay_section
)
5154 lma
= last
->lma
+ TO_ADDR (last
->size
);
5156 /* Otherwise, keep the same lma to vma relationship
5157 as the previous section. */
5159 lma
= dot
+ last
->lma
- last
->vma
;
5161 if (section_alignment
> 0)
5162 lma
= align_power (lma
, section_alignment
);
5163 os
->bfd_section
->lma
= lma
;
5166 os
->processed_lma
= TRUE
;
5168 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5171 /* Keep track of normal sections using the default
5172 lma region. We use this to set the lma for
5173 following sections. Overlays or other linker
5174 script assignment to lma might mean that the
5175 default lma == vma is incorrect.
5176 To avoid warnings about dot moving backwards when using
5177 -Ttext, don't start tracking sections until we find one
5178 of non-zero size or with lma set differently to vma. */
5179 if (!IGNORE_SECTION (os
->bfd_section
)
5180 && (os
->bfd_section
->size
!= 0
5181 || (r
->last_os
== NULL
5182 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
5183 || (r
->last_os
!= NULL
5184 && dot
>= (r
->last_os
->output_section_statement
5185 .bfd_section
->vma
)))
5186 && os
->lma_region
== NULL
5187 && !bfd_link_relocatable (&link_info
))
5190 /* .tbss sections effectively have zero size. */
5191 if (!IS_TBSS (os
->bfd_section
)
5192 || bfd_link_relocatable (&link_info
))
5193 dotdelta
= TO_ADDR (os
->bfd_section
->size
);
5198 if (os
->update_dot_tree
!= 0)
5199 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5201 /* Update dot in the region ?
5202 We only do this if the section is going to be allocated,
5203 since unallocated sections do not contribute to the region's
5204 overall size in memory. */
5205 if (os
->region
!= NULL
5206 && (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)))
5208 os
->region
->current
= dot
;
5211 /* Make sure the new address is within the region. */
5212 os_region_check (os
, os
->region
, os
->addr_tree
,
5213 os
->bfd_section
->vma
);
5215 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
5216 && ((os
->bfd_section
->flags
& SEC_LOAD
)
5217 || os
->align_lma_with_input
))
5219 os
->lma_region
->current
= os
->bfd_section
->lma
+ dotdelta
;
5222 os_region_check (os
, os
->lma_region
, NULL
,
5223 os
->bfd_section
->lma
);
5229 case lang_constructors_statement_enum
:
5230 dot
= lang_size_sections_1 (&constructor_list
.head
,
5231 output_section_statement
,
5232 fill
, dot
, relax
, check_regions
);
5235 case lang_data_statement_enum
:
5237 unsigned int size
= 0;
5239 s
->data_statement
.output_offset
=
5240 dot
- output_section_statement
->bfd_section
->vma
;
5241 s
->data_statement
.output_section
=
5242 output_section_statement
->bfd_section
;
5244 /* We might refer to provided symbols in the expression, and
5245 need to mark them as needed. */
5246 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5248 switch (s
->data_statement
.type
)
5266 if (size
< TO_SIZE ((unsigned) 1))
5267 size
= TO_SIZE ((unsigned) 1);
5268 dot
+= TO_ADDR (size
);
5269 output_section_statement
->bfd_section
->size
5270 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5275 case lang_reloc_statement_enum
:
5279 s
->reloc_statement
.output_offset
=
5280 dot
- output_section_statement
->bfd_section
->vma
;
5281 s
->reloc_statement
.output_section
=
5282 output_section_statement
->bfd_section
;
5283 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
5284 dot
+= TO_ADDR (size
);
5285 output_section_statement
->bfd_section
->size
5286 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5290 case lang_wild_statement_enum
:
5291 dot
= lang_size_sections_1 (&s
->wild_statement
.children
.head
,
5292 output_section_statement
,
5293 fill
, dot
, relax
, check_regions
);
5296 case lang_object_symbols_statement_enum
:
5297 link_info
.create_object_symbols_section
=
5298 output_section_statement
->bfd_section
;
5301 case lang_output_statement_enum
:
5302 case lang_target_statement_enum
:
5305 case lang_input_section_enum
:
5309 i
= s
->input_section
.section
;
5314 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
5315 einfo (_("%P%F: can't relax section: %E\n"));
5319 dot
= size_input_section (prev
, output_section_statement
,
5324 case lang_input_statement_enum
:
5327 case lang_fill_statement_enum
:
5328 s
->fill_statement
.output_section
=
5329 output_section_statement
->bfd_section
;
5331 fill
= s
->fill_statement
.fill
;
5334 case lang_assignment_statement_enum
:
5336 bfd_vma newdot
= dot
;
5337 etree_type
*tree
= s
->assignment_statement
.exp
;
5339 expld
.dataseg
.relro
= exp_dataseg_relro_none
;
5341 exp_fold_tree (tree
,
5342 output_section_statement
->bfd_section
,
5345 if (expld
.dataseg
.relro
== exp_dataseg_relro_start
)
5347 if (!expld
.dataseg
.relro_start_stat
)
5348 expld
.dataseg
.relro_start_stat
= s
;
5351 ASSERT (expld
.dataseg
.relro_start_stat
== s
);
5354 else if (expld
.dataseg
.relro
== exp_dataseg_relro_end
)
5356 if (!expld
.dataseg
.relro_end_stat
)
5357 expld
.dataseg
.relro_end_stat
= s
;
5360 ASSERT (expld
.dataseg
.relro_end_stat
== s
);
5363 expld
.dataseg
.relro
= exp_dataseg_relro_none
;
5365 /* This symbol may be relative to this section. */
5366 if ((tree
->type
.node_class
== etree_provided
5367 || tree
->type
.node_class
== etree_assign
)
5368 && (tree
->assign
.dst
[0] != '.'
5369 || tree
->assign
.dst
[1] != '\0'))
5370 output_section_statement
->update_dot
= 1;
5372 if (!output_section_statement
->ignored
)
5374 if (output_section_statement
== abs_output_section
)
5376 /* If we don't have an output section, then just adjust
5377 the default memory address. */
5378 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
5379 FALSE
)->current
= newdot
;
5381 else if (newdot
!= dot
)
5383 /* Insert a pad after this statement. We can't
5384 put the pad before when relaxing, in case the
5385 assignment references dot. */
5386 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
5387 output_section_statement
->bfd_section
, dot
);
5389 /* Don't neuter the pad below when relaxing. */
5392 /* If dot is advanced, this implies that the section
5393 should have space allocated to it, unless the
5394 user has explicitly stated that the section
5395 should not be allocated. */
5396 if (output_section_statement
->sectype
!= noalloc_section
5397 && (output_section_statement
->sectype
!= noload_section
5398 || (bfd_get_flavour (link_info
.output_bfd
)
5399 == bfd_target_elf_flavour
)))
5400 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
5407 case lang_padding_statement_enum
:
5408 /* If this is the first time lang_size_sections is called,
5409 we won't have any padding statements. If this is the
5410 second or later passes when relaxing, we should allow
5411 padding to shrink. If padding is needed on this pass, it
5412 will be added back in. */
5413 s
->padding_statement
.size
= 0;
5415 /* Make sure output_offset is valid. If relaxation shrinks
5416 the section and this pad isn't needed, it's possible to
5417 have output_offset larger than the final size of the
5418 section. bfd_set_section_contents will complain even for
5419 a pad size of zero. */
5420 s
->padding_statement
.output_offset
5421 = dot
- output_section_statement
->bfd_section
->vma
;
5424 case lang_group_statement_enum
:
5425 dot
= lang_size_sections_1 (&s
->group_statement
.children
.head
,
5426 output_section_statement
,
5427 fill
, dot
, relax
, check_regions
);
5430 case lang_insert_statement_enum
:
5433 /* We can only get here when relaxing is turned on. */
5434 case lang_address_statement_enum
:
5441 prev
= &s
->header
.next
;
5446 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
5447 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
5448 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
5449 segments. We are allowed an opportunity to override this decision. */
5452 ldlang_override_segment_assignment (struct bfd_link_info
* info ATTRIBUTE_UNUSED
,
5453 bfd
* abfd ATTRIBUTE_UNUSED
,
5454 asection
* current_section
,
5455 asection
* previous_section
,
5456 bfd_boolean new_segment
)
5458 lang_output_section_statement_type
* cur
;
5459 lang_output_section_statement_type
* prev
;
5461 /* The checks below are only necessary when the BFD library has decided
5462 that the two sections ought to be placed into the same segment. */
5466 /* Paranoia checks. */
5467 if (current_section
== NULL
|| previous_section
== NULL
)
5470 /* If this flag is set, the target never wants code and non-code
5471 sections comingled in the same segment. */
5472 if (config
.separate_code
5473 && ((current_section
->flags
^ previous_section
->flags
) & SEC_CODE
))
5476 /* Find the memory regions associated with the two sections.
5477 We call lang_output_section_find() here rather than scanning the list
5478 of output sections looking for a matching section pointer because if
5479 we have a large number of sections then a hash lookup is faster. */
5480 cur
= lang_output_section_find (current_section
->name
);
5481 prev
= lang_output_section_find (previous_section
->name
);
5483 /* More paranoia. */
5484 if (cur
== NULL
|| prev
== NULL
)
5487 /* If the regions are different then force the sections to live in
5488 different segments. See the email thread starting at the following
5489 URL for the reasons why this is necessary:
5490 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
5491 return cur
->region
!= prev
->region
;
5495 one_lang_size_sections_pass (bfd_boolean
*relax
, bfd_boolean check_regions
)
5497 lang_statement_iteration
++;
5498 lang_size_sections_1 (&statement_list
.head
, abs_output_section
,
5499 0, 0, relax
, check_regions
);
5503 lang_size_sections (bfd_boolean
*relax
, bfd_boolean check_regions
)
5505 expld
.phase
= lang_allocating_phase_enum
;
5506 expld
.dataseg
.phase
= exp_dataseg_none
;
5508 one_lang_size_sections_pass (relax
, check_regions
);
5509 if (expld
.dataseg
.phase
== exp_dataseg_end_seen
5510 && link_info
.relro
&& expld
.dataseg
.relro_end
)
5512 bfd_vma initial_base
, relro_end
, desired_end
;
5515 /* Compute the expected PT_GNU_RELRO segment end. */
5516 relro_end
= ((expld
.dataseg
.relro_end
+ expld
.dataseg
.pagesize
- 1)
5517 & ~(expld
.dataseg
.pagesize
- 1));
5519 /* Adjust by the offset arg of DATA_SEGMENT_RELRO_END. */
5520 desired_end
= relro_end
- expld
.dataseg
.relro_offset
;
5522 /* For sections in the relro segment.. */
5523 for (sec
= link_info
.output_bfd
->section_last
; sec
; sec
= sec
->prev
)
5524 if ((sec
->flags
& SEC_ALLOC
) != 0
5525 && sec
->vma
>= expld
.dataseg
.base
5526 && sec
->vma
< expld
.dataseg
.relro_end
- expld
.dataseg
.relro_offset
)
5528 /* Where do we want to put this section so that it ends as
5530 bfd_vma start
, end
, bump
;
5532 end
= start
= sec
->vma
;
5534 end
+= TO_ADDR (sec
->size
);
5535 bump
= desired_end
- end
;
5536 /* We'd like to increase START by BUMP, but we must heed
5537 alignment so the increase might be less than optimum. */
5539 start
&= ~(((bfd_vma
) 1 << sec
->alignment_power
) - 1);
5540 /* This is now the desired end for the previous section. */
5541 desired_end
= start
;
5544 expld
.dataseg
.phase
= exp_dataseg_relro_adjust
;
5545 ASSERT (desired_end
>= expld
.dataseg
.base
);
5546 initial_base
= expld
.dataseg
.base
;
5547 expld
.dataseg
.base
= desired_end
;
5548 lang_reset_memory_regions ();
5549 one_lang_size_sections_pass (relax
, check_regions
);
5551 if (expld
.dataseg
.relro_end
> relro_end
)
5553 /* Assignments to dot, or to output section address in a
5554 user script have increased padding over the original.
5556 expld
.dataseg
.base
= initial_base
;
5557 lang_reset_memory_regions ();
5558 one_lang_size_sections_pass (relax
, check_regions
);
5561 link_info
.relro_start
= expld
.dataseg
.base
;
5562 link_info
.relro_end
= expld
.dataseg
.relro_end
;
5564 else if (expld
.dataseg
.phase
== exp_dataseg_end_seen
)
5566 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
5567 a page could be saved in the data segment. */
5568 bfd_vma first
, last
;
5570 first
= -expld
.dataseg
.base
& (expld
.dataseg
.pagesize
- 1);
5571 last
= expld
.dataseg
.end
& (expld
.dataseg
.pagesize
- 1);
5573 && ((expld
.dataseg
.base
& ~(expld
.dataseg
.pagesize
- 1))
5574 != (expld
.dataseg
.end
& ~(expld
.dataseg
.pagesize
- 1)))
5575 && first
+ last
<= expld
.dataseg
.pagesize
)
5577 expld
.dataseg
.phase
= exp_dataseg_adjust
;
5578 lang_reset_memory_regions ();
5579 one_lang_size_sections_pass (relax
, check_regions
);
5582 expld
.dataseg
.phase
= exp_dataseg_done
;
5585 expld
.dataseg
.phase
= exp_dataseg_done
;
5588 static lang_output_section_statement_type
*current_section
;
5589 static lang_assignment_statement_type
*current_assign
;
5590 static bfd_boolean prefer_next_section
;
5592 /* Worker function for lang_do_assignments. Recursiveness goes here. */
5595 lang_do_assignments_1 (lang_statement_union_type
*s
,
5596 lang_output_section_statement_type
*current_os
,
5599 bfd_boolean
*found_end
)
5601 for (; s
!= NULL
; s
= s
->header
.next
)
5603 switch (s
->header
.type
)
5605 case lang_constructors_statement_enum
:
5606 dot
= lang_do_assignments_1 (constructor_list
.head
,
5607 current_os
, fill
, dot
, found_end
);
5610 case lang_output_section_statement_enum
:
5612 lang_output_section_statement_type
*os
;
5614 os
= &(s
->output_section_statement
);
5615 os
->after_end
= *found_end
;
5616 if (os
->bfd_section
!= NULL
&& !os
->ignored
)
5618 if ((os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5620 current_section
= os
;
5621 prefer_next_section
= FALSE
;
5623 dot
= os
->bfd_section
->vma
;
5625 lang_do_assignments_1 (os
->children
.head
,
5626 os
, os
->fill
, dot
, found_end
);
5628 /* .tbss sections effectively have zero size. */
5629 if (!IS_TBSS (os
->bfd_section
)
5630 || bfd_link_relocatable (&link_info
))
5631 dot
+= TO_ADDR (os
->bfd_section
->size
);
5633 if (os
->update_dot_tree
!= NULL
)
5634 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5639 case lang_wild_statement_enum
:
5641 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
5642 current_os
, fill
, dot
, found_end
);
5645 case lang_object_symbols_statement_enum
:
5646 case lang_output_statement_enum
:
5647 case lang_target_statement_enum
:
5650 case lang_data_statement_enum
:
5651 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5652 if (expld
.result
.valid_p
)
5654 s
->data_statement
.value
= expld
.result
.value
;
5655 if (expld
.result
.section
!= NULL
)
5656 s
->data_statement
.value
+= expld
.result
.section
->vma
;
5659 einfo (_("%F%P: invalid data statement\n"));
5662 switch (s
->data_statement
.type
)
5680 if (size
< TO_SIZE ((unsigned) 1))
5681 size
= TO_SIZE ((unsigned) 1);
5682 dot
+= TO_ADDR (size
);
5686 case lang_reloc_statement_enum
:
5687 exp_fold_tree (s
->reloc_statement
.addend_exp
,
5688 bfd_abs_section_ptr
, &dot
);
5689 if (expld
.result
.valid_p
)
5690 s
->reloc_statement
.addend_value
= expld
.result
.value
;
5692 einfo (_("%F%P: invalid reloc statement\n"));
5693 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
5696 case lang_input_section_enum
:
5698 asection
*in
= s
->input_section
.section
;
5700 if ((in
->flags
& SEC_EXCLUDE
) == 0)
5701 dot
+= TO_ADDR (in
->size
);
5705 case lang_input_statement_enum
:
5708 case lang_fill_statement_enum
:
5709 fill
= s
->fill_statement
.fill
;
5712 case lang_assignment_statement_enum
:
5713 current_assign
= &s
->assignment_statement
;
5714 if (current_assign
->exp
->type
.node_class
!= etree_assert
)
5716 const char *p
= current_assign
->exp
->assign
.dst
;
5718 if (current_os
== abs_output_section
&& p
[0] == '.' && p
[1] == 0)
5719 prefer_next_section
= TRUE
;
5723 if (strcmp (p
, "end") == 0)
5726 exp_fold_tree (s
->assignment_statement
.exp
,
5727 current_os
->bfd_section
,
5731 case lang_padding_statement_enum
:
5732 dot
+= TO_ADDR (s
->padding_statement
.size
);
5735 case lang_group_statement_enum
:
5736 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
5737 current_os
, fill
, dot
, found_end
);
5740 case lang_insert_statement_enum
:
5743 case lang_address_statement_enum
:
5755 lang_do_assignments (lang_phase_type phase
)
5757 bfd_boolean found_end
= FALSE
;
5759 current_section
= NULL
;
5760 prefer_next_section
= FALSE
;
5761 expld
.phase
= phase
;
5762 lang_statement_iteration
++;
5763 lang_do_assignments_1 (statement_list
.head
,
5764 abs_output_section
, NULL
, 0, &found_end
);
5767 /* For an assignment statement outside of an output section statement,
5768 choose the best of neighbouring output sections to use for values
5772 section_for_dot (void)
5776 /* Assignments belong to the previous output section, unless there
5777 has been an assignment to "dot", in which case following
5778 assignments belong to the next output section. (The assumption
5779 is that an assignment to "dot" is setting up the address for the
5780 next output section.) Except that past the assignment to "_end"
5781 we always associate with the previous section. This exception is
5782 for targets like SH that define an alloc .stack or other
5783 weirdness after non-alloc sections. */
5784 if (current_section
== NULL
|| prefer_next_section
)
5786 lang_statement_union_type
*stmt
;
5787 lang_output_section_statement_type
*os
;
5789 for (stmt
= (lang_statement_union_type
*) current_assign
;
5791 stmt
= stmt
->header
.next
)
5792 if (stmt
->header
.type
== lang_output_section_statement_enum
)
5795 os
= &stmt
->output_section_statement
;
5798 && (os
->bfd_section
== NULL
5799 || (os
->bfd_section
->flags
& SEC_EXCLUDE
) != 0
5800 || bfd_section_removed_from_list (link_info
.output_bfd
,
5804 if (current_section
== NULL
|| os
== NULL
|| !os
->after_end
)
5807 s
= os
->bfd_section
;
5809 s
= link_info
.output_bfd
->section_last
;
5811 && ((s
->flags
& SEC_ALLOC
) == 0
5812 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
5817 return bfd_abs_section_ptr
;
5821 s
= current_section
->bfd_section
;
5823 /* The section may have been stripped. */
5825 && ((s
->flags
& SEC_EXCLUDE
) != 0
5826 || (s
->flags
& SEC_ALLOC
) == 0
5827 || (s
->flags
& SEC_THREAD_LOCAL
) != 0
5828 || bfd_section_removed_from_list (link_info
.output_bfd
, s
)))
5831 s
= link_info
.output_bfd
->sections
;
5833 && ((s
->flags
& SEC_ALLOC
) == 0
5834 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
5839 return bfd_abs_section_ptr
;
5842 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
5843 operator .startof. (section_name), it produces an undefined symbol
5844 .startof.section_name. Similarly, when it sees
5845 .sizeof. (section_name), it produces an undefined symbol
5846 .sizeof.section_name. For all the output sections, we look for
5847 such symbols, and set them to the correct value. */
5850 lang_set_startof (void)
5854 if (bfd_link_relocatable (&link_info
))
5857 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5859 const char *secname
;
5861 struct bfd_link_hash_entry
*h
;
5863 secname
= bfd_get_section_name (link_info
.output_bfd
, s
);
5864 buf
= (char *) xmalloc (10 + strlen (secname
));
5866 sprintf (buf
, ".startof.%s", secname
);
5867 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
5868 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
5870 h
->type
= bfd_link_hash_defined
;
5872 h
->u
.def
.section
= s
;
5875 sprintf (buf
, ".sizeof.%s", secname
);
5876 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
5877 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
5879 h
->type
= bfd_link_hash_defined
;
5880 h
->u
.def
.value
= TO_ADDR (s
->size
);
5881 h
->u
.def
.section
= bfd_abs_section_ptr
;
5891 struct bfd_link_hash_entry
*h
;
5894 if ((bfd_link_relocatable (&link_info
) && !link_info
.gc_sections
)
5895 || bfd_link_dll (&link_info
))
5896 warn
= entry_from_cmdline
;
5900 /* Force the user to specify a root when generating a relocatable with
5902 if (link_info
.gc_sections
&& bfd_link_relocatable (&link_info
)
5903 && !(entry_from_cmdline
|| undef_from_cmdline
))
5904 einfo (_("%P%F: gc-sections requires either an entry or "
5905 "an undefined symbol\n"));
5907 if (entry_symbol
.name
== NULL
)
5909 /* No entry has been specified. Look for the default entry, but
5910 don't warn if we don't find it. */
5911 entry_symbol
.name
= entry_symbol_default
;
5915 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
5916 FALSE
, FALSE
, TRUE
);
5918 && (h
->type
== bfd_link_hash_defined
5919 || h
->type
== bfd_link_hash_defweak
)
5920 && h
->u
.def
.section
->output_section
!= NULL
)
5924 val
= (h
->u
.def
.value
5925 + bfd_get_section_vma (link_info
.output_bfd
,
5926 h
->u
.def
.section
->output_section
)
5927 + h
->u
.def
.section
->output_offset
);
5928 if (! bfd_set_start_address (link_info
.output_bfd
, val
))
5929 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
.name
);
5936 /* We couldn't find the entry symbol. Try parsing it as a
5938 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
5941 if (! bfd_set_start_address (link_info
.output_bfd
, val
))
5942 einfo (_("%P%F: can't set start address\n"));
5948 /* Can't find the entry symbol, and it's not a number. Use
5949 the first address in the text section. */
5950 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
5954 einfo (_("%P: warning: cannot find entry symbol %s;"
5955 " defaulting to %V\n"),
5957 bfd_get_section_vma (link_info
.output_bfd
, ts
));
5958 if (!(bfd_set_start_address
5959 (link_info
.output_bfd
,
5960 bfd_get_section_vma (link_info
.output_bfd
, ts
))))
5961 einfo (_("%P%F: can't set start address\n"));
5966 einfo (_("%P: warning: cannot find entry symbol %s;"
5967 " not setting start address\n"),
5974 /* This is a small function used when we want to ignore errors from
5978 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
5980 /* Don't do anything. */
5983 /* Check that the architecture of all the input files is compatible
5984 with the output file. Also call the backend to let it do any
5985 other checking that is needed. */
5990 lang_statement_union_type
*file
;
5992 const bfd_arch_info_type
*compatible
;
5994 for (file
= file_chain
.head
; file
!= NULL
; file
= file
->input_statement
.next
)
5996 #ifdef ENABLE_PLUGINS
5997 /* Don't check format of files claimed by plugin. */
5998 if (file
->input_statement
.flags
.claimed
)
6000 #endif /* ENABLE_PLUGINS */
6001 input_bfd
= file
->input_statement
.the_bfd
;
6003 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
6004 command_line
.accept_unknown_input_arch
);
6006 /* In general it is not possible to perform a relocatable
6007 link between differing object formats when the input
6008 file has relocations, because the relocations in the
6009 input format may not have equivalent representations in
6010 the output format (and besides BFD does not translate
6011 relocs for other link purposes than a final link). */
6012 if ((bfd_link_relocatable (&link_info
)
6013 || link_info
.emitrelocations
)
6014 && (compatible
== NULL
6015 || (bfd_get_flavour (input_bfd
)
6016 != bfd_get_flavour (link_info
.output_bfd
)))
6017 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
6019 einfo (_("%P%F: Relocatable linking with relocations from"
6020 " format %s (%B) to format %s (%B) is not supported\n"),
6021 bfd_get_target (input_bfd
), input_bfd
,
6022 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
6023 /* einfo with %F exits. */
6026 if (compatible
== NULL
)
6028 if (command_line
.warn_mismatch
)
6029 einfo (_("%P%X: %s architecture of input file `%B'"
6030 " is incompatible with %s output\n"),
6031 bfd_printable_name (input_bfd
), input_bfd
,
6032 bfd_printable_name (link_info
.output_bfd
));
6034 else if (bfd_count_sections (input_bfd
))
6036 /* If the input bfd has no contents, it shouldn't set the
6037 private data of the output bfd. */
6039 bfd_error_handler_type pfn
= NULL
;
6041 /* If we aren't supposed to warn about mismatched input
6042 files, temporarily set the BFD error handler to a
6043 function which will do nothing. We still want to call
6044 bfd_merge_private_bfd_data, since it may set up
6045 information which is needed in the output file. */
6046 if (! command_line
.warn_mismatch
)
6047 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
6048 if (! bfd_merge_private_bfd_data (input_bfd
, link_info
.output_bfd
))
6050 if (command_line
.warn_mismatch
)
6051 einfo (_("%P%X: failed to merge target specific data"
6052 " of file %B\n"), input_bfd
);
6054 if (! command_line
.warn_mismatch
)
6055 bfd_set_error_handler (pfn
);
6060 /* Look through all the global common symbols and attach them to the
6061 correct section. The -sort-common command line switch may be used
6062 to roughly sort the entries by alignment. */
6067 if (command_line
.inhibit_common_definition
)
6069 if (bfd_link_relocatable (&link_info
)
6070 && ! command_line
.force_common_definition
)
6073 if (! config
.sort_common
)
6074 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
6079 if (config
.sort_common
== sort_descending
)
6081 for (power
= 4; power
> 0; power
--)
6082 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6085 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6089 for (power
= 0; power
<= 4; power
++)
6090 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6092 power
= (unsigned int) -1;
6093 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6098 /* Place one common symbol in the correct section. */
6101 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
6103 unsigned int power_of_two
;
6107 if (h
->type
!= bfd_link_hash_common
)
6111 power_of_two
= h
->u
.c
.p
->alignment_power
;
6113 if (config
.sort_common
== sort_descending
6114 && power_of_two
< *(unsigned int *) info
)
6116 else if (config
.sort_common
== sort_ascending
6117 && power_of_two
> *(unsigned int *) info
)
6120 section
= h
->u
.c
.p
->section
;
6121 if (!bfd_define_common_symbol (link_info
.output_bfd
, &link_info
, h
))
6122 einfo (_("%P%F: Could not define common symbol `%T': %E\n"),
6125 if (config
.map_file
!= NULL
)
6127 static bfd_boolean header_printed
;
6132 if (! header_printed
)
6134 minfo (_("\nAllocating common symbols\n"));
6135 minfo (_("Common symbol size file\n\n"));
6136 header_printed
= TRUE
;
6139 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
6140 DMGL_ANSI
| DMGL_PARAMS
);
6143 minfo ("%s", h
->root
.string
);
6144 len
= strlen (h
->root
.string
);
6149 len
= strlen (name
);
6165 if (size
<= 0xffffffff)
6166 sprintf (buf
, "%lx", (unsigned long) size
);
6168 sprintf_vma (buf
, size
);
6178 minfo ("%B\n", section
->owner
);
6184 /* Handle a single orphan section S, placing the orphan into an appropriate
6185 output section. The effects of the --orphan-handling command line
6186 option are handled here. */
6189 ldlang_place_orphan (asection
*s
)
6191 if (config
.orphan_handling
== orphan_handling_discard
)
6193 lang_output_section_statement_type
*os
;
6194 os
= lang_output_section_statement_lookup (DISCARD_SECTION_NAME
, 0,
6196 if (os
->addr_tree
== NULL
6197 && (bfd_link_relocatable (&link_info
)
6198 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6199 os
->addr_tree
= exp_intop (0);
6200 lang_add_section (&os
->children
, s
, NULL
, os
);
6204 lang_output_section_statement_type
*os
;
6205 const char *name
= s
->name
;
6208 if (config
.orphan_handling
== orphan_handling_error
)
6209 einfo ("%X%P: error: unplaced orphan section `%A' from `%B'.\n",
6212 if (config
.unique_orphan_sections
|| unique_section_p (s
, NULL
))
6213 constraint
= SPECIAL
;
6215 os
= ldemul_place_orphan (s
, name
, constraint
);
6218 os
= lang_output_section_statement_lookup (name
, constraint
, TRUE
);
6219 if (os
->addr_tree
== NULL
6220 && (bfd_link_relocatable (&link_info
)
6221 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6222 os
->addr_tree
= exp_intop (0);
6223 lang_add_section (&os
->children
, s
, NULL
, os
);
6226 if (config
.orphan_handling
== orphan_handling_warn
)
6227 einfo ("%P: warning: orphan section `%A' from `%B' being "
6228 "placed in section `%s'.\n",
6229 s
, s
->owner
, os
->name
);
6233 /* Run through the input files and ensure that every input section has
6234 somewhere to go. If one is found without a destination then create
6235 an input request and place it into the statement tree. */
6238 lang_place_orphans (void)
6240 LANG_FOR_EACH_INPUT_STATEMENT (file
)
6244 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6246 if (s
->output_section
== NULL
)
6248 /* This section of the file is not attached, root
6249 around for a sensible place for it to go. */
6251 if (file
->flags
.just_syms
)
6252 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
6253 else if ((s
->flags
& SEC_EXCLUDE
) != 0)
6254 s
->output_section
= bfd_abs_section_ptr
;
6255 else if (strcmp (s
->name
, "COMMON") == 0)
6257 /* This is a lonely common section which must have
6258 come from an archive. We attach to the section
6259 with the wildcard. */
6260 if (!bfd_link_relocatable (&link_info
)
6261 || command_line
.force_common_definition
)
6263 if (default_common_section
== NULL
)
6264 default_common_section
6265 = lang_output_section_statement_lookup (".bss", 0,
6267 lang_add_section (&default_common_section
->children
, s
,
6268 NULL
, default_common_section
);
6272 ldlang_place_orphan (s
);
6279 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
6281 flagword
*ptr_flags
;
6283 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
6289 /* PR 17900: An exclamation mark in the attributes reverses
6290 the sense of any of the attributes that follow. */
6293 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
6297 *ptr_flags
|= SEC_ALLOC
;
6301 *ptr_flags
|= SEC_READONLY
;
6305 *ptr_flags
|= SEC_DATA
;
6309 *ptr_flags
|= SEC_CODE
;
6314 *ptr_flags
|= SEC_LOAD
;
6318 einfo (_("%P%F: invalid character %c (%d) in flags\n"), * flags
, * flags
);
6325 /* Call a function on each input file. This function will be called
6326 on an archive, but not on the elements. */
6329 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
6331 lang_input_statement_type
*f
;
6333 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
6335 f
= (lang_input_statement_type
*) f
->next_real_file
)
6339 /* Call a function on each file. The function will be called on all
6340 the elements of an archive which are included in the link, but will
6341 not be called on the archive file itself. */
6344 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
6346 LANG_FOR_EACH_INPUT_STATEMENT (f
)
6353 ldlang_add_file (lang_input_statement_type
*entry
)
6355 lang_statement_append (&file_chain
,
6356 (lang_statement_union_type
*) entry
,
6359 /* The BFD linker needs to have a list of all input BFDs involved in
6361 ASSERT (entry
->the_bfd
->link
.next
== NULL
);
6362 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
6364 *link_info
.input_bfds_tail
= entry
->the_bfd
;
6365 link_info
.input_bfds_tail
= &entry
->the_bfd
->link
.next
;
6366 entry
->the_bfd
->usrdata
= entry
;
6367 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
6369 /* Look through the sections and check for any which should not be
6370 included in the link. We need to do this now, so that we can
6371 notice when the backend linker tries to report multiple
6372 definition errors for symbols which are in sections we aren't
6373 going to link. FIXME: It might be better to entirely ignore
6374 symbols which are defined in sections which are going to be
6375 discarded. This would require modifying the backend linker for
6376 each backend which might set the SEC_LINK_ONCE flag. If we do
6377 this, we should probably handle SEC_EXCLUDE in the same way. */
6379 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
6383 lang_add_output (const char *name
, int from_script
)
6385 /* Make -o on command line override OUTPUT in script. */
6386 if (!had_output_filename
|| !from_script
)
6388 output_filename
= name
;
6389 had_output_filename
= TRUE
;
6402 for (l
= 0; l
< 32; l
++)
6404 if (i
>= (unsigned int) x
)
6412 lang_output_section_statement_type
*
6413 lang_enter_output_section_statement (const char *output_section_statement_name
,
6414 etree_type
*address_exp
,
6415 enum section_type sectype
,
6417 etree_type
*subalign
,
6420 int align_with_input
)
6422 lang_output_section_statement_type
*os
;
6424 os
= lang_output_section_statement_lookup (output_section_statement_name
,
6426 current_section
= os
;
6428 if (os
->addr_tree
== NULL
)
6430 os
->addr_tree
= address_exp
;
6432 os
->sectype
= sectype
;
6433 if (sectype
!= noload_section
)
6434 os
->flags
= SEC_NO_FLAGS
;
6436 os
->flags
= SEC_NEVER_LOAD
;
6437 os
->block_value
= 1;
6439 /* Make next things chain into subchain of this. */
6440 push_stat_ptr (&os
->children
);
6442 os
->align_lma_with_input
= align_with_input
== ALIGN_WITH_INPUT
;
6443 if (os
->align_lma_with_input
&& align
!= NULL
)
6444 einfo (_("%F%P:%S: error: align with input and explicit align specified\n"), NULL
);
6446 os
->subsection_alignment
=
6447 topower (exp_get_value_int (subalign
, -1, "subsection alignment"));
6448 os
->section_alignment
=
6449 topower (exp_get_value_int (align
, -1, "section alignment"));
6451 os
->load_base
= ebase
;
6458 lang_output_statement_type
*new_stmt
;
6460 new_stmt
= new_stat (lang_output_statement
, stat_ptr
);
6461 new_stmt
->name
= output_filename
;
6464 /* Reset the current counters in the regions. */
6467 lang_reset_memory_regions (void)
6469 lang_memory_region_type
*p
= lang_memory_region_list
;
6471 lang_output_section_statement_type
*os
;
6473 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
6475 p
->current
= p
->origin
;
6479 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
6483 os
->processed_vma
= FALSE
;
6484 os
->processed_lma
= FALSE
;
6487 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6489 /* Save the last size for possible use by bfd_relax_section. */
6490 o
->rawsize
= o
->size
;
6495 /* Worker for lang_gc_sections_1. */
6498 gc_section_callback (lang_wild_statement_type
*ptr
,
6499 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
6501 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
6502 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
6503 void *data ATTRIBUTE_UNUSED
)
6505 /* If the wild pattern was marked KEEP, the member sections
6506 should be as well. */
6507 if (ptr
->keep_sections
)
6508 section
->flags
|= SEC_KEEP
;
6511 /* Iterate over sections marking them against GC. */
6514 lang_gc_sections_1 (lang_statement_union_type
*s
)
6516 for (; s
!= NULL
; s
= s
->header
.next
)
6518 switch (s
->header
.type
)
6520 case lang_wild_statement_enum
:
6521 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
6523 case lang_constructors_statement_enum
:
6524 lang_gc_sections_1 (constructor_list
.head
);
6526 case lang_output_section_statement_enum
:
6527 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
6529 case lang_group_statement_enum
:
6530 lang_gc_sections_1 (s
->group_statement
.children
.head
);
6539 lang_gc_sections (void)
6541 /* Keep all sections so marked in the link script. */
6542 lang_gc_sections_1 (statement_list
.head
);
6544 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
6545 the special case of debug info. (See bfd/stabs.c)
6546 Twiddle the flag here, to simplify later linker code. */
6547 if (bfd_link_relocatable (&link_info
))
6549 LANG_FOR_EACH_INPUT_STATEMENT (f
)
6552 #ifdef ENABLE_PLUGINS
6553 if (f
->flags
.claimed
)
6556 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6557 if ((sec
->flags
& SEC_DEBUGGING
) == 0)
6558 sec
->flags
&= ~SEC_EXCLUDE
;
6562 if (link_info
.gc_sections
)
6563 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
6566 /* Worker for lang_find_relro_sections_1. */
6569 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
6570 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
6572 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
6573 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
6576 /* Discarded, excluded and ignored sections effectively have zero
6578 if (section
->output_section
!= NULL
6579 && section
->output_section
->owner
== link_info
.output_bfd
6580 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
6581 && !IGNORE_SECTION (section
)
6582 && section
->size
!= 0)
6584 bfd_boolean
*has_relro_section
= (bfd_boolean
*) data
;
6585 *has_relro_section
= TRUE
;
6589 /* Iterate over sections for relro sections. */
6592 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
6593 bfd_boolean
*has_relro_section
)
6595 if (*has_relro_section
)
6598 for (; s
!= NULL
; s
= s
->header
.next
)
6600 if (s
== expld
.dataseg
.relro_end_stat
)
6603 switch (s
->header
.type
)
6605 case lang_wild_statement_enum
:
6606 walk_wild (&s
->wild_statement
,
6607 find_relro_section_callback
,
6610 case lang_constructors_statement_enum
:
6611 lang_find_relro_sections_1 (constructor_list
.head
,
6614 case lang_output_section_statement_enum
:
6615 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
6618 case lang_group_statement_enum
:
6619 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
6629 lang_find_relro_sections (void)
6631 bfd_boolean has_relro_section
= FALSE
;
6633 /* Check all sections in the link script. */
6635 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
6636 &has_relro_section
);
6638 if (!has_relro_section
)
6639 link_info
.relro
= FALSE
;
6642 /* Relax all sections until bfd_relax_section gives up. */
6645 lang_relax_sections (bfd_boolean need_layout
)
6647 if (RELAXATION_ENABLED
)
6649 /* We may need more than one relaxation pass. */
6650 int i
= link_info
.relax_pass
;
6652 /* The backend can use it to determine the current pass. */
6653 link_info
.relax_pass
= 0;
6657 /* Keep relaxing until bfd_relax_section gives up. */
6658 bfd_boolean relax_again
;
6660 link_info
.relax_trip
= -1;
6663 link_info
.relax_trip
++;
6665 /* Note: pe-dll.c does something like this also. If you find
6666 you need to change this code, you probably need to change
6667 pe-dll.c also. DJ */
6669 /* Do all the assignments with our current guesses as to
6671 lang_do_assignments (lang_assigning_phase_enum
);
6673 /* We must do this after lang_do_assignments, because it uses
6675 lang_reset_memory_regions ();
6677 /* Perform another relax pass - this time we know where the
6678 globals are, so can make a better guess. */
6679 relax_again
= FALSE
;
6680 lang_size_sections (&relax_again
, FALSE
);
6682 while (relax_again
);
6684 link_info
.relax_pass
++;
6691 /* Final extra sizing to report errors. */
6692 lang_do_assignments (lang_assigning_phase_enum
);
6693 lang_reset_memory_regions ();
6694 lang_size_sections (NULL
, TRUE
);
6698 #ifdef ENABLE_PLUGINS
6699 /* Find the insert point for the plugin's replacement files. We
6700 place them after the first claimed real object file, or if the
6701 first claimed object is an archive member, after the last real
6702 object file immediately preceding the archive. In the event
6703 no objects have been claimed at all, we return the first dummy
6704 object file on the list as the insert point; that works, but
6705 the callee must be careful when relinking the file_chain as it
6706 is not actually on that chain, only the statement_list and the
6707 input_file list; in that case, the replacement files must be
6708 inserted at the head of the file_chain. */
6710 static lang_input_statement_type
*
6711 find_replacements_insert_point (void)
6713 lang_input_statement_type
*claim1
, *lastobject
;
6714 lastobject
= &input_file_chain
.head
->input_statement
;
6715 for (claim1
= &file_chain
.head
->input_statement
;
6717 claim1
= &claim1
->next
->input_statement
)
6719 if (claim1
->flags
.claimed
)
6720 return claim1
->flags
.claim_archive
? lastobject
: claim1
;
6721 /* Update lastobject if this is a real object file. */
6722 if (claim1
->the_bfd
&& (claim1
->the_bfd
->my_archive
== NULL
))
6723 lastobject
= claim1
;
6725 /* No files were claimed by the plugin. Choose the last object
6726 file found on the list (maybe the first, dummy entry) as the
6731 /* Insert SRCLIST into DESTLIST after given element by chaining
6732 on FIELD as the next-pointer. (Counterintuitively does not need
6733 a pointer to the actual after-node itself, just its chain field.) */
6736 lang_list_insert_after (lang_statement_list_type
*destlist
,
6737 lang_statement_list_type
*srclist
,
6738 lang_statement_union_type
**field
)
6740 *(srclist
->tail
) = *field
;
6741 *field
= srclist
->head
;
6742 if (destlist
->tail
== field
)
6743 destlist
->tail
= srclist
->tail
;
6746 /* Detach new nodes added to DESTLIST since the time ORIGLIST
6747 was taken as a copy of it and leave them in ORIGLIST. */
6750 lang_list_remove_tail (lang_statement_list_type
*destlist
,
6751 lang_statement_list_type
*origlist
)
6753 union lang_statement_union
**savetail
;
6754 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
6755 ASSERT (origlist
->head
== destlist
->head
);
6756 savetail
= origlist
->tail
;
6757 origlist
->head
= *(savetail
);
6758 origlist
->tail
= destlist
->tail
;
6759 destlist
->tail
= savetail
;
6762 #endif /* ENABLE_PLUGINS */
6764 /* Add NAME to the list of garbage collection entry points. */
6767 lang_add_gc_name (const char * name
)
6769 struct bfd_sym_chain
*sym
;
6774 sym
= (struct bfd_sym_chain
*) stat_alloc (sizeof (*sym
));
6776 sym
->next
= link_info
.gc_sym_list
;
6778 link_info
.gc_sym_list
= sym
;
6781 /* Check relocations. */
6784 lang_check_relocs (void)
6786 if (link_info
.check_relocs_after_open_input
6787 && bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
6791 for (abfd
= link_info
.input_bfds
;
6792 abfd
!= (bfd
*) NULL
; abfd
= abfd
->link
.next
)
6793 if (!_bfd_elf_link_check_relocs (abfd
, &link_info
))
6795 /* no object output, fail return */
6796 config
.make_executable
= FALSE
;
6805 /* Finalize dynamic list. */
6806 if (link_info
.dynamic_list
)
6807 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
6809 current_target
= default_target
;
6811 /* Open the output file. */
6812 lang_for_each_statement (ldlang_open_output
);
6815 ldemul_create_output_section_statements ();
6817 /* Add to the hash table all undefineds on the command line. */
6818 lang_place_undefineds ();
6820 if (!bfd_section_already_linked_table_init ())
6821 einfo (_("%P%F: Failed to create hash table\n"));
6823 /* Create a bfd for each input file. */
6824 current_target
= default_target
;
6825 open_input_bfds (statement_list
.head
, OPEN_BFD_NORMAL
);
6827 #ifdef ENABLE_PLUGINS
6828 if (link_info
.lto_plugin_active
)
6830 lang_statement_list_type added
;
6831 lang_statement_list_type files
, inputfiles
;
6833 /* Now all files are read, let the plugin(s) decide if there
6834 are any more to be added to the link before we call the
6835 emulation's after_open hook. We create a private list of
6836 input statements for this purpose, which we will eventually
6837 insert into the global statment list after the first claimed
6840 /* We need to manipulate all three chains in synchrony. */
6842 inputfiles
= input_file_chain
;
6843 if (plugin_call_all_symbols_read ())
6844 einfo (_("%P%F: %s: plugin reported error after all symbols read\n"),
6845 plugin_error_plugin ());
6846 /* Open any newly added files, updating the file chains. */
6847 open_input_bfds (*added
.tail
, OPEN_BFD_NORMAL
);
6848 /* Restore the global list pointer now they have all been added. */
6849 lang_list_remove_tail (stat_ptr
, &added
);
6850 /* And detach the fresh ends of the file lists. */
6851 lang_list_remove_tail (&file_chain
, &files
);
6852 lang_list_remove_tail (&input_file_chain
, &inputfiles
);
6853 /* Were any new files added? */
6854 if (added
.head
!= NULL
)
6856 /* If so, we will insert them into the statement list immediately
6857 after the first input file that was claimed by the plugin. */
6858 plugin_insert
= find_replacements_insert_point ();
6859 /* If a plugin adds input files without having claimed any, we
6860 don't really have a good idea where to place them. Just putting
6861 them at the start or end of the list is liable to leave them
6862 outside the crtbegin...crtend range. */
6863 ASSERT (plugin_insert
!= NULL
);
6864 /* Splice the new statement list into the old one. */
6865 lang_list_insert_after (stat_ptr
, &added
,
6866 &plugin_insert
->header
.next
);
6867 /* Likewise for the file chains. */
6868 lang_list_insert_after (&input_file_chain
, &inputfiles
,
6869 &plugin_insert
->next_real_file
);
6870 /* We must be careful when relinking file_chain; we may need to
6871 insert the new files at the head of the list if the insert
6872 point chosen is the dummy first input file. */
6873 if (plugin_insert
->filename
)
6874 lang_list_insert_after (&file_chain
, &files
, &plugin_insert
->next
);
6876 lang_list_insert_after (&file_chain
, &files
, &file_chain
.head
);
6878 /* Rescan archives in case new undefined symbols have appeared. */
6879 open_input_bfds (statement_list
.head
, OPEN_BFD_RESCAN
);
6882 #endif /* ENABLE_PLUGINS */
6884 /* Make sure that nobody has tried to add a symbol to this list before now. */
6885 ASSERT (link_info
.gc_sym_list
== NULL
);
6887 link_info
.gc_sym_list
= &entry_symbol
;
6889 if (entry_symbol
.name
== NULL
)
6891 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
6893 /* entry_symbol is normally initialied by a ENTRY definition in the
6894 linker script or the -e command line option. But if neither of
6895 these have been used, the target specific backend may still have
6896 provided an entry symbol via a call to lang_default_entry().
6897 Unfortunately this value will not be processed until lang_end()
6898 is called, long after this function has finished. So detect this
6899 case here and add the target's entry symbol to the list of starting
6900 points for garbage collection resolution. */
6901 lang_add_gc_name (entry_symbol_default
);
6904 lang_add_gc_name (link_info
.init_function
);
6905 lang_add_gc_name (link_info
.fini_function
);
6907 ldemul_after_open ();
6908 if (config
.map_file
!= NULL
)
6909 lang_print_asneeded ();
6911 bfd_section_already_linked_table_free ();
6913 /* Make sure that we're not mixing architectures. We call this
6914 after all the input files have been opened, but before we do any
6915 other processing, so that any operations merge_private_bfd_data
6916 does on the output file will be known during the rest of the
6920 /* Handle .exports instead of a version script if we're told to do so. */
6921 if (command_line
.version_exports_section
)
6922 lang_do_version_exports_section ();
6924 /* Build all sets based on the information gathered from the input
6926 ldctor_build_sets ();
6928 /* PR 13683: We must rerun the assignments prior to running garbage
6929 collection in order to make sure that all symbol aliases are resolved. */
6930 lang_do_assignments (lang_mark_phase_enum
);
6932 lang_do_memory_regions();
6933 expld
.phase
= lang_first_phase_enum
;
6935 /* Size up the common data. */
6938 /* Remove unreferenced sections if asked to. */
6939 lang_gc_sections ();
6941 /* Check relocations. */
6942 lang_check_relocs ();
6944 /* Update wild statements. */
6945 update_wild_statements (statement_list
.head
);
6947 /* Run through the contours of the script and attach input sections
6948 to the correct output sections. */
6949 lang_statement_iteration
++;
6950 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
6952 process_insert_statements ();
6954 /* Find any sections not attached explicitly and handle them. */
6955 lang_place_orphans ();
6957 if (!bfd_link_relocatable (&link_info
))
6961 /* Merge SEC_MERGE sections. This has to be done after GC of
6962 sections, so that GCed sections are not merged, but before
6963 assigning dynamic symbols, since removing whole input sections
6965 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
6967 /* Look for a text section and set the readonly attribute in it. */
6968 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
6972 if (config
.text_read_only
)
6973 found
->flags
|= SEC_READONLY
;
6975 found
->flags
&= ~SEC_READONLY
;
6979 /* Do anything special before sizing sections. This is where ELF
6980 and other back-ends size dynamic sections. */
6981 ldemul_before_allocation ();
6983 /* We must record the program headers before we try to fix the
6984 section positions, since they will affect SIZEOF_HEADERS. */
6985 lang_record_phdrs ();
6987 /* Check relro sections. */
6988 if (link_info
.relro
&& !bfd_link_relocatable (&link_info
))
6989 lang_find_relro_sections ();
6991 /* Size up the sections. */
6992 lang_size_sections (NULL
, ! RELAXATION_ENABLED
);
6994 /* See if anything special should be done now we know how big
6995 everything is. This is where relaxation is done. */
6996 ldemul_after_allocation ();
6998 /* Fix any .startof. or .sizeof. symbols. */
6999 lang_set_startof ();
7001 /* Do all the assignments, now that we know the final resting places
7002 of all the symbols. */
7003 lang_do_assignments (lang_final_phase_enum
);
7007 /* Convert absolute symbols to section relative. */
7008 ldexp_finalize_syms ();
7010 /* Make sure that the section addresses make sense. */
7011 if (command_line
.check_section_addresses
)
7012 lang_check_section_addresses ();
7014 /* Check any required symbols are known. */
7015 ldlang_check_require_defined_symbols ();
7020 /* EXPORTED TO YACC */
7023 lang_add_wild (struct wildcard_spec
*filespec
,
7024 struct wildcard_list
*section_list
,
7025 bfd_boolean keep_sections
)
7027 struct wildcard_list
*curr
, *next
;
7028 lang_wild_statement_type
*new_stmt
;
7030 /* Reverse the list as the parser puts it back to front. */
7031 for (curr
= section_list
, section_list
= NULL
;
7033 section_list
= curr
, curr
= next
)
7035 if (curr
->spec
.name
!= NULL
&& strcmp (curr
->spec
.name
, "COMMON") == 0)
7036 placed_commons
= TRUE
;
7039 curr
->next
= section_list
;
7042 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
7044 if (strcmp (filespec
->name
, "*") == 0)
7045 filespec
->name
= NULL
;
7046 else if (! wildcardp (filespec
->name
))
7047 lang_has_input_file
= TRUE
;
7050 new_stmt
= new_stat (lang_wild_statement
, stat_ptr
);
7051 new_stmt
->filename
= NULL
;
7052 new_stmt
->filenames_sorted
= FALSE
;
7053 new_stmt
->section_flag_list
= NULL
;
7054 if (filespec
!= NULL
)
7056 new_stmt
->filename
= filespec
->name
;
7057 new_stmt
->filenames_sorted
= filespec
->sorted
== by_name
;
7058 new_stmt
->section_flag_list
= filespec
->section_flag_list
;
7060 new_stmt
->section_list
= section_list
;
7061 new_stmt
->keep_sections
= keep_sections
;
7062 lang_list_init (&new_stmt
->children
);
7063 analyze_walk_wild_section_handler (new_stmt
);
7067 lang_section_start (const char *name
, etree_type
*address
,
7068 const segment_type
*segment
)
7070 lang_address_statement_type
*ad
;
7072 ad
= new_stat (lang_address_statement
, stat_ptr
);
7073 ad
->section_name
= name
;
7074 ad
->address
= address
;
7075 ad
->segment
= segment
;
7078 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
7079 because of a -e argument on the command line, or zero if this is
7080 called by ENTRY in a linker script. Command line arguments take
7084 lang_add_entry (const char *name
, bfd_boolean cmdline
)
7086 if (entry_symbol
.name
== NULL
7088 || ! entry_from_cmdline
)
7090 entry_symbol
.name
= name
;
7091 entry_from_cmdline
= cmdline
;
7095 /* Set the default start symbol to NAME. .em files should use this,
7096 not lang_add_entry, to override the use of "start" if neither the
7097 linker script nor the command line specifies an entry point. NAME
7098 must be permanently allocated. */
7100 lang_default_entry (const char *name
)
7102 entry_symbol_default
= name
;
7106 lang_add_target (const char *name
)
7108 lang_target_statement_type
*new_stmt
;
7110 new_stmt
= new_stat (lang_target_statement
, stat_ptr
);
7111 new_stmt
->target
= name
;
7115 lang_add_map (const char *name
)
7122 map_option_f
= TRUE
;
7130 lang_add_fill (fill_type
*fill
)
7132 lang_fill_statement_type
*new_stmt
;
7134 new_stmt
= new_stat (lang_fill_statement
, stat_ptr
);
7135 new_stmt
->fill
= fill
;
7139 lang_add_data (int type
, union etree_union
*exp
)
7141 lang_data_statement_type
*new_stmt
;
7143 new_stmt
= new_stat (lang_data_statement
, stat_ptr
);
7144 new_stmt
->exp
= exp
;
7145 new_stmt
->type
= type
;
7148 /* Create a new reloc statement. RELOC is the BFD relocation type to
7149 generate. HOWTO is the corresponding howto structure (we could
7150 look this up, but the caller has already done so). SECTION is the
7151 section to generate a reloc against, or NAME is the name of the
7152 symbol to generate a reloc against. Exactly one of SECTION and
7153 NAME must be NULL. ADDEND is an expression for the addend. */
7156 lang_add_reloc (bfd_reloc_code_real_type reloc
,
7157 reloc_howto_type
*howto
,
7160 union etree_union
*addend
)
7162 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
7166 p
->section
= section
;
7168 p
->addend_exp
= addend
;
7170 p
->addend_value
= 0;
7171 p
->output_section
= NULL
;
7172 p
->output_offset
= 0;
7175 lang_assignment_statement_type
*
7176 lang_add_assignment (etree_type
*exp
)
7178 lang_assignment_statement_type
*new_stmt
;
7180 new_stmt
= new_stat (lang_assignment_statement
, stat_ptr
);
7181 new_stmt
->exp
= exp
;
7186 lang_add_attribute (enum statement_enum attribute
)
7188 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
7192 lang_startup (const char *name
)
7194 if (first_file
->filename
!= NULL
)
7196 einfo (_("%P%F: multiple STARTUP files\n"));
7198 first_file
->filename
= name
;
7199 first_file
->local_sym_name
= name
;
7200 first_file
->flags
.real
= TRUE
;
7204 lang_float (bfd_boolean maybe
)
7206 lang_float_flag
= maybe
;
7210 /* Work out the load- and run-time regions from a script statement, and
7211 store them in *LMA_REGION and *REGION respectively.
7213 MEMSPEC is the name of the run-time region, or the value of
7214 DEFAULT_MEMORY_REGION if the statement didn't specify one.
7215 LMA_MEMSPEC is the name of the load-time region, or null if the
7216 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
7217 had an explicit load address.
7219 It is an error to specify both a load region and a load address. */
7222 lang_get_regions (lang_memory_region_type
**region
,
7223 lang_memory_region_type
**lma_region
,
7224 const char *memspec
,
7225 const char *lma_memspec
,
7226 bfd_boolean have_lma
,
7227 bfd_boolean have_vma
)
7229 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
7231 /* If no runtime region or VMA has been specified, but the load region
7232 has been specified, then use the load region for the runtime region
7234 if (lma_memspec
!= NULL
7236 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
7237 *region
= *lma_region
;
7239 *region
= lang_memory_region_lookup (memspec
, FALSE
);
7241 if (have_lma
&& lma_memspec
!= 0)
7242 einfo (_("%X%P:%S: section has both a load address and a load region\n"),
7247 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
7248 lang_output_section_phdr_list
*phdrs
,
7249 const char *lma_memspec
)
7251 lang_get_regions (¤t_section
->region
,
7252 ¤t_section
->lma_region
,
7253 memspec
, lma_memspec
,
7254 current_section
->load_base
!= NULL
,
7255 current_section
->addr_tree
!= NULL
);
7257 /* If this section has no load region or base, but uses the same
7258 region as the previous section, then propagate the previous
7259 section's load region. */
7261 if (current_section
->lma_region
== NULL
7262 && current_section
->load_base
== NULL
7263 && current_section
->addr_tree
== NULL
7264 && current_section
->region
== current_section
->prev
->region
)
7265 current_section
->lma_region
= current_section
->prev
->lma_region
;
7267 current_section
->fill
= fill
;
7268 current_section
->phdrs
= phdrs
;
7273 lang_statement_append (lang_statement_list_type
*list
,
7274 lang_statement_union_type
*element
,
7275 lang_statement_union_type
**field
)
7277 *(list
->tail
) = element
;
7281 /* Set the output format type. -oformat overrides scripts. */
7284 lang_add_output_format (const char *format
,
7289 if (output_target
== NULL
|| !from_script
)
7291 if (command_line
.endian
== ENDIAN_BIG
7294 else if (command_line
.endian
== ENDIAN_LITTLE
7298 output_target
= format
;
7303 lang_add_insert (const char *where
, int is_before
)
7305 lang_insert_statement_type
*new_stmt
;
7307 new_stmt
= new_stat (lang_insert_statement
, stat_ptr
);
7308 new_stmt
->where
= where
;
7309 new_stmt
->is_before
= is_before
;
7310 saved_script_handle
= previous_script_handle
;
7313 /* Enter a group. This creates a new lang_group_statement, and sets
7314 stat_ptr to build new statements within the group. */
7317 lang_enter_group (void)
7319 lang_group_statement_type
*g
;
7321 g
= new_stat (lang_group_statement
, stat_ptr
);
7322 lang_list_init (&g
->children
);
7323 push_stat_ptr (&g
->children
);
7326 /* Leave a group. This just resets stat_ptr to start writing to the
7327 regular list of statements again. Note that this will not work if
7328 groups can occur inside anything else which can adjust stat_ptr,
7329 but currently they can't. */
7332 lang_leave_group (void)
7337 /* Add a new program header. This is called for each entry in a PHDRS
7338 command in a linker script. */
7341 lang_new_phdr (const char *name
,
7343 bfd_boolean filehdr
,
7348 struct lang_phdr
*n
, **pp
;
7351 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
7354 n
->type
= exp_get_value_int (type
, 0, "program header type");
7355 n
->filehdr
= filehdr
;
7360 hdrs
= n
->type
== 1 && (phdrs
|| filehdr
);
7362 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
7365 && !((*pp
)->filehdr
|| (*pp
)->phdrs
))
7367 einfo (_("%X%P:%S: PHDRS and FILEHDR are not supported"
7368 " when prior PT_LOAD headers lack them\n"), NULL
);
7375 /* Record the program header information in the output BFD. FIXME: We
7376 should not be calling an ELF specific function here. */
7379 lang_record_phdrs (void)
7383 lang_output_section_phdr_list
*last
;
7384 struct lang_phdr
*l
;
7385 lang_output_section_statement_type
*os
;
7388 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
7391 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
7398 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
7402 lang_output_section_phdr_list
*pl
;
7404 if (os
->constraint
< 0)
7412 if (os
->sectype
== noload_section
7413 || os
->bfd_section
== NULL
7414 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
7417 /* Don't add orphans to PT_INTERP header. */
7423 lang_output_section_statement_type
* tmp_os
;
7425 /* If we have not run across a section with a program
7426 header assigned to it yet, then scan forwards to find
7427 one. This prevents inconsistencies in the linker's
7428 behaviour when a script has specified just a single
7429 header and there are sections in that script which are
7430 not assigned to it, and which occur before the first
7431 use of that header. See here for more details:
7432 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
7433 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
7436 last
= tmp_os
->phdrs
;
7440 einfo (_("%F%P: no sections assigned to phdrs\n"));
7445 if (os
->bfd_section
== NULL
)
7448 for (; pl
!= NULL
; pl
= pl
->next
)
7450 if (strcmp (pl
->name
, l
->name
) == 0)
7455 secs
= (asection
**) xrealloc (secs
,
7456 alc
* sizeof (asection
*));
7458 secs
[c
] = os
->bfd_section
;
7465 if (l
->flags
== NULL
)
7468 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
7473 at
= exp_get_vma (l
->at
, 0, "phdr load address");
7475 if (! bfd_record_phdr (link_info
.output_bfd
, l
->type
,
7476 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
7477 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
7478 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
7483 /* Make sure all the phdr assignments succeeded. */
7484 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
7488 lang_output_section_phdr_list
*pl
;
7490 if (os
->constraint
< 0
7491 || os
->bfd_section
== NULL
)
7494 for (pl
= os
->phdrs
;
7497 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
7498 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
7499 os
->name
, pl
->name
);
7503 /* Record a list of sections which may not be cross referenced. */
7506 lang_add_nocrossref (lang_nocrossref_type
*l
)
7508 struct lang_nocrossrefs
*n
;
7510 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
7511 n
->next
= nocrossref_list
;
7513 n
->onlyfirst
= FALSE
;
7514 nocrossref_list
= n
;
7516 /* Set notice_all so that we get informed about all symbols. */
7517 link_info
.notice_all
= TRUE
;
7520 /* Record a section that cannot be referenced from a list of sections. */
7523 lang_add_nocrossref_to (lang_nocrossref_type
*l
)
7525 lang_add_nocrossref (l
);
7526 nocrossref_list
->onlyfirst
= TRUE
;
7529 /* Overlay handling. We handle overlays with some static variables. */
7531 /* The overlay virtual address. */
7532 static etree_type
*overlay_vma
;
7533 /* And subsection alignment. */
7534 static etree_type
*overlay_subalign
;
7536 /* An expression for the maximum section size seen so far. */
7537 static etree_type
*overlay_max
;
7539 /* A list of all the sections in this overlay. */
7541 struct overlay_list
{
7542 struct overlay_list
*next
;
7543 lang_output_section_statement_type
*os
;
7546 static struct overlay_list
*overlay_list
;
7548 /* Start handling an overlay. */
7551 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
7553 /* The grammar should prevent nested overlays from occurring. */
7554 ASSERT (overlay_vma
== NULL
7555 && overlay_subalign
== NULL
7556 && overlay_max
== NULL
);
7558 overlay_vma
= vma_expr
;
7559 overlay_subalign
= subalign
;
7562 /* Start a section in an overlay. We handle this by calling
7563 lang_enter_output_section_statement with the correct VMA.
7564 lang_leave_overlay sets up the LMA and memory regions. */
7567 lang_enter_overlay_section (const char *name
)
7569 struct overlay_list
*n
;
7572 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
7573 0, overlay_subalign
, 0, 0, 0);
7575 /* If this is the first section, then base the VMA of future
7576 sections on this one. This will work correctly even if `.' is
7577 used in the addresses. */
7578 if (overlay_list
== NULL
)
7579 overlay_vma
= exp_nameop (ADDR
, name
);
7581 /* Remember the section. */
7582 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
7583 n
->os
= current_section
;
7584 n
->next
= overlay_list
;
7587 size
= exp_nameop (SIZEOF
, name
);
7589 /* Arrange to work out the maximum section end address. */
7590 if (overlay_max
== NULL
)
7593 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
7596 /* Finish a section in an overlay. There isn't any special to do
7600 lang_leave_overlay_section (fill_type
*fill
,
7601 lang_output_section_phdr_list
*phdrs
)
7608 name
= current_section
->name
;
7610 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
7611 region and that no load-time region has been specified. It doesn't
7612 really matter what we say here, since lang_leave_overlay will
7614 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
7616 /* Define the magic symbols. */
7618 clean
= (char *) xmalloc (strlen (name
) + 1);
7620 for (s1
= name
; *s1
!= '\0'; s1
++)
7621 if (ISALNUM (*s1
) || *s1
== '_')
7625 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_start_");
7626 sprintf (buf
, "__load_start_%s", clean
);
7627 lang_add_assignment (exp_provide (buf
,
7628 exp_nameop (LOADADDR
, name
),
7631 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_stop_");
7632 sprintf (buf
, "__load_stop_%s", clean
);
7633 lang_add_assignment (exp_provide (buf
,
7635 exp_nameop (LOADADDR
, name
),
7636 exp_nameop (SIZEOF
, name
)),
7642 /* Finish an overlay. If there are any overlay wide settings, this
7643 looks through all the sections in the overlay and sets them. */
7646 lang_leave_overlay (etree_type
*lma_expr
,
7649 const char *memspec
,
7650 lang_output_section_phdr_list
*phdrs
,
7651 const char *lma_memspec
)
7653 lang_memory_region_type
*region
;
7654 lang_memory_region_type
*lma_region
;
7655 struct overlay_list
*l
;
7656 lang_nocrossref_type
*nocrossref
;
7658 lang_get_regions (®ion
, &lma_region
,
7659 memspec
, lma_memspec
,
7660 lma_expr
!= NULL
, FALSE
);
7664 /* After setting the size of the last section, set '.' to end of the
7666 if (overlay_list
!= NULL
)
7668 overlay_list
->os
->update_dot
= 1;
7669 overlay_list
->os
->update_dot_tree
7670 = exp_assign (".", exp_binop ('+', overlay_vma
, overlay_max
), FALSE
);
7676 struct overlay_list
*next
;
7678 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
7681 l
->os
->region
= region
;
7682 l
->os
->lma_region
= lma_region
;
7684 /* The first section has the load address specified in the
7685 OVERLAY statement. The rest are worked out from that.
7686 The base address is not needed (and should be null) if
7687 an LMA region was specified. */
7690 l
->os
->load_base
= lma_expr
;
7691 l
->os
->sectype
= normal_section
;
7693 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
7694 l
->os
->phdrs
= phdrs
;
7698 lang_nocrossref_type
*nc
;
7700 nc
= (lang_nocrossref_type
*) xmalloc (sizeof *nc
);
7701 nc
->name
= l
->os
->name
;
7702 nc
->next
= nocrossref
;
7711 if (nocrossref
!= NULL
)
7712 lang_add_nocrossref (nocrossref
);
7715 overlay_list
= NULL
;
7719 /* Version handling. This is only useful for ELF. */
7721 /* If PREV is NULL, return first version pattern matching particular symbol.
7722 If PREV is non-NULL, return first version pattern matching particular
7723 symbol after PREV (previously returned by lang_vers_match). */
7725 static struct bfd_elf_version_expr
*
7726 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
7727 struct bfd_elf_version_expr
*prev
,
7731 const char *cxx_sym
= sym
;
7732 const char *java_sym
= sym
;
7733 struct bfd_elf_version_expr
*expr
= NULL
;
7734 enum demangling_styles curr_style
;
7736 curr_style
= CURRENT_DEMANGLING_STYLE
;
7737 cplus_demangle_set_style (no_demangling
);
7738 c_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_NO_OPTS
);
7741 cplus_demangle_set_style (curr_style
);
7743 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
7745 cxx_sym
= bfd_demangle (link_info
.output_bfd
, sym
,
7746 DMGL_PARAMS
| DMGL_ANSI
);
7750 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
7752 java_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_JAVA
);
7757 if (head
->htab
&& (prev
== NULL
|| prev
->literal
))
7759 struct bfd_elf_version_expr e
;
7761 switch (prev
? prev
->mask
: 0)
7764 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
7767 expr
= (struct bfd_elf_version_expr
*)
7768 htab_find ((htab_t
) head
->htab
, &e
);
7769 while (expr
&& strcmp (expr
->pattern
, c_sym
) == 0)
7770 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
7776 case BFD_ELF_VERSION_C_TYPE
:
7777 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
7779 e
.pattern
= cxx_sym
;
7780 expr
= (struct bfd_elf_version_expr
*)
7781 htab_find ((htab_t
) head
->htab
, &e
);
7782 while (expr
&& strcmp (expr
->pattern
, cxx_sym
) == 0)
7783 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
7789 case BFD_ELF_VERSION_CXX_TYPE
:
7790 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
7792 e
.pattern
= java_sym
;
7793 expr
= (struct bfd_elf_version_expr
*)
7794 htab_find ((htab_t
) head
->htab
, &e
);
7795 while (expr
&& strcmp (expr
->pattern
, java_sym
) == 0)
7796 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
7807 /* Finally, try the wildcards. */
7808 if (prev
== NULL
|| prev
->literal
)
7809 expr
= head
->remaining
;
7812 for (; expr
; expr
= expr
->next
)
7819 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
7822 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
7824 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
7828 if (fnmatch (expr
->pattern
, s
, 0) == 0)
7834 free ((char *) c_sym
);
7836 free ((char *) cxx_sym
);
7837 if (java_sym
!= sym
)
7838 free ((char *) java_sym
);
7842 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
7843 return a pointer to the symbol name with any backslash quotes removed. */
7846 realsymbol (const char *pattern
)
7849 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
7850 char *s
, *symbol
= (char *) xmalloc (strlen (pattern
) + 1);
7852 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
7854 /* It is a glob pattern only if there is no preceding
7858 /* Remove the preceding backslash. */
7865 if (*p
== '?' || *p
== '*' || *p
== '[')
7872 backslash
= *p
== '\\';
7888 /* This is called for each variable name or match expression. NEW_NAME is
7889 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
7890 pattern to be matched against symbol names. */
7892 struct bfd_elf_version_expr
*
7893 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
7894 const char *new_name
,
7896 bfd_boolean literal_p
)
7898 struct bfd_elf_version_expr
*ret
;
7900 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
7904 ret
->literal
= TRUE
;
7905 ret
->pattern
= literal_p
? new_name
: realsymbol (new_name
);
7906 if (ret
->pattern
== NULL
)
7908 ret
->pattern
= new_name
;
7909 ret
->literal
= FALSE
;
7912 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
7913 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
7914 else if (strcasecmp (lang
, "C++") == 0)
7915 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
7916 else if (strcasecmp (lang
, "Java") == 0)
7917 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
7920 einfo (_("%X%P: unknown language `%s' in version information\n"),
7922 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
7925 return ldemul_new_vers_pattern (ret
);
7928 /* This is called for each set of variable names and match
7931 struct bfd_elf_version_tree
*
7932 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
7933 struct bfd_elf_version_expr
*locals
)
7935 struct bfd_elf_version_tree
*ret
;
7937 ret
= (struct bfd_elf_version_tree
*) xcalloc (1, sizeof *ret
);
7938 ret
->globals
.list
= globals
;
7939 ret
->locals
.list
= locals
;
7940 ret
->match
= lang_vers_match
;
7941 ret
->name_indx
= (unsigned int) -1;
7945 /* This static variable keeps track of version indices. */
7947 static int version_index
;
7950 version_expr_head_hash (const void *p
)
7952 const struct bfd_elf_version_expr
*e
=
7953 (const struct bfd_elf_version_expr
*) p
;
7955 return htab_hash_string (e
->pattern
);
7959 version_expr_head_eq (const void *p1
, const void *p2
)
7961 const struct bfd_elf_version_expr
*e1
=
7962 (const struct bfd_elf_version_expr
*) p1
;
7963 const struct bfd_elf_version_expr
*e2
=
7964 (const struct bfd_elf_version_expr
*) p2
;
7966 return strcmp (e1
->pattern
, e2
->pattern
) == 0;
7970 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
7973 struct bfd_elf_version_expr
*e
, *next
;
7974 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
7976 for (e
= head
->list
; e
; e
= e
->next
)
7980 head
->mask
|= e
->mask
;
7985 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
7986 version_expr_head_eq
, NULL
);
7987 list_loc
= &head
->list
;
7988 remaining_loc
= &head
->remaining
;
7989 for (e
= head
->list
; e
; e
= next
)
7995 remaining_loc
= &e
->next
;
7999 void **loc
= htab_find_slot ((htab_t
) head
->htab
, e
, INSERT
);
8003 struct bfd_elf_version_expr
*e1
, *last
;
8005 e1
= (struct bfd_elf_version_expr
*) *loc
;
8009 if (e1
->mask
== e
->mask
)
8017 while (e1
&& strcmp (e1
->pattern
, e
->pattern
) == 0);
8021 /* This is a duplicate. */
8022 /* FIXME: Memory leak. Sometimes pattern is not
8023 xmalloced alone, but in larger chunk of memory. */
8024 /* free (e->pattern); */
8029 e
->next
= last
->next
;
8037 list_loc
= &e
->next
;
8041 *remaining_loc
= NULL
;
8042 *list_loc
= head
->remaining
;
8045 head
->remaining
= head
->list
;
8048 /* This is called when we know the name and dependencies of the
8052 lang_register_vers_node (const char *name
,
8053 struct bfd_elf_version_tree
*version
,
8054 struct bfd_elf_version_deps
*deps
)
8056 struct bfd_elf_version_tree
*t
, **pp
;
8057 struct bfd_elf_version_expr
*e1
;
8062 if (link_info
.version_info
!= NULL
8063 && (name
[0] == '\0' || link_info
.version_info
->name
[0] == '\0'))
8065 einfo (_("%X%P: anonymous version tag cannot be combined"
8066 " with other version tags\n"));
8071 /* Make sure this node has a unique name. */
8072 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8073 if (strcmp (t
->name
, name
) == 0)
8074 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
8076 lang_finalize_version_expr_head (&version
->globals
);
8077 lang_finalize_version_expr_head (&version
->locals
);
8079 /* Check the global and local match names, and make sure there
8080 aren't any duplicates. */
8082 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
8084 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8086 struct bfd_elf_version_expr
*e2
;
8088 if (t
->locals
.htab
&& e1
->literal
)
8090 e2
= (struct bfd_elf_version_expr
*)
8091 htab_find ((htab_t
) t
->locals
.htab
, e1
);
8092 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
8094 if (e1
->mask
== e2
->mask
)
8095 einfo (_("%X%P: duplicate expression `%s'"
8096 " in version information\n"), e1
->pattern
);
8100 else if (!e1
->literal
)
8101 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
8102 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
8103 && e1
->mask
== e2
->mask
)
8104 einfo (_("%X%P: duplicate expression `%s'"
8105 " in version information\n"), e1
->pattern
);
8109 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
8111 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8113 struct bfd_elf_version_expr
*e2
;
8115 if (t
->globals
.htab
&& e1
->literal
)
8117 e2
= (struct bfd_elf_version_expr
*)
8118 htab_find ((htab_t
) t
->globals
.htab
, e1
);
8119 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
8121 if (e1
->mask
== e2
->mask
)
8122 einfo (_("%X%P: duplicate expression `%s'"
8123 " in version information\n"),
8128 else if (!e1
->literal
)
8129 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
8130 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
8131 && e1
->mask
== e2
->mask
)
8132 einfo (_("%X%P: duplicate expression `%s'"
8133 " in version information\n"), e1
->pattern
);
8137 version
->deps
= deps
;
8138 version
->name
= name
;
8139 if (name
[0] != '\0')
8142 version
->vernum
= version_index
;
8145 version
->vernum
= 0;
8147 for (pp
= &link_info
.version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
8152 /* This is called when we see a version dependency. */
8154 struct bfd_elf_version_deps
*
8155 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
8157 struct bfd_elf_version_deps
*ret
;
8158 struct bfd_elf_version_tree
*t
;
8160 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
8163 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
8165 if (strcmp (t
->name
, name
) == 0)
8167 ret
->version_needed
= t
;
8172 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
8174 ret
->version_needed
= NULL
;
8179 lang_do_version_exports_section (void)
8181 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
8183 LANG_FOR_EACH_INPUT_STATEMENT (is
)
8185 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
8193 contents
= (char *) xmalloc (len
);
8194 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
8195 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
8198 while (p
< contents
+ len
)
8200 greg
= lang_new_vers_pattern (greg
, p
, NULL
, FALSE
);
8201 p
= strchr (p
, '\0') + 1;
8204 /* Do not free the contents, as we used them creating the regex. */
8206 /* Do not include this section in the link. */
8207 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
8210 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, FALSE
);
8211 lang_register_vers_node (command_line
.version_exports_section
,
8212 lang_new_vers_node (greg
, lreg
), NULL
);
8215 /* Evaluate LENGTH and ORIGIN parts of MEMORY spec */
8218 lang_do_memory_regions (void)
8220 lang_memory_region_type
*r
= lang_memory_region_list
;
8222 for (; r
!= NULL
; r
= r
->next
)
8226 exp_fold_tree_no_dot (r
->origin_exp
);
8227 if (expld
.result
.valid_p
)
8229 r
->origin
= expld
.result
.value
;
8230 r
->current
= r
->origin
;
8233 einfo (_("%F%P: invalid origin for memory region %s\n"), r
->name_list
.name
);
8237 exp_fold_tree_no_dot (r
->length_exp
);
8238 if (expld
.result
.valid_p
)
8239 r
->length
= expld
.result
.value
;
8241 einfo (_("%F%P: invalid length for memory region %s\n"), r
->name_list
.name
);
8247 lang_add_unique (const char *name
)
8249 struct unique_sections
*ent
;
8251 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
8252 if (strcmp (ent
->name
, name
) == 0)
8255 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
8256 ent
->name
= xstrdup (name
);
8257 ent
->next
= unique_section_list
;
8258 unique_section_list
= ent
;
8261 /* Append the list of dynamic symbols to the existing one. */
8264 lang_append_dynamic_list (struct bfd_elf_version_expr
*dynamic
)
8266 if (link_info
.dynamic_list
)
8268 struct bfd_elf_version_expr
*tail
;
8269 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
8271 tail
->next
= link_info
.dynamic_list
->head
.list
;
8272 link_info
.dynamic_list
->head
.list
= dynamic
;
8276 struct bfd_elf_dynamic_list
*d
;
8278 d
= (struct bfd_elf_dynamic_list
*) xcalloc (1, sizeof *d
);
8279 d
->head
.list
= dynamic
;
8280 d
->match
= lang_vers_match
;
8281 link_info
.dynamic_list
= d
;
8285 /* Append the list of C++ typeinfo dynamic symbols to the existing
8289 lang_append_dynamic_list_cpp_typeinfo (void)
8291 const char * symbols
[] =
8293 "typeinfo name for*",
8296 struct bfd_elf_version_expr
*dynamic
= NULL
;
8299 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
8300 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
8303 lang_append_dynamic_list (dynamic
);
8306 /* Append the list of C++ operator new and delete dynamic symbols to the
8310 lang_append_dynamic_list_cpp_new (void)
8312 const char * symbols
[] =
8317 struct bfd_elf_version_expr
*dynamic
= NULL
;
8320 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
8321 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
8324 lang_append_dynamic_list (dynamic
);
8327 /* Scan a space and/or comma separated string of features. */
8330 lang_ld_feature (char *str
)
8338 while (*p
== ',' || ISSPACE (*p
))
8343 while (*q
&& *q
!= ',' && !ISSPACE (*q
))
8347 if (strcasecmp (p
, "SANE_EXPR") == 0)
8348 config
.sane_expr
= TRUE
;
8350 einfo (_("%X%P: unknown feature `%s'\n"), p
);
8356 /* Pretty print memory amount. */
8359 lang_print_memory_size (bfd_vma sz
)
8361 if ((sz
& 0x3fffffff) == 0)
8362 printf ("%10" BFD_VMA_FMT
"u GB", sz
>> 30);
8363 else if ((sz
& 0xfffff) == 0)
8364 printf ("%10" BFD_VMA_FMT
"u MB", sz
>> 20);
8365 else if ((sz
& 0x3ff) == 0)
8366 printf ("%10" BFD_VMA_FMT
"u KB", sz
>> 10);
8368 printf (" %10" BFD_VMA_FMT
"u B", sz
);
8371 /* Implement --print-memory-usage: disply per region memory usage. */
8374 lang_print_memory_usage (void)
8376 lang_memory_region_type
*r
;
8378 printf ("Memory region Used Size Region Size %%age Used\n");
8379 for (r
= lang_memory_region_list
; r
->next
!= NULL
; r
= r
->next
)
8381 bfd_vma used_length
= r
->current
- r
->origin
;
8384 printf ("%16s: ",r
->name_list
.name
);
8385 lang_print_memory_size (used_length
);
8386 lang_print_memory_size ((bfd_vma
) r
->length
);
8388 percent
= used_length
* 100.0 / r
->length
;
8390 printf (" %6.2f%%\n", percent
);