1 /* Linker command language support.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
6 This file is part of the GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
27 #include "libiberty.h"
28 #include "safe-ctype.h"
47 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
50 /* Locals variables. */
51 static struct obstack stat_obstack
;
52 static struct obstack map_obstack
;
54 #define obstack_chunk_alloc xmalloc
55 #define obstack_chunk_free free
56 static const char *startup_file
;
57 static bfd_boolean placed_commons
= FALSE
;
58 static bfd_boolean stripped_excluded_sections
= FALSE
;
59 static lang_output_section_statement_type
*default_common_section
;
60 static bfd_boolean map_option_f
;
61 static bfd_vma print_dot
;
62 static lang_input_statement_type
*first_file
;
63 static const char *current_target
;
64 static const char *output_target
;
65 static lang_statement_list_type statement_list
;
66 static struct bfd_hash_table lang_definedness_table
;
68 /* Forward declarations. */
69 static void exp_init_os (etree_type
*);
70 static void init_map_userdata (bfd
*, asection
*, void *);
71 static lang_input_statement_type
*lookup_name (const char *);
72 static struct bfd_hash_entry
*lang_definedness_newfunc
73 (struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *);
74 static void insert_undefined (const char *);
75 static bfd_boolean
sort_def_symbol (struct bfd_link_hash_entry
*, void *);
76 static void print_statement (lang_statement_union_type
*,
77 lang_output_section_statement_type
*);
78 static void print_statement_list (lang_statement_union_type
*,
79 lang_output_section_statement_type
*);
80 static void print_statements (void);
81 static void print_input_section (asection
*);
82 static bfd_boolean
lang_one_common (struct bfd_link_hash_entry
*, void *);
83 static void lang_record_phdrs (void);
84 static void lang_do_version_exports_section (void);
85 static void lang_finalize_version_expr_head
86 (struct bfd_elf_version_expr_head
*);
88 /* Exported variables. */
89 lang_output_section_statement_type
*abs_output_section
;
90 lang_statement_list_type lang_output_section_statement
;
91 lang_statement_list_type
*stat_ptr
= &statement_list
;
92 lang_statement_list_type file_chain
= { NULL
, NULL
};
93 lang_statement_list_type input_file_chain
;
94 struct bfd_sym_chain entry_symbol
= { NULL
, NULL
};
95 static const char *entry_symbol_default
= "start";
96 const char *entry_section
= ".text";
97 bfd_boolean entry_from_cmdline
;
98 bfd_boolean lang_has_input_file
= FALSE
;
99 bfd_boolean had_output_filename
= FALSE
;
100 bfd_boolean lang_float_flag
= FALSE
;
101 bfd_boolean delete_output_file_on_failure
= FALSE
;
102 struct lang_phdr
*lang_phdr_list
;
103 struct lang_nocrossrefs
*nocrossref_list
;
104 static struct unique_sections
*unique_section_list
;
105 static bfd_boolean ldlang_sysrooted_script
= FALSE
;
107 /* Functions that traverse the linker script and might evaluate
108 DEFINED() need to increment this. */
109 int lang_statement_iteration
= 0;
111 etree_type
*base
; /* Relocation base - or null */
113 /* Return TRUE if the PATTERN argument is a wildcard pattern.
114 Although backslashes are treated specially if a pattern contains
115 wildcards, we do not consider the mere presence of a backslash to
116 be enough to cause the pattern to be treated as a wildcard.
117 That lets us handle DOS filenames more naturally. */
118 #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
120 #define new_stat(x, y) \
121 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
123 #define outside_section_address(q) \
124 ((q)->output_offset + (q)->output_section->vma)
126 #define outside_symbol_address(q) \
127 ((q)->value + outside_section_address (q->section))
129 #define SECTION_NAME_MAP_LENGTH (16)
132 stat_alloc (size_t size
)
134 return obstack_alloc (&stat_obstack
, size
);
138 name_match (const char *pattern
, const char *name
)
140 if (wildcardp (pattern
))
141 return fnmatch (pattern
, name
, 0);
142 return strcmp (pattern
, name
);
145 /* If PATTERN is of the form archive:file, return a pointer to the
146 separator. If not, return NULL. */
149 archive_path (const char *pattern
)
153 if (link_info
.path_separator
== 0)
156 p
= strchr (pattern
, link_info
.path_separator
);
157 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
158 if (p
== NULL
|| link_info
.path_separator
!= ':')
161 /* Assume a match on the second char is part of drive specifier,
162 as in "c:\silly.dos". */
163 if (p
== pattern
+ 1 && ISALPHA (*pattern
))
164 p
= strchr (p
+ 1, link_info
.path_separator
);
169 /* Given that FILE_SPEC results in a non-NULL SEP result from archive_path,
170 return whether F matches FILE_SPEC. */
173 input_statement_is_archive_path (const char *file_spec
, char *sep
,
174 lang_input_statement_type
*f
)
176 bfd_boolean match
= FALSE
;
179 || name_match (sep
+ 1, f
->filename
) == 0)
180 && ((sep
!= file_spec
)
181 == (f
->the_bfd
!= NULL
&& f
->the_bfd
->my_archive
!= NULL
)))
185 if (sep
!= file_spec
)
187 const char *aname
= f
->the_bfd
->my_archive
->filename
;
189 match
= name_match (file_spec
, aname
) == 0;
190 *sep
= link_info
.path_separator
;
197 unique_section_p (const asection
*sec
)
199 struct unique_sections
*unam
;
202 if (link_info
.relocatable
203 && sec
->owner
!= NULL
204 && bfd_is_group_section (sec
->owner
, sec
))
208 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
209 if (name_match (unam
->name
, secnam
) == 0)
215 /* Generic traversal routines for finding matching sections. */
217 /* Try processing a section against a wildcard. This just calls
218 the callback unless the filename exclusion list is present
219 and excludes the file. It's hardly ever present so this
220 function is very fast. */
223 walk_wild_consider_section (lang_wild_statement_type
*ptr
,
224 lang_input_statement_type
*file
,
226 struct wildcard_list
*sec
,
230 struct name_list
*list_tmp
;
232 /* Don't process sections from files which were excluded. */
233 for (list_tmp
= sec
->spec
.exclude_name_list
;
235 list_tmp
= list_tmp
->next
)
237 char *p
= archive_path (list_tmp
->name
);
241 if (input_statement_is_archive_path (list_tmp
->name
, p
, file
))
245 else if (name_match (list_tmp
->name
, file
->filename
) == 0)
248 /* FIXME: Perhaps remove the following at some stage? Matching
249 unadorned archives like this was never documented and has
250 been superceded by the archive:path syntax. */
251 else if (file
->the_bfd
!= NULL
252 && file
->the_bfd
->my_archive
!= NULL
253 && name_match (list_tmp
->name
,
254 file
->the_bfd
->my_archive
->filename
) == 0)
258 (*callback
) (ptr
, sec
, s
, file
, data
);
261 /* Lowest common denominator routine that can handle everything correctly,
265 walk_wild_section_general (lang_wild_statement_type
*ptr
,
266 lang_input_statement_type
*file
,
271 struct wildcard_list
*sec
;
273 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
275 sec
= ptr
->section_list
;
277 (*callback
) (ptr
, sec
, s
, file
, data
);
281 bfd_boolean skip
= FALSE
;
283 if (sec
->spec
.name
!= NULL
)
285 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
287 skip
= name_match (sec
->spec
.name
, sname
) != 0;
291 walk_wild_consider_section (ptr
, file
, s
, sec
, callback
, data
);
298 /* Routines to find a single section given its name. If there's more
299 than one section with that name, we report that. */
303 asection
*found_section
;
304 bfd_boolean multiple_sections_found
;
305 } section_iterator_callback_data
;
308 section_iterator_callback (bfd
*bfd ATTRIBUTE_UNUSED
, asection
*s
, void *data
)
310 section_iterator_callback_data
*d
= data
;
312 if (d
->found_section
!= NULL
)
314 d
->multiple_sections_found
= TRUE
;
318 d
->found_section
= s
;
323 find_section (lang_input_statement_type
*file
,
324 struct wildcard_list
*sec
,
325 bfd_boolean
*multiple_sections_found
)
327 section_iterator_callback_data cb_data
= { NULL
, FALSE
};
329 bfd_get_section_by_name_if (file
->the_bfd
, sec
->spec
.name
,
330 section_iterator_callback
, &cb_data
);
331 *multiple_sections_found
= cb_data
.multiple_sections_found
;
332 return cb_data
.found_section
;
335 /* Code for handling simple wildcards without going through fnmatch,
336 which can be expensive because of charset translations etc. */
338 /* A simple wild is a literal string followed by a single '*',
339 where the literal part is at least 4 characters long. */
342 is_simple_wild (const char *name
)
344 size_t len
= strcspn (name
, "*?[");
345 return len
>= 4 && name
[len
] == '*' && name
[len
+ 1] == '\0';
349 match_simple_wild (const char *pattern
, const char *name
)
351 /* The first four characters of the pattern are guaranteed valid
352 non-wildcard characters. So we can go faster. */
353 if (pattern
[0] != name
[0] || pattern
[1] != name
[1]
354 || pattern
[2] != name
[2] || pattern
[3] != name
[3])
359 while (*pattern
!= '*')
360 if (*name
++ != *pattern
++)
366 /* Compare sections ASEC and BSEC according to SORT. */
369 compare_section (sort_type sort
, asection
*asec
, asection
*bsec
)
378 case by_alignment_name
:
379 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
380 - bfd_section_alignment (asec
->owner
, asec
));
386 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
387 bfd_get_section_name (bsec
->owner
, bsec
));
390 case by_name_alignment
:
391 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
392 bfd_get_section_name (bsec
->owner
, bsec
));
398 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
399 - bfd_section_alignment (asec
->owner
, asec
));
406 /* Build a Binary Search Tree to sort sections, unlike insertion sort
407 used in wild_sort(). BST is considerably faster if the number of
408 of sections are large. */
410 static lang_section_bst_type
**
411 wild_sort_fast (lang_wild_statement_type
*wild
,
412 struct wildcard_list
*sec
,
413 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
416 lang_section_bst_type
**tree
;
419 if (!wild
->filenames_sorted
420 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
422 /* Append at the right end of tree. */
424 tree
= &((*tree
)->right
);
430 /* Find the correct node to append this section. */
431 if (compare_section (sec
->spec
.sorted
, section
, (*tree
)->section
) < 0)
432 tree
= &((*tree
)->left
);
434 tree
= &((*tree
)->right
);
440 /* Use wild_sort_fast to build a BST to sort sections. */
443 output_section_callback_fast (lang_wild_statement_type
*ptr
,
444 struct wildcard_list
*sec
,
446 lang_input_statement_type
*file
,
447 void *output ATTRIBUTE_UNUSED
)
449 lang_section_bst_type
*node
;
450 lang_section_bst_type
**tree
;
452 if (unique_section_p (section
))
455 node
= xmalloc (sizeof (lang_section_bst_type
));
458 node
->section
= section
;
460 tree
= wild_sort_fast (ptr
, sec
, file
, section
);
465 /* Convert a sorted sections' BST back to list form. */
468 output_section_callback_tree_to_list (lang_wild_statement_type
*ptr
,
469 lang_section_bst_type
*tree
,
473 output_section_callback_tree_to_list (ptr
, tree
->left
, output
);
475 lang_add_section (&ptr
->children
, tree
->section
,
476 (lang_output_section_statement_type
*) output
);
479 output_section_callback_tree_to_list (ptr
, tree
->right
, output
);
484 /* Specialized, optimized routines for handling different kinds of
488 walk_wild_section_specs1_wild0 (lang_wild_statement_type
*ptr
,
489 lang_input_statement_type
*file
,
493 /* We can just do a hash lookup for the section with the right name.
494 But if that lookup discovers more than one section with the name
495 (should be rare), we fall back to the general algorithm because
496 we would otherwise have to sort the sections to make sure they
497 get processed in the bfd's order. */
498 bfd_boolean multiple_sections_found
;
499 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
500 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
502 if (multiple_sections_found
)
503 walk_wild_section_general (ptr
, file
, callback
, data
);
505 walk_wild_consider_section (ptr
, file
, s0
, sec0
, callback
, data
);
509 walk_wild_section_specs1_wild1 (lang_wild_statement_type
*ptr
,
510 lang_input_statement_type
*file
,
515 struct wildcard_list
*wildsec0
= ptr
->handler_data
[0];
517 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
519 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
520 bfd_boolean skip
= !match_simple_wild (wildsec0
->spec
.name
, sname
);
523 walk_wild_consider_section (ptr
, file
, s
, wildsec0
, callback
, data
);
528 walk_wild_section_specs2_wild1 (lang_wild_statement_type
*ptr
,
529 lang_input_statement_type
*file
,
534 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
535 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
536 bfd_boolean multiple_sections_found
;
537 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
539 if (multiple_sections_found
)
541 walk_wild_section_general (ptr
, file
, callback
, data
);
545 /* Note that if the section was not found, s0 is NULL and
546 we'll simply never succeed the s == s0 test below. */
547 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
549 /* Recall that in this code path, a section cannot satisfy more
550 than one spec, so if s == s0 then it cannot match
553 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
556 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
557 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
560 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
,
567 walk_wild_section_specs3_wild2 (lang_wild_statement_type
*ptr
,
568 lang_input_statement_type
*file
,
573 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
574 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
575 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
576 bfd_boolean multiple_sections_found
;
577 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
579 if (multiple_sections_found
)
581 walk_wild_section_general (ptr
, file
, callback
, data
);
585 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
588 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
591 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
592 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
595 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
, data
);
598 skip
= !match_simple_wild (wildsec2
->spec
.name
, sname
);
600 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
608 walk_wild_section_specs4_wild2 (lang_wild_statement_type
*ptr
,
609 lang_input_statement_type
*file
,
614 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
615 struct wildcard_list
*sec1
= ptr
->handler_data
[1];
616 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
617 struct wildcard_list
*wildsec3
= ptr
->handler_data
[3];
618 bfd_boolean multiple_sections_found
;
619 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
), *s1
;
621 if (multiple_sections_found
)
623 walk_wild_section_general (ptr
, file
, callback
, data
);
627 s1
= find_section (file
, sec1
, &multiple_sections_found
);
628 if (multiple_sections_found
)
630 walk_wild_section_general (ptr
, file
, callback
, data
);
634 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
637 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
640 walk_wild_consider_section (ptr
, file
, s
, sec1
, callback
, data
);
643 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
644 bfd_boolean skip
= !match_simple_wild (wildsec2
->spec
.name
,
648 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
652 skip
= !match_simple_wild (wildsec3
->spec
.name
, sname
);
654 walk_wild_consider_section (ptr
, file
, s
, wildsec3
,
662 walk_wild_section (lang_wild_statement_type
*ptr
,
663 lang_input_statement_type
*file
,
667 if (file
->just_syms_flag
)
670 (*ptr
->walk_wild_section_handler
) (ptr
, file
, callback
, data
);
673 /* Returns TRUE when name1 is a wildcard spec that might match
674 something name2 can match. We're conservative: we return FALSE
675 only if the prefixes of name1 and name2 are different up to the
676 first wildcard character. */
679 wild_spec_can_overlap (const char *name1
, const char *name2
)
681 size_t prefix1_len
= strcspn (name1
, "?*[");
682 size_t prefix2_len
= strcspn (name2
, "?*[");
683 size_t min_prefix_len
;
685 /* Note that if there is no wildcard character, then we treat the
686 terminating 0 as part of the prefix. Thus ".text" won't match
687 ".text." or ".text.*", for example. */
688 if (name1
[prefix1_len
] == '\0')
690 if (name2
[prefix2_len
] == '\0')
693 min_prefix_len
= prefix1_len
< prefix2_len
? prefix1_len
: prefix2_len
;
695 return memcmp (name1
, name2
, min_prefix_len
) == 0;
698 /* Select specialized code to handle various kinds of wildcard
702 analyze_walk_wild_section_handler (lang_wild_statement_type
*ptr
)
705 int wild_name_count
= 0;
706 struct wildcard_list
*sec
;
710 ptr
->walk_wild_section_handler
= walk_wild_section_general
;
711 ptr
->handler_data
[0] = NULL
;
712 ptr
->handler_data
[1] = NULL
;
713 ptr
->handler_data
[2] = NULL
;
714 ptr
->handler_data
[3] = NULL
;
717 /* Count how many wildcard_specs there are, and how many of those
718 actually use wildcards in the name. Also, bail out if any of the
719 wildcard names are NULL. (Can this actually happen?
720 walk_wild_section used to test for it.) And bail out if any
721 of the wildcards are more complex than a simple string
722 ending in a single '*'. */
723 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
726 if (sec
->spec
.name
== NULL
)
728 if (wildcardp (sec
->spec
.name
))
731 if (!is_simple_wild (sec
->spec
.name
))
736 /* The zero-spec case would be easy to optimize but it doesn't
737 happen in practice. Likewise, more than 4 specs doesn't
738 happen in practice. */
739 if (sec_count
== 0 || sec_count
> 4)
742 /* Check that no two specs can match the same section. */
743 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
745 struct wildcard_list
*sec2
;
746 for (sec2
= sec
->next
; sec2
!= NULL
; sec2
= sec2
->next
)
748 if (wild_spec_can_overlap (sec
->spec
.name
, sec2
->spec
.name
))
753 signature
= (sec_count
<< 8) + wild_name_count
;
757 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild0
;
760 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild1
;
763 ptr
->walk_wild_section_handler
= walk_wild_section_specs2_wild1
;
766 ptr
->walk_wild_section_handler
= walk_wild_section_specs3_wild2
;
769 ptr
->walk_wild_section_handler
= walk_wild_section_specs4_wild2
;
775 /* Now fill the data array with pointers to the specs, first the
776 specs with non-wildcard names, then the specs with wildcard
777 names. It's OK to process the specs in different order from the
778 given order, because we've already determined that no section
779 will match more than one spec. */
781 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
782 if (!wildcardp (sec
->spec
.name
))
783 ptr
->handler_data
[data_counter
++] = sec
;
784 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
785 if (wildcardp (sec
->spec
.name
))
786 ptr
->handler_data
[data_counter
++] = sec
;
789 /* Handle a wild statement for a single file F. */
792 walk_wild_file (lang_wild_statement_type
*s
,
793 lang_input_statement_type
*f
,
797 if (f
->the_bfd
== NULL
798 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
799 walk_wild_section (s
, f
, callback
, data
);
804 /* This is an archive file. We must map each member of the
805 archive separately. */
806 member
= bfd_openr_next_archived_file (f
->the_bfd
, NULL
);
807 while (member
!= NULL
)
809 /* When lookup_name is called, it will call the add_symbols
810 entry point for the archive. For each element of the
811 archive which is included, BFD will call ldlang_add_file,
812 which will set the usrdata field of the member to the
813 lang_input_statement. */
814 if (member
->usrdata
!= NULL
)
816 walk_wild_section (s
, member
->usrdata
, callback
, data
);
819 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
825 walk_wild (lang_wild_statement_type
*s
, callback_t callback
, void *data
)
827 const char *file_spec
= s
->filename
;
830 if (file_spec
== NULL
)
832 /* Perform the iteration over all files in the list. */
833 LANG_FOR_EACH_INPUT_STATEMENT (f
)
835 walk_wild_file (s
, f
, callback
, data
);
838 else if ((p
= archive_path (file_spec
)) != NULL
)
840 LANG_FOR_EACH_INPUT_STATEMENT (f
)
842 if (input_statement_is_archive_path (file_spec
, p
, f
))
843 walk_wild_file (s
, f
, callback
, data
);
846 else if (wildcardp (file_spec
))
848 LANG_FOR_EACH_INPUT_STATEMENT (f
)
850 if (fnmatch (file_spec
, f
->filename
, 0) == 0)
851 walk_wild_file (s
, f
, callback
, data
);
856 lang_input_statement_type
*f
;
858 /* Perform the iteration over a single file. */
859 f
= lookup_name (file_spec
);
861 walk_wild_file (s
, f
, callback
, data
);
865 /* lang_for_each_statement walks the parse tree and calls the provided
866 function for each node. */
869 lang_for_each_statement_worker (void (*func
) (lang_statement_union_type
*),
870 lang_statement_union_type
*s
)
872 for (; s
!= NULL
; s
= s
->header
.next
)
876 switch (s
->header
.type
)
878 case lang_constructors_statement_enum
:
879 lang_for_each_statement_worker (func
, constructor_list
.head
);
881 case lang_output_section_statement_enum
:
882 lang_for_each_statement_worker
883 (func
, s
->output_section_statement
.children
.head
);
885 case lang_wild_statement_enum
:
886 lang_for_each_statement_worker (func
,
887 s
->wild_statement
.children
.head
);
889 case lang_group_statement_enum
:
890 lang_for_each_statement_worker (func
,
891 s
->group_statement
.children
.head
);
893 case lang_data_statement_enum
:
894 case lang_reloc_statement_enum
:
895 case lang_object_symbols_statement_enum
:
896 case lang_output_statement_enum
:
897 case lang_target_statement_enum
:
898 case lang_input_section_enum
:
899 case lang_input_statement_enum
:
900 case lang_assignment_statement_enum
:
901 case lang_padding_statement_enum
:
902 case lang_address_statement_enum
:
903 case lang_fill_statement_enum
:
904 case lang_insert_statement_enum
:
914 lang_for_each_statement (void (*func
) (lang_statement_union_type
*))
916 lang_for_each_statement_worker (func
, statement_list
.head
);
919 /*----------------------------------------------------------------------*/
922 lang_list_init (lang_statement_list_type
*list
)
925 list
->tail
= &list
->head
;
928 /* Build a new statement node for the parse tree. */
930 static lang_statement_union_type
*
931 new_statement (enum statement_enum type
,
933 lang_statement_list_type
*list
)
935 lang_statement_union_type
*new;
937 new = stat_alloc (size
);
938 new->header
.type
= type
;
939 new->header
.next
= NULL
;
940 lang_statement_append (list
, new, &new->header
.next
);
944 /* Build a new input file node for the language. There are several
945 ways in which we treat an input file, eg, we only look at symbols,
946 or prefix it with a -l etc.
948 We can be supplied with requests for input files more than once;
949 they may, for example be split over several lines like foo.o(.text)
950 foo.o(.data) etc, so when asked for a file we check that we haven't
951 got it already so we don't duplicate the bfd. */
953 static lang_input_statement_type
*
954 new_afile (const char *name
,
955 lang_input_file_enum_type file_type
,
957 bfd_boolean add_to_list
)
959 lang_input_statement_type
*p
;
962 p
= new_stat (lang_input_statement
, stat_ptr
);
965 p
= stat_alloc (sizeof (lang_input_statement_type
));
966 p
->header
.type
= lang_input_statement_enum
;
967 p
->header
.next
= NULL
;
970 lang_has_input_file
= TRUE
;
972 p
->sysrooted
= FALSE
;
974 if (file_type
== lang_input_file_is_l_enum
975 && name
[0] == ':' && name
[1] != '\0')
977 file_type
= lang_input_file_is_search_file_enum
;
983 case lang_input_file_is_symbols_only_enum
:
985 p
->is_archive
= FALSE
;
987 p
->local_sym_name
= name
;
988 p
->just_syms_flag
= TRUE
;
989 p
->search_dirs_flag
= FALSE
;
991 case lang_input_file_is_fake_enum
:
993 p
->is_archive
= FALSE
;
995 p
->local_sym_name
= name
;
996 p
->just_syms_flag
= FALSE
;
997 p
->search_dirs_flag
= FALSE
;
999 case lang_input_file_is_l_enum
:
1000 p
->is_archive
= TRUE
;
1003 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
1004 p
->just_syms_flag
= FALSE
;
1005 p
->search_dirs_flag
= TRUE
;
1007 case lang_input_file_is_marker_enum
:
1009 p
->is_archive
= FALSE
;
1011 p
->local_sym_name
= name
;
1012 p
->just_syms_flag
= FALSE
;
1013 p
->search_dirs_flag
= TRUE
;
1015 case lang_input_file_is_search_file_enum
:
1016 p
->sysrooted
= ldlang_sysrooted_script
;
1018 p
->is_archive
= FALSE
;
1020 p
->local_sym_name
= name
;
1021 p
->just_syms_flag
= FALSE
;
1022 p
->search_dirs_flag
= TRUE
;
1024 case lang_input_file_is_file_enum
:
1026 p
->is_archive
= FALSE
;
1028 p
->local_sym_name
= name
;
1029 p
->just_syms_flag
= FALSE
;
1030 p
->search_dirs_flag
= FALSE
;
1036 p
->next_real_file
= NULL
;
1038 p
->dynamic
= config
.dynamic_link
;
1039 p
->add_needed
= add_needed
;
1040 p
->as_needed
= as_needed
;
1041 p
->whole_archive
= whole_archive
;
1043 lang_statement_append (&input_file_chain
,
1044 (lang_statement_union_type
*) p
,
1045 &p
->next_real_file
);
1049 lang_input_statement_type
*
1050 lang_add_input_file (const char *name
,
1051 lang_input_file_enum_type file_type
,
1054 return new_afile (name
, file_type
, target
, TRUE
);
1057 struct out_section_hash_entry
1059 struct bfd_hash_entry root
;
1060 lang_statement_union_type s
;
1063 /* The hash table. */
1065 static struct bfd_hash_table output_section_statement_table
;
1067 /* Support routines for the hash table used by lang_output_section_find,
1068 initialize the table, fill in an entry and remove the table. */
1070 static struct bfd_hash_entry
*
1071 output_section_statement_newfunc (struct bfd_hash_entry
*entry
,
1072 struct bfd_hash_table
*table
,
1075 lang_output_section_statement_type
**nextp
;
1076 struct out_section_hash_entry
*ret
;
1080 entry
= bfd_hash_allocate (table
, sizeof (*ret
));
1085 entry
= bfd_hash_newfunc (entry
, table
, string
);
1089 ret
= (struct out_section_hash_entry
*) entry
;
1090 memset (&ret
->s
, 0, sizeof (ret
->s
));
1091 ret
->s
.header
.type
= lang_output_section_statement_enum
;
1092 ret
->s
.output_section_statement
.subsection_alignment
= -1;
1093 ret
->s
.output_section_statement
.section_alignment
= -1;
1094 ret
->s
.output_section_statement
.block_value
= 1;
1095 lang_list_init (&ret
->s
.output_section_statement
.children
);
1096 lang_statement_append (stat_ptr
, &ret
->s
, &ret
->s
.header
.next
);
1098 /* For every output section statement added to the list, except the
1099 first one, lang_output_section_statement.tail points to the "next"
1100 field of the last element of the list. */
1101 if (lang_output_section_statement
.head
!= NULL
)
1102 ret
->s
.output_section_statement
.prev
1103 = ((lang_output_section_statement_type
*)
1104 ((char *) lang_output_section_statement
.tail
1105 - offsetof (lang_output_section_statement_type
, next
)));
1107 /* GCC's strict aliasing rules prevent us from just casting the
1108 address, so we store the pointer in a variable and cast that
1110 nextp
= &ret
->s
.output_section_statement
.next
;
1111 lang_statement_append (&lang_output_section_statement
,
1113 (lang_statement_union_type
**) nextp
);
1118 output_section_statement_table_init (void)
1120 if (!bfd_hash_table_init_n (&output_section_statement_table
,
1121 output_section_statement_newfunc
,
1122 sizeof (struct out_section_hash_entry
),
1124 einfo (_("%P%F: can not create hash table: %E\n"));
1128 output_section_statement_table_free (void)
1130 bfd_hash_table_free (&output_section_statement_table
);
1133 /* Build enough state so that the parser can build its tree. */
1138 obstack_begin (&stat_obstack
, 1000);
1140 stat_ptr
= &statement_list
;
1142 output_section_statement_table_init ();
1144 lang_list_init (stat_ptr
);
1146 lang_list_init (&input_file_chain
);
1147 lang_list_init (&lang_output_section_statement
);
1148 lang_list_init (&file_chain
);
1149 first_file
= lang_add_input_file (NULL
, lang_input_file_is_marker_enum
,
1151 abs_output_section
=
1152 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
, 0, TRUE
);
1154 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
1156 /* The value "3" is ad-hoc, somewhat related to the expected number of
1157 DEFINED expressions in a linker script. For most default linker
1158 scripts, there are none. Why a hash table then? Well, it's somewhat
1159 simpler to re-use working machinery than using a linked list in terms
1160 of code-complexity here in ld, besides the initialization which just
1161 looks like other code here. */
1162 if (!bfd_hash_table_init_n (&lang_definedness_table
,
1163 lang_definedness_newfunc
,
1164 sizeof (struct lang_definedness_hash_entry
),
1166 einfo (_("%P%F: can not create hash table: %E\n"));
1172 output_section_statement_table_free ();
1175 /*----------------------------------------------------------------------
1176 A region is an area of memory declared with the
1177 MEMORY { name:org=exp, len=exp ... }
1180 We maintain a list of all the regions here.
1182 If no regions are specified in the script, then the default is used
1183 which is created when looked up to be the entire data space.
1185 If create is true we are creating a region inside a MEMORY block.
1186 In this case it is probably an error to create a region that has
1187 already been created. If we are not inside a MEMORY block it is
1188 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1189 and so we issue a warning. */
1191 static lang_memory_region_type
*lang_memory_region_list
;
1192 static lang_memory_region_type
**lang_memory_region_list_tail
1193 = &lang_memory_region_list
;
1195 lang_memory_region_type
*
1196 lang_memory_region_lookup (const char *const name
, bfd_boolean create
)
1198 lang_memory_region_type
*p
;
1199 lang_memory_region_type
*new;
1201 /* NAME is NULL for LMA memspecs if no region was specified. */
1205 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
1206 if (strcmp (p
->name
, name
) == 0)
1209 einfo (_("%P:%S: warning: redeclaration of memory region '%s'\n"),
1214 if (!create
&& strcmp (name
, DEFAULT_MEMORY_REGION
))
1215 einfo (_("%P:%S: warning: memory region %s not declared\n"), name
);
1217 new = stat_alloc (sizeof (lang_memory_region_type
));
1219 new->name
= xstrdup (name
);
1222 new->length
= ~(bfd_size_type
) 0;
1224 new->last_os
= NULL
;
1227 new->had_full_message
= FALSE
;
1229 *lang_memory_region_list_tail
= new;
1230 lang_memory_region_list_tail
= &new->next
;
1235 static lang_memory_region_type
*
1236 lang_memory_default (asection
*section
)
1238 lang_memory_region_type
*p
;
1240 flagword sec_flags
= section
->flags
;
1242 /* Override SEC_DATA to mean a writable section. */
1243 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
1244 sec_flags
|= SEC_DATA
;
1246 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
1248 if ((p
->flags
& sec_flags
) != 0
1249 && (p
->not_flags
& sec_flags
) == 0)
1254 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
1257 lang_output_section_statement_type
*
1258 lang_output_section_statement_lookup (const char *const name
,
1262 struct out_section_hash_entry
*entry
;
1264 entry
= ((struct out_section_hash_entry
*)
1265 bfd_hash_lookup (&output_section_statement_table
, name
,
1270 einfo (_("%P%F: failed creating section `%s': %E\n"), name
);
1274 if (entry
->s
.output_section_statement
.name
!= NULL
)
1276 /* We have a section of this name, but it might not have the correct
1278 struct out_section_hash_entry
*last_ent
;
1279 unsigned long hash
= entry
->root
.hash
;
1283 if (entry
->s
.output_section_statement
.constraint
>= 0
1285 || (constraint
== entry
->s
.output_section_statement
.constraint
1286 && constraint
!= SPECIAL
)))
1287 return &entry
->s
.output_section_statement
;
1289 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1291 while (entry
!= NULL
1292 && entry
->root
.hash
== hash
1293 && strcmp (name
, entry
->s
.output_section_statement
.name
) == 0);
1299 = ((struct out_section_hash_entry
*)
1300 output_section_statement_newfunc (NULL
,
1301 &output_section_statement_table
,
1305 einfo (_("%P%F: failed creating section `%s': %E\n"), name
);
1308 entry
->root
= last_ent
->root
;
1309 last_ent
->root
.next
= &entry
->root
;
1312 entry
->s
.output_section_statement
.name
= name
;
1313 entry
->s
.output_section_statement
.constraint
= constraint
;
1314 return &entry
->s
.output_section_statement
;
1317 /* A variant of lang_output_section_find used by place_orphan.
1318 Returns the output statement that should precede a new output
1319 statement for SEC. If an exact match is found on certain flags,
1322 lang_output_section_statement_type
*
1323 lang_output_section_find_by_flags (const asection
*sec
,
1324 lang_output_section_statement_type
**exact
,
1325 lang_match_sec_type_func match_type
)
1327 lang_output_section_statement_type
*first
, *look
, *found
;
1330 /* We know the first statement on this list is *ABS*. May as well
1332 first
= &lang_output_section_statement
.head
->output_section_statement
;
1333 first
= first
->next
;
1335 /* First try for an exact match. */
1337 for (look
= first
; look
; look
= look
->next
)
1339 flags
= look
->flags
;
1340 if (look
->bfd_section
!= NULL
)
1342 flags
= look
->bfd_section
->flags
;
1343 if (match_type
&& !match_type (link_info
.output_bfd
,
1348 flags
^= sec
->flags
;
1349 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1350 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1360 if (sec
->flags
& SEC_CODE
)
1362 /* Try for a rw code section. */
1363 for (look
= first
; look
; look
= look
->next
)
1365 flags
= look
->flags
;
1366 if (look
->bfd_section
!= NULL
)
1368 flags
= look
->bfd_section
->flags
;
1369 if (match_type
&& !match_type (link_info
.output_bfd
,
1374 flags
^= sec
->flags
;
1375 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1376 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1380 else if (sec
->flags
& (SEC_READONLY
| SEC_THREAD_LOCAL
))
1382 /* .rodata can go after .text, .sdata2 after .rodata. */
1383 for (look
= first
; look
; look
= look
->next
)
1385 flags
= look
->flags
;
1386 if (look
->bfd_section
!= NULL
)
1388 flags
= look
->bfd_section
->flags
;
1389 if (match_type
&& !match_type (link_info
.output_bfd
,
1394 flags
^= sec
->flags
;
1395 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1397 && !(look
->flags
& (SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1401 else if (sec
->flags
& SEC_SMALL_DATA
)
1403 /* .sdata goes after .data, .sbss after .sdata. */
1404 for (look
= first
; look
; look
= look
->next
)
1406 flags
= look
->flags
;
1407 if (look
->bfd_section
!= NULL
)
1409 flags
= look
->bfd_section
->flags
;
1410 if (match_type
&& !match_type (link_info
.output_bfd
,
1415 flags
^= sec
->flags
;
1416 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1417 | SEC_THREAD_LOCAL
))
1418 || ((look
->flags
& SEC_SMALL_DATA
)
1419 && !(sec
->flags
& SEC_HAS_CONTENTS
)))
1423 else if (sec
->flags
& SEC_HAS_CONTENTS
)
1425 /* .data goes after .rodata. */
1426 for (look
= first
; look
; look
= look
->next
)
1428 flags
= look
->flags
;
1429 if (look
->bfd_section
!= NULL
)
1431 flags
= look
->bfd_section
->flags
;
1432 if (match_type
&& !match_type (link_info
.output_bfd
,
1437 flags
^= sec
->flags
;
1438 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1439 | SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1445 /* .bss goes last. */
1446 for (look
= first
; look
; look
= look
->next
)
1448 flags
= look
->flags
;
1449 if (look
->bfd_section
!= NULL
)
1451 flags
= look
->bfd_section
->flags
;
1452 if (match_type
&& !match_type (link_info
.output_bfd
,
1457 flags
^= sec
->flags
;
1458 if (!(flags
& SEC_ALLOC
))
1463 if (found
|| !match_type
)
1466 return lang_output_section_find_by_flags (sec
, NULL
, NULL
);
1469 /* Find the last output section before given output statement.
1470 Used by place_orphan. */
1473 output_prev_sec_find (lang_output_section_statement_type
*os
)
1475 lang_output_section_statement_type
*lookup
;
1477 for (lookup
= os
->prev
; lookup
!= NULL
; lookup
= lookup
->prev
)
1479 if (lookup
->constraint
< 0)
1482 if (lookup
->bfd_section
!= NULL
&& lookup
->bfd_section
->owner
!= NULL
)
1483 return lookup
->bfd_section
;
1489 /* Look for a suitable place for a new output section statement. The
1490 idea is to skip over anything that might be inside a SECTIONS {}
1491 statement in a script, before we find another output section
1492 statement. Assignments to "dot" before an output section statement
1493 are assumed to belong to it. An exception to this rule is made for
1494 the first assignment to dot, otherwise we might put an orphan
1495 before . = . + SIZEOF_HEADERS or similar assignments that set the
1498 static lang_statement_union_type
**
1499 insert_os_after (lang_output_section_statement_type
*after
)
1501 lang_statement_union_type
**where
;
1502 lang_statement_union_type
**assign
= NULL
;
1503 bfd_boolean ignore_first
;
1506 = after
== &lang_output_section_statement
.head
->output_section_statement
;
1508 for (where
= &after
->header
.next
;
1510 where
= &(*where
)->header
.next
)
1512 switch ((*where
)->header
.type
)
1514 case lang_assignment_statement_enum
:
1517 lang_assignment_statement_type
*ass
;
1519 ass
= &(*where
)->assignment_statement
;
1520 if (ass
->exp
->type
.node_class
!= etree_assert
1521 && ass
->exp
->assign
.dst
[0] == '.'
1522 && ass
->exp
->assign
.dst
[1] == 0
1526 ignore_first
= FALSE
;
1528 case lang_wild_statement_enum
:
1529 case lang_input_section_enum
:
1530 case lang_object_symbols_statement_enum
:
1531 case lang_fill_statement_enum
:
1532 case lang_data_statement_enum
:
1533 case lang_reloc_statement_enum
:
1534 case lang_padding_statement_enum
:
1535 case lang_constructors_statement_enum
:
1538 case lang_output_section_statement_enum
:
1542 case lang_input_statement_enum
:
1543 case lang_address_statement_enum
:
1544 case lang_target_statement_enum
:
1545 case lang_output_statement_enum
:
1546 case lang_group_statement_enum
:
1547 case lang_insert_statement_enum
:
1556 lang_output_section_statement_type
*
1557 lang_insert_orphan (asection
*s
,
1558 const char *secname
,
1559 lang_output_section_statement_type
*after
,
1560 struct orphan_save
*place
,
1561 etree_type
*address
,
1562 lang_statement_list_type
*add_child
)
1564 lang_statement_list_type
*old
;
1565 lang_statement_list_type add
;
1567 lang_output_section_statement_type
*os
;
1568 lang_output_section_statement_type
**os_tail
;
1570 /* Start building a list of statements for this section.
1571 First save the current statement pointer. */
1574 /* If we have found an appropriate place for the output section
1575 statements for this orphan, add them to our own private list,
1576 inserting them later into the global statement list. */
1580 lang_list_init (stat_ptr
);
1584 if (config
.build_constructors
)
1586 /* If the name of the section is representable in C, then create
1587 symbols to mark the start and the end of the section. */
1588 for (ps
= secname
; *ps
!= '\0'; ps
++)
1589 if (! ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
1594 etree_type
*e_align
;
1596 symname
= (char *) xmalloc (ps
- secname
+ sizeof "__start_" + 1);
1597 symname
[0] = bfd_get_symbol_leading_char (link_info
.output_bfd
);
1598 sprintf (symname
+ (symname
[0] != 0), "__start_%s", secname
);
1599 e_align
= exp_unop (ALIGN_K
,
1600 exp_intop ((bfd_vma
) 1 << s
->alignment_power
));
1601 lang_add_assignment (exp_assop ('=', ".", e_align
));
1602 lang_add_assignment (exp_provide (symname
,
1603 exp_nameop (NAME
, "."),
1608 if (link_info
.relocatable
|| (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
1609 address
= exp_intop (0);
1611 os_tail
= ((lang_output_section_statement_type
**)
1612 lang_output_section_statement
.tail
);
1613 os
= lang_enter_output_section_statement (secname
, address
, 0, NULL
, NULL
,
1616 if (add_child
== NULL
)
1617 add_child
= &os
->children
;
1618 lang_add_section (add_child
, s
, os
);
1620 lang_leave_output_section_statement (0, "*default*", NULL
, NULL
);
1622 if (config
.build_constructors
&& *ps
== '\0')
1626 /* lang_leave_ouput_section_statement resets stat_ptr.
1627 Put stat_ptr back where we want it. */
1631 symname
= (char *) xmalloc (ps
- secname
+ sizeof "__stop_" + 1);
1632 symname
[0] = bfd_get_symbol_leading_char (link_info
.output_bfd
);
1633 sprintf (symname
+ (symname
[0] != 0), "__stop_%s", secname
);
1634 lang_add_assignment (exp_provide (symname
,
1635 exp_nameop (NAME
, "."),
1639 /* Restore the global list pointer. */
1643 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
1645 asection
*snew
, *as
;
1647 snew
= os
->bfd_section
;
1649 /* Shuffle the bfd section list to make the output file look
1650 neater. This is really only cosmetic. */
1651 if (place
->section
== NULL
1652 && after
!= (&lang_output_section_statement
.head
1653 ->output_section_statement
))
1655 asection
*bfd_section
= after
->bfd_section
;
1657 /* If the output statement hasn't been used to place any input
1658 sections (and thus doesn't have an output bfd_section),
1659 look for the closest prior output statement having an
1661 if (bfd_section
== NULL
)
1662 bfd_section
= output_prev_sec_find (after
);
1664 if (bfd_section
!= NULL
&& bfd_section
!= snew
)
1665 place
->section
= &bfd_section
->next
;
1668 if (place
->section
== NULL
)
1669 place
->section
= &link_info
.output_bfd
->sections
;
1671 as
= *place
->section
;
1675 /* Put the section at the end of the list. */
1677 /* Unlink the section. */
1678 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1680 /* Now tack it back on in the right place. */
1681 bfd_section_list_append (link_info
.output_bfd
, snew
);
1683 else if (as
!= snew
&& as
->prev
!= snew
)
1685 /* Unlink the section. */
1686 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1688 /* Now tack it back on in the right place. */
1689 bfd_section_list_insert_before (link_info
.output_bfd
, as
, snew
);
1692 /* Save the end of this list. Further ophans of this type will
1693 follow the one we've just added. */
1694 place
->section
= &snew
->next
;
1696 /* The following is non-cosmetic. We try to put the output
1697 statements in some sort of reasonable order here, because they
1698 determine the final load addresses of the orphan sections.
1699 In addition, placing output statements in the wrong order may
1700 require extra segments. For instance, given a typical
1701 situation of all read-only sections placed in one segment and
1702 following that a segment containing all the read-write
1703 sections, we wouldn't want to place an orphan read/write
1704 section before or amongst the read-only ones. */
1705 if (add
.head
!= NULL
)
1707 lang_output_section_statement_type
*newly_added_os
;
1709 if (place
->stmt
== NULL
)
1711 lang_statement_union_type
**where
= insert_os_after (after
);
1716 place
->os_tail
= &after
->next
;
1720 /* Put it after the last orphan statement we added. */
1721 *add
.tail
= *place
->stmt
;
1722 *place
->stmt
= add
.head
;
1725 /* Fix the global list pointer if we happened to tack our
1726 new list at the tail. */
1727 if (*old
->tail
== add
.head
)
1728 old
->tail
= add
.tail
;
1730 /* Save the end of this list. */
1731 place
->stmt
= add
.tail
;
1733 /* Do the same for the list of output section statements. */
1734 newly_added_os
= *os_tail
;
1736 newly_added_os
->prev
= (lang_output_section_statement_type
*)
1737 ((char *) place
->os_tail
1738 - offsetof (lang_output_section_statement_type
, next
));
1739 newly_added_os
->next
= *place
->os_tail
;
1740 if (newly_added_os
->next
!= NULL
)
1741 newly_added_os
->next
->prev
= newly_added_os
;
1742 *place
->os_tail
= newly_added_os
;
1743 place
->os_tail
= &newly_added_os
->next
;
1745 /* Fixing the global list pointer here is a little different.
1746 We added to the list in lang_enter_output_section_statement,
1747 trimmed off the new output_section_statment above when
1748 assigning *os_tail = NULL, but possibly added it back in
1749 the same place when assigning *place->os_tail. */
1750 if (*os_tail
== NULL
)
1751 lang_output_section_statement
.tail
1752 = (lang_statement_union_type
**) os_tail
;
1759 lang_map_flags (flagword flag
)
1761 if (flag
& SEC_ALLOC
)
1764 if (flag
& SEC_CODE
)
1767 if (flag
& SEC_READONLY
)
1770 if (flag
& SEC_DATA
)
1773 if (flag
& SEC_LOAD
)
1780 lang_memory_region_type
*m
;
1781 bfd_boolean dis_header_printed
= FALSE
;
1784 LANG_FOR_EACH_INPUT_STATEMENT (file
)
1788 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
1789 || file
->just_syms_flag
)
1792 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
1793 if ((s
->output_section
== NULL
1794 || s
->output_section
->owner
!= link_info
.output_bfd
)
1795 && (s
->flags
& (SEC_LINKER_CREATED
| SEC_KEEP
)) == 0)
1797 if (! dis_header_printed
)
1799 fprintf (config
.map_file
, _("\nDiscarded input sections\n\n"));
1800 dis_header_printed
= TRUE
;
1803 print_input_section (s
);
1807 minfo (_("\nMemory Configuration\n\n"));
1808 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
1809 _("Name"), _("Origin"), _("Length"), _("Attributes"));
1811 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
1816 fprintf (config
.map_file
, "%-16s ", m
->name
);
1818 sprintf_vma (buf
, m
->origin
);
1819 minfo ("0x%s ", buf
);
1827 minfo ("0x%V", m
->length
);
1828 if (m
->flags
|| m
->not_flags
)
1836 lang_map_flags (m
->flags
);
1842 lang_map_flags (m
->not_flags
);
1849 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
1851 if (! link_info
.reduce_memory_overheads
)
1853 obstack_begin (&map_obstack
, 1000);
1854 for (p
= link_info
.input_bfds
; p
!= (bfd
*) NULL
; p
= p
->link_next
)
1855 bfd_map_over_sections (p
, init_map_userdata
, 0);
1856 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
1858 lang_statement_iteration
++;
1859 print_statements ();
1863 init_map_userdata (bfd
*abfd ATTRIBUTE_UNUSED
,
1865 void *data ATTRIBUTE_UNUSED
)
1867 fat_section_userdata_type
*new_data
1868 = ((fat_section_userdata_type
*) (stat_alloc
1869 (sizeof (fat_section_userdata_type
))));
1871 ASSERT (get_userdata (sec
) == NULL
);
1872 get_userdata (sec
) = new_data
;
1873 new_data
->map_symbol_def_tail
= &new_data
->map_symbol_def_head
;
1877 sort_def_symbol (struct bfd_link_hash_entry
*hash_entry
,
1878 void *info ATTRIBUTE_UNUSED
)
1880 if (hash_entry
->type
== bfd_link_hash_defined
1881 || hash_entry
->type
== bfd_link_hash_defweak
)
1883 struct fat_user_section_struct
*ud
;
1884 struct map_symbol_def
*def
;
1886 ud
= get_userdata (hash_entry
->u
.def
.section
);
1889 /* ??? What do we have to do to initialize this beforehand? */
1890 /* The first time we get here is bfd_abs_section... */
1891 init_map_userdata (0, hash_entry
->u
.def
.section
, 0);
1892 ud
= get_userdata (hash_entry
->u
.def
.section
);
1894 else if (!ud
->map_symbol_def_tail
)
1895 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
1897 def
= obstack_alloc (&map_obstack
, sizeof *def
);
1898 def
->entry
= hash_entry
;
1899 *(ud
->map_symbol_def_tail
) = def
;
1900 ud
->map_symbol_def_tail
= &def
->next
;
1905 /* Initialize an output section. */
1908 init_os (lang_output_section_statement_type
*s
, asection
*isec
,
1911 if (s
->bfd_section
!= NULL
)
1914 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
1915 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
1917 s
->bfd_section
= bfd_get_section_by_name (link_info
.output_bfd
, s
->name
);
1918 if (s
->bfd_section
== NULL
)
1919 s
->bfd_section
= bfd_make_section_with_flags (link_info
.output_bfd
,
1921 if (s
->bfd_section
== NULL
)
1923 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
1924 link_info
.output_bfd
->xvec
->name
, s
->name
);
1926 s
->bfd_section
->output_section
= s
->bfd_section
;
1927 s
->bfd_section
->output_offset
= 0;
1929 if (!link_info
.reduce_memory_overheads
)
1931 fat_section_userdata_type
*new
1932 = stat_alloc (sizeof (fat_section_userdata_type
));
1933 memset (new, 0, sizeof (fat_section_userdata_type
));
1934 get_userdata (s
->bfd_section
) = new;
1937 /* If there is a base address, make sure that any sections it might
1938 mention are initialized. */
1939 if (s
->addr_tree
!= NULL
)
1940 exp_init_os (s
->addr_tree
);
1942 if (s
->load_base
!= NULL
)
1943 exp_init_os (s
->load_base
);
1945 /* If supplied an alignment, set it. */
1946 if (s
->section_alignment
!= -1)
1947 s
->bfd_section
->alignment_power
= s
->section_alignment
;
1950 bfd_init_private_section_data (isec
->owner
, isec
,
1951 link_info
.output_bfd
, s
->bfd_section
,
1955 /* Make sure that all output sections mentioned in an expression are
1959 exp_init_os (etree_type
*exp
)
1961 switch (exp
->type
.node_class
)
1965 exp_init_os (exp
->assign
.src
);
1969 exp_init_os (exp
->binary
.lhs
);
1970 exp_init_os (exp
->binary
.rhs
);
1974 exp_init_os (exp
->trinary
.cond
);
1975 exp_init_os (exp
->trinary
.lhs
);
1976 exp_init_os (exp
->trinary
.rhs
);
1980 exp_init_os (exp
->assert_s
.child
);
1984 exp_init_os (exp
->unary
.child
);
1988 switch (exp
->type
.node_code
)
1994 lang_output_section_statement_type
*os
;
1996 os
= lang_output_section_find (exp
->name
.name
);
1997 if (os
!= NULL
&& os
->bfd_section
== NULL
)
1998 init_os (os
, NULL
, 0);
2009 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
2011 lang_input_statement_type
*entry
= data
;
2013 /* If we are only reading symbols from this object, then we want to
2014 discard all sections. */
2015 if (entry
->just_syms_flag
)
2017 bfd_link_just_syms (abfd
, sec
, &link_info
);
2021 if (!(abfd
->flags
& DYNAMIC
))
2022 bfd_section_already_linked (abfd
, sec
, &link_info
);
2025 /* The wild routines.
2027 These expand statements like *(.text) and foo.o to a list of
2028 explicit actions, like foo.o(.text), bar.o(.text) and
2029 foo.o(.text, .data). */
2031 /* Add SECTION to the output section OUTPUT. Do this by creating a
2032 lang_input_section statement which is placed at PTR. FILE is the
2033 input file which holds SECTION. */
2036 lang_add_section (lang_statement_list_type
*ptr
,
2038 lang_output_section_statement_type
*output
)
2040 flagword flags
= section
->flags
;
2041 bfd_boolean discard
;
2043 /* Discard sections marked with SEC_EXCLUDE. */
2044 discard
= (flags
& SEC_EXCLUDE
) != 0;
2046 /* Discard input sections which are assigned to a section named
2047 DISCARD_SECTION_NAME. */
2048 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
2051 /* Discard debugging sections if we are stripping debugging
2053 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
2054 && (flags
& SEC_DEBUGGING
) != 0)
2059 if (section
->output_section
== NULL
)
2061 /* This prevents future calls from assigning this section. */
2062 section
->output_section
= bfd_abs_section_ptr
;
2067 if (section
->output_section
== NULL
)
2070 lang_input_section_type
*new;
2073 flags
= section
->flags
;
2075 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2076 to an output section, because we want to be able to include a
2077 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2078 section (I don't know why we want to do this, but we do).
2079 build_link_order in ldwrite.c handles this case by turning
2080 the embedded SEC_NEVER_LOAD section into a fill. */
2082 flags
&= ~ SEC_NEVER_LOAD
;
2084 switch (output
->sectype
)
2086 case normal_section
:
2087 case overlay_section
:
2089 case noalloc_section
:
2090 flags
&= ~SEC_ALLOC
;
2092 case noload_section
:
2094 flags
|= SEC_NEVER_LOAD
;
2098 if (output
->bfd_section
== NULL
)
2099 init_os (output
, section
, flags
);
2101 first
= ! output
->bfd_section
->linker_has_input
;
2102 output
->bfd_section
->linker_has_input
= 1;
2104 if (!link_info
.relocatable
2105 && !stripped_excluded_sections
)
2107 asection
*s
= output
->bfd_section
->map_tail
.s
;
2108 output
->bfd_section
->map_tail
.s
= section
;
2109 section
->map_head
.s
= NULL
;
2110 section
->map_tail
.s
= s
;
2112 s
->map_head
.s
= section
;
2114 output
->bfd_section
->map_head
.s
= section
;
2117 /* Add a section reference to the list. */
2118 new = new_stat (lang_input_section
, ptr
);
2120 new->section
= section
;
2121 section
->output_section
= output
->bfd_section
;
2123 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2124 already been processed. One reason to do this is that on pe
2125 format targets, .text$foo sections go into .text and it's odd
2126 to see .text with SEC_LINK_ONCE set. */
2128 if (! link_info
.relocatable
)
2129 flags
&= ~ (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
);
2131 /* If this is not the first input section, and the SEC_READONLY
2132 flag is not currently set, then don't set it just because the
2133 input section has it set. */
2135 if (! first
&& (output
->bfd_section
->flags
& SEC_READONLY
) == 0)
2136 flags
&= ~ SEC_READONLY
;
2138 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2140 && ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2141 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2142 || ((flags
& SEC_MERGE
)
2143 && output
->bfd_section
->entsize
!= section
->entsize
)))
2145 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2146 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2149 output
->bfd_section
->flags
|= flags
;
2151 if (flags
& SEC_MERGE
)
2152 output
->bfd_section
->entsize
= section
->entsize
;
2154 /* If SEC_READONLY is not set in the input section, then clear
2155 it from the output section. */
2156 if ((section
->flags
& SEC_READONLY
) == 0)
2157 output
->bfd_section
->flags
&= ~SEC_READONLY
;
2159 /* Copy over SEC_SMALL_DATA. */
2160 if (section
->flags
& SEC_SMALL_DATA
)
2161 output
->bfd_section
->flags
|= SEC_SMALL_DATA
;
2163 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2164 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2166 if (bfd_get_arch (section
->owner
) == bfd_arch_tic54x
2167 && (section
->flags
& SEC_TIC54X_BLOCK
) != 0)
2169 output
->bfd_section
->flags
|= SEC_TIC54X_BLOCK
;
2170 /* FIXME: This value should really be obtained from the bfd... */
2171 output
->block_value
= 128;
2176 /* Handle wildcard sorting. This returns the lang_input_section which
2177 should follow the one we are going to create for SECTION and FILE,
2178 based on the sorting requirements of WILD. It returns NULL if the
2179 new section should just go at the end of the current list. */
2181 static lang_statement_union_type
*
2182 wild_sort (lang_wild_statement_type
*wild
,
2183 struct wildcard_list
*sec
,
2184 lang_input_statement_type
*file
,
2187 const char *section_name
;
2188 lang_statement_union_type
*l
;
2190 if (!wild
->filenames_sorted
2191 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
2194 section_name
= bfd_get_section_name (file
->the_bfd
, section
);
2195 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
2197 lang_input_section_type
*ls
;
2199 if (l
->header
.type
!= lang_input_section_enum
)
2201 ls
= &l
->input_section
;
2203 /* Sorting by filename takes precedence over sorting by section
2206 if (wild
->filenames_sorted
)
2208 const char *fn
, *ln
;
2212 /* The PE support for the .idata section as generated by
2213 dlltool assumes that files will be sorted by the name of
2214 the archive and then the name of the file within the
2217 if (file
->the_bfd
!= NULL
2218 && bfd_my_archive (file
->the_bfd
) != NULL
)
2220 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
2225 fn
= file
->filename
;
2229 if (bfd_my_archive (ls
->section
->owner
) != NULL
)
2231 ln
= bfd_get_filename (bfd_my_archive (ls
->section
->owner
));
2236 ln
= ls
->section
->owner
->filename
;
2240 i
= strcmp (fn
, ln
);
2249 fn
= file
->filename
;
2251 ln
= ls
->section
->owner
->filename
;
2253 i
= strcmp (fn
, ln
);
2261 /* Here either the files are not sorted by name, or we are
2262 looking at the sections for this file. */
2264 if (sec
!= NULL
&& sec
->spec
.sorted
!= none
)
2265 if (compare_section (sec
->spec
.sorted
, section
, ls
->section
) < 0)
2272 /* Expand a wild statement for a particular FILE. SECTION may be
2273 NULL, in which case it is a wild card. */
2276 output_section_callback (lang_wild_statement_type
*ptr
,
2277 struct wildcard_list
*sec
,
2279 lang_input_statement_type
*file
,
2282 lang_statement_union_type
*before
;
2284 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2285 if (unique_section_p (section
))
2288 before
= wild_sort (ptr
, sec
, file
, section
);
2290 /* Here BEFORE points to the lang_input_section which
2291 should follow the one we are about to add. If BEFORE
2292 is NULL, then the section should just go at the end
2293 of the current list. */
2296 lang_add_section (&ptr
->children
, section
,
2297 (lang_output_section_statement_type
*) output
);
2300 lang_statement_list_type list
;
2301 lang_statement_union_type
**pp
;
2303 lang_list_init (&list
);
2304 lang_add_section (&list
, section
,
2305 (lang_output_section_statement_type
*) output
);
2307 /* If we are discarding the section, LIST.HEAD will
2309 if (list
.head
!= NULL
)
2311 ASSERT (list
.head
->header
.next
== NULL
);
2313 for (pp
= &ptr
->children
.head
;
2315 pp
= &(*pp
)->header
.next
)
2316 ASSERT (*pp
!= NULL
);
2318 list
.head
->header
.next
= *pp
;
2324 /* Check if all sections in a wild statement for a particular FILE
2328 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2329 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2331 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2334 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2335 if (unique_section_p (section
))
2338 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2339 ((lang_output_section_statement_type
*) data
)->all_input_readonly
= FALSE
;
2342 /* This is passed a file name which must have been seen already and
2343 added to the statement tree. We will see if it has been opened
2344 already and had its symbols read. If not then we'll read it. */
2346 static lang_input_statement_type
*
2347 lookup_name (const char *name
)
2349 lang_input_statement_type
*search
;
2351 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
2353 search
= (lang_input_statement_type
*) search
->next_real_file
)
2355 /* Use the local_sym_name as the name of the file that has
2356 already been loaded as filename might have been transformed
2357 via the search directory lookup mechanism. */
2358 const char *filename
= search
->local_sym_name
;
2360 if (filename
!= NULL
2361 && strcmp (filename
, name
) == 0)
2366 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2367 default_target
, FALSE
);
2369 /* If we have already added this file, or this file is not real
2370 don't add this file. */
2371 if (search
->loaded
|| !search
->real
)
2374 if (! load_symbols (search
, NULL
))
2380 /* Save LIST as a list of libraries whose symbols should not be exported. */
2385 struct excluded_lib
*next
;
2387 static struct excluded_lib
*excluded_libs
;
2390 add_excluded_libs (const char *list
)
2392 const char *p
= list
, *end
;
2396 struct excluded_lib
*entry
;
2397 end
= strpbrk (p
, ",:");
2399 end
= p
+ strlen (p
);
2400 entry
= xmalloc (sizeof (*entry
));
2401 entry
->next
= excluded_libs
;
2402 entry
->name
= xmalloc (end
- p
+ 1);
2403 memcpy (entry
->name
, p
, end
- p
);
2404 entry
->name
[end
- p
] = '\0';
2405 excluded_libs
= entry
;
2413 check_excluded_libs (bfd
*abfd
)
2415 struct excluded_lib
*lib
= excluded_libs
;
2419 int len
= strlen (lib
->name
);
2420 const char *filename
= lbasename (abfd
->filename
);
2422 if (strcmp (lib
->name
, "ALL") == 0)
2424 abfd
->no_export
= TRUE
;
2428 if (strncmp (lib
->name
, filename
, len
) == 0
2429 && (filename
[len
] == '\0'
2430 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
2431 && filename
[len
+ 2] == '\0')))
2433 abfd
->no_export
= TRUE
;
2441 /* Get the symbols for an input file. */
2444 load_symbols (lang_input_statement_type
*entry
,
2445 lang_statement_list_type
*place
)
2452 ldfile_open_file (entry
);
2454 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
2455 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
2458 lang_statement_list_type
*hold
;
2459 bfd_boolean bad_load
= TRUE
;
2460 bfd_boolean save_ldlang_sysrooted_script
;
2461 bfd_boolean save_as_needed
, save_add_needed
;
2463 err
= bfd_get_error ();
2465 /* See if the emulation has some special knowledge. */
2466 if (ldemul_unrecognized_file (entry
))
2469 if (err
== bfd_error_file_ambiguously_recognized
)
2473 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
2474 einfo (_("%B: matching formats:"), entry
->the_bfd
);
2475 for (p
= matching
; *p
!= NULL
; p
++)
2479 else if (err
!= bfd_error_file_not_recognized
2481 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
2485 bfd_close (entry
->the_bfd
);
2486 entry
->the_bfd
= NULL
;
2488 /* Try to interpret the file as a linker script. */
2489 ldfile_open_command_file (entry
->filename
);
2493 save_ldlang_sysrooted_script
= ldlang_sysrooted_script
;
2494 ldlang_sysrooted_script
= entry
->sysrooted
;
2495 save_as_needed
= as_needed
;
2496 as_needed
= entry
->as_needed
;
2497 save_add_needed
= add_needed
;
2498 add_needed
= entry
->add_needed
;
2500 ldfile_assumed_script
= TRUE
;
2501 parser_input
= input_script
;
2502 /* We want to use the same -Bdynamic/-Bstatic as the one for
2504 config
.dynamic_link
= entry
->dynamic
;
2506 ldfile_assumed_script
= FALSE
;
2508 ldlang_sysrooted_script
= save_ldlang_sysrooted_script
;
2509 as_needed
= save_as_needed
;
2510 add_needed
= save_add_needed
;
2516 if (ldemul_recognized_file (entry
))
2519 /* We don't call ldlang_add_file for an archive. Instead, the
2520 add_symbols entry point will call ldlang_add_file, via the
2521 add_archive_element callback, for each element of the archive
2523 switch (bfd_get_format (entry
->the_bfd
))
2529 ldlang_add_file (entry
);
2530 if (trace_files
|| trace_file_tries
)
2531 info_msg ("%I\n", entry
);
2535 check_excluded_libs (entry
->the_bfd
);
2537 if (entry
->whole_archive
)
2540 bfd_boolean loaded
= TRUE
;
2544 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
2549 if (! bfd_check_format (member
, bfd_object
))
2551 einfo (_("%F%B: member %B in archive is not an object\n"),
2552 entry
->the_bfd
, member
);
2556 if (! ((*link_info
.callbacks
->add_archive_element
)
2557 (&link_info
, member
, "--whole-archive")))
2560 if (! bfd_link_add_symbols (member
, &link_info
))
2562 einfo (_("%F%B: could not read symbols: %E\n"), member
);
2567 entry
->loaded
= loaded
;
2573 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
2574 entry
->loaded
= TRUE
;
2576 einfo (_("%F%B: could not read symbols: %E\n"), entry
->the_bfd
);
2578 return entry
->loaded
;
2581 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
2582 may be NULL, indicating that it is a wildcard. Separate
2583 lang_input_section statements are created for each part of the
2584 expansion; they are added after the wild statement S. OUTPUT is
2585 the output section. */
2588 wild (lang_wild_statement_type
*s
,
2589 const char *target ATTRIBUTE_UNUSED
,
2590 lang_output_section_statement_type
*output
)
2592 struct wildcard_list
*sec
;
2594 if (s
->handler_data
[0]
2595 && s
->handler_data
[0]->spec
.sorted
== by_name
2596 && !s
->filenames_sorted
)
2598 lang_section_bst_type
*tree
;
2600 walk_wild (s
, output_section_callback_fast
, output
);
2605 output_section_callback_tree_to_list (s
, tree
, output
);
2610 walk_wild (s
, output_section_callback
, output
);
2612 if (default_common_section
== NULL
)
2613 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
2614 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
2616 /* Remember the section that common is going to in case we
2617 later get something which doesn't know where to put it. */
2618 default_common_section
= output
;
2623 /* Return TRUE iff target is the sought target. */
2626 get_target (const bfd_target
*target
, void *data
)
2628 const char *sought
= data
;
2630 return strcmp (target
->name
, sought
) == 0;
2633 /* Like strcpy() but convert to lower case as well. */
2636 stricpy (char *dest
, char *src
)
2640 while ((c
= *src
++) != 0)
2641 *dest
++ = TOLOWER (c
);
2646 /* Remove the first occurrence of needle (if any) in haystack
2650 strcut (char *haystack
, char *needle
)
2652 haystack
= strstr (haystack
, needle
);
2658 for (src
= haystack
+ strlen (needle
); *src
;)
2659 *haystack
++ = *src
++;
2665 /* Compare two target format name strings.
2666 Return a value indicating how "similar" they are. */
2669 name_compare (char *first
, char *second
)
2675 copy1
= xmalloc (strlen (first
) + 1);
2676 copy2
= xmalloc (strlen (second
) + 1);
2678 /* Convert the names to lower case. */
2679 stricpy (copy1
, first
);
2680 stricpy (copy2
, second
);
2682 /* Remove size and endian strings from the name. */
2683 strcut (copy1
, "big");
2684 strcut (copy1
, "little");
2685 strcut (copy2
, "big");
2686 strcut (copy2
, "little");
2688 /* Return a value based on how many characters match,
2689 starting from the beginning. If both strings are
2690 the same then return 10 * their length. */
2691 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
2692 if (copy1
[result
] == 0)
2704 /* Set by closest_target_match() below. */
2705 static const bfd_target
*winner
;
2707 /* Scan all the valid bfd targets looking for one that has the endianness
2708 requirement that was specified on the command line, and is the nearest
2709 match to the original output target. */
2712 closest_target_match (const bfd_target
*target
, void *data
)
2714 const bfd_target
*original
= data
;
2716 if (command_line
.endian
== ENDIAN_BIG
2717 && target
->byteorder
!= BFD_ENDIAN_BIG
)
2720 if (command_line
.endian
== ENDIAN_LITTLE
2721 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
2724 /* Must be the same flavour. */
2725 if (target
->flavour
!= original
->flavour
)
2728 /* Ignore generic big and little endian elf vectors. */
2729 if (strcmp (target
->name
, "elf32-big") == 0
2730 || strcmp (target
->name
, "elf64-big") == 0
2731 || strcmp (target
->name
, "elf32-little") == 0
2732 || strcmp (target
->name
, "elf64-little") == 0)
2735 /* If we have not found a potential winner yet, then record this one. */
2742 /* Oh dear, we now have two potential candidates for a successful match.
2743 Compare their names and choose the better one. */
2744 if (name_compare (target
->name
, original
->name
)
2745 > name_compare (winner
->name
, original
->name
))
2748 /* Keep on searching until wqe have checked them all. */
2752 /* Return the BFD target format of the first input file. */
2755 get_first_input_target (void)
2757 char *target
= NULL
;
2759 LANG_FOR_EACH_INPUT_STATEMENT (s
)
2761 if (s
->header
.type
== lang_input_statement_enum
2764 ldfile_open_file (s
);
2766 if (s
->the_bfd
!= NULL
2767 && bfd_check_format (s
->the_bfd
, bfd_object
))
2769 target
= bfd_get_target (s
->the_bfd
);
2781 lang_get_output_target (void)
2785 /* Has the user told us which output format to use? */
2786 if (output_target
!= NULL
)
2787 return output_target
;
2789 /* No - has the current target been set to something other than
2791 if (current_target
!= default_target
)
2792 return current_target
;
2794 /* No - can we determine the format of the first input file? */
2795 target
= get_first_input_target ();
2799 /* Failed - use the default output target. */
2800 return default_target
;
2803 /* Open the output file. */
2806 open_output (const char *name
)
2808 output_target
= lang_get_output_target ();
2810 /* Has the user requested a particular endianness on the command
2812 if (command_line
.endian
!= ENDIAN_UNSET
)
2814 const bfd_target
*target
;
2815 enum bfd_endian desired_endian
;
2817 /* Get the chosen target. */
2818 target
= bfd_search_for_target (get_target
, (void *) output_target
);
2820 /* If the target is not supported, we cannot do anything. */
2823 if (command_line
.endian
== ENDIAN_BIG
)
2824 desired_endian
= BFD_ENDIAN_BIG
;
2826 desired_endian
= BFD_ENDIAN_LITTLE
;
2828 /* See if the target has the wrong endianness. This should
2829 not happen if the linker script has provided big and
2830 little endian alternatives, but some scrips don't do
2832 if (target
->byteorder
!= desired_endian
)
2834 /* If it does, then see if the target provides
2835 an alternative with the correct endianness. */
2836 if (target
->alternative_target
!= NULL
2837 && (target
->alternative_target
->byteorder
== desired_endian
))
2838 output_target
= target
->alternative_target
->name
;
2841 /* Try to find a target as similar as possible to
2842 the default target, but which has the desired
2843 endian characteristic. */
2844 bfd_search_for_target (closest_target_match
,
2847 /* Oh dear - we could not find any targets that
2848 satisfy our requirements. */
2850 einfo (_("%P: warning: could not find any targets"
2851 " that match endianness requirement\n"));
2853 output_target
= winner
->name
;
2859 link_info
.output_bfd
= bfd_openw (name
, output_target
);
2861 if (link_info
.output_bfd
== NULL
)
2863 if (bfd_get_error () == bfd_error_invalid_target
)
2864 einfo (_("%P%F: target %s not found\n"), output_target
);
2866 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
2869 delete_output_file_on_failure
= TRUE
;
2871 if (! bfd_set_format (link_info
.output_bfd
, bfd_object
))
2872 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
2873 if (! bfd_set_arch_mach (link_info
.output_bfd
,
2874 ldfile_output_architecture
,
2875 ldfile_output_machine
))
2876 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
2878 link_info
.hash
= bfd_link_hash_table_create (link_info
.output_bfd
);
2879 if (link_info
.hash
== NULL
)
2880 einfo (_("%P%F: can not create hash table: %E\n"));
2882 bfd_set_gp_size (link_info
.output_bfd
, g_switch_value
);
2886 ldlang_open_output (lang_statement_union_type
*statement
)
2888 switch (statement
->header
.type
)
2890 case lang_output_statement_enum
:
2891 ASSERT (link_info
.output_bfd
== NULL
);
2892 open_output (statement
->output_statement
.name
);
2893 ldemul_set_output_arch ();
2894 if (config
.magic_demand_paged
&& !link_info
.relocatable
)
2895 link_info
.output_bfd
->flags
|= D_PAGED
;
2897 link_info
.output_bfd
->flags
&= ~D_PAGED
;
2898 if (config
.text_read_only
)
2899 link_info
.output_bfd
->flags
|= WP_TEXT
;
2901 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
2902 if (link_info
.traditional_format
)
2903 link_info
.output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
2905 link_info
.output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
2908 case lang_target_statement_enum
:
2909 current_target
= statement
->target_statement
.target
;
2916 /* Convert between addresses in bytes and sizes in octets.
2917 For currently supported targets, octets_per_byte is always a power
2918 of two, so we can use shifts. */
2919 #define TO_ADDR(X) ((X) >> opb_shift)
2920 #define TO_SIZE(X) ((X) << opb_shift)
2922 /* Support the above. */
2923 static unsigned int opb_shift
= 0;
2928 unsigned x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2929 ldfile_output_machine
);
2932 while ((x
& 1) == 0)
2940 /* Open all the input files. */
2943 open_input_bfds (lang_statement_union_type
*s
, bfd_boolean force
)
2945 for (; s
!= NULL
; s
= s
->header
.next
)
2947 switch (s
->header
.type
)
2949 case lang_constructors_statement_enum
:
2950 open_input_bfds (constructor_list
.head
, force
);
2952 case lang_output_section_statement_enum
:
2953 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
2955 case lang_wild_statement_enum
:
2956 /* Maybe we should load the file's symbols. */
2957 if (s
->wild_statement
.filename
2958 && !wildcardp (s
->wild_statement
.filename
)
2959 && !archive_path (s
->wild_statement
.filename
))
2960 lookup_name (s
->wild_statement
.filename
);
2961 open_input_bfds (s
->wild_statement
.children
.head
, force
);
2963 case lang_group_statement_enum
:
2965 struct bfd_link_hash_entry
*undefs
;
2967 /* We must continually search the entries in the group
2968 until no new symbols are added to the list of undefined
2973 undefs
= link_info
.hash
->undefs_tail
;
2974 open_input_bfds (s
->group_statement
.children
.head
, TRUE
);
2976 while (undefs
!= link_info
.hash
->undefs_tail
);
2979 case lang_target_statement_enum
:
2980 current_target
= s
->target_statement
.target
;
2982 case lang_input_statement_enum
:
2983 if (s
->input_statement
.real
)
2985 lang_statement_list_type add
;
2987 s
->input_statement
.target
= current_target
;
2989 /* If we are being called from within a group, and this
2990 is an archive which has already been searched, then
2991 force it to be researched unless the whole archive
2992 has been loaded already. */
2994 && !s
->input_statement
.whole_archive
2995 && s
->input_statement
.loaded
2996 && bfd_check_format (s
->input_statement
.the_bfd
,
2998 s
->input_statement
.loaded
= FALSE
;
3000 lang_list_init (&add
);
3002 if (! load_symbols (&s
->input_statement
, &add
))
3003 config
.make_executable
= FALSE
;
3005 if (add
.head
!= NULL
)
3007 *add
.tail
= s
->header
.next
;
3008 s
->header
.next
= add
.head
;
3018 /* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions. */
3021 lang_track_definedness (const char *name
)
3023 if (bfd_hash_lookup (&lang_definedness_table
, name
, TRUE
, FALSE
) == NULL
)
3024 einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name
);
3027 /* New-function for the definedness hash table. */
3029 static struct bfd_hash_entry
*
3030 lang_definedness_newfunc (struct bfd_hash_entry
*entry
,
3031 struct bfd_hash_table
*table ATTRIBUTE_UNUSED
,
3032 const char *name ATTRIBUTE_UNUSED
)
3034 struct lang_definedness_hash_entry
*ret
3035 = (struct lang_definedness_hash_entry
*) entry
;
3038 ret
= (struct lang_definedness_hash_entry
*)
3039 bfd_hash_allocate (table
, sizeof (struct lang_definedness_hash_entry
));
3042 einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name
);
3044 ret
->iteration
= -1;
3048 /* Return the iteration when the definition of NAME was last updated. A
3049 value of -1 means that the symbol is not defined in the linker script
3050 or the command line, but may be defined in the linker symbol table. */
3053 lang_symbol_definition_iteration (const char *name
)
3055 struct lang_definedness_hash_entry
*defentry
3056 = (struct lang_definedness_hash_entry
*)
3057 bfd_hash_lookup (&lang_definedness_table
, name
, FALSE
, FALSE
);
3059 /* We've already created this one on the presence of DEFINED in the
3060 script, so it can't be NULL unless something is borked elsewhere in
3062 if (defentry
== NULL
)
3065 return defentry
->iteration
;
3068 /* Update the definedness state of NAME. */
3071 lang_update_definedness (const char *name
, struct bfd_link_hash_entry
*h
)
3073 struct lang_definedness_hash_entry
*defentry
3074 = (struct lang_definedness_hash_entry
*)
3075 bfd_hash_lookup (&lang_definedness_table
, name
, FALSE
, FALSE
);
3077 /* We don't keep track of symbols not tested with DEFINED. */
3078 if (defentry
== NULL
)
3081 /* If the symbol was already defined, and not from an earlier statement
3082 iteration, don't update the definedness iteration, because that'd
3083 make the symbol seem defined in the linker script at this point, and
3084 it wasn't; it was defined in some object. If we do anyway, DEFINED
3085 would start to yield false before this point and the construct "sym =
3086 DEFINED (sym) ? sym : X;" would change sym to X despite being defined
3088 if (h
->type
!= bfd_link_hash_undefined
3089 && h
->type
!= bfd_link_hash_common
3090 && h
->type
!= bfd_link_hash_new
3091 && defentry
->iteration
== -1)
3094 defentry
->iteration
= lang_statement_iteration
;
3097 /* Add the supplied name to the symbol table as an undefined reference.
3098 This is a two step process as the symbol table doesn't even exist at
3099 the time the ld command line is processed. First we put the name
3100 on a list, then, once the output file has been opened, transfer the
3101 name to the symbol table. */
3103 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3105 #define ldlang_undef_chain_list_head entry_symbol.next
3108 ldlang_add_undef (const char *const name
)
3110 ldlang_undef_chain_list_type
*new =
3111 stat_alloc (sizeof (ldlang_undef_chain_list_type
));
3113 new->next
= ldlang_undef_chain_list_head
;
3114 ldlang_undef_chain_list_head
= new;
3116 new->name
= xstrdup (name
);
3118 if (link_info
.output_bfd
!= NULL
)
3119 insert_undefined (new->name
);
3122 /* Insert NAME as undefined in the symbol table. */
3125 insert_undefined (const char *name
)
3127 struct bfd_link_hash_entry
*h
;
3129 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
3131 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3132 if (h
->type
== bfd_link_hash_new
)
3134 h
->type
= bfd_link_hash_undefined
;
3135 h
->u
.undef
.abfd
= NULL
;
3136 bfd_link_add_undef (link_info
.hash
, h
);
3140 /* Run through the list of undefineds created above and place them
3141 into the linker hash table as undefined symbols belonging to the
3145 lang_place_undefineds (void)
3147 ldlang_undef_chain_list_type
*ptr
;
3149 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3150 insert_undefined (ptr
->name
);
3153 /* Check for all readonly or some readwrite sections. */
3156 check_input_sections
3157 (lang_statement_union_type
*s
,
3158 lang_output_section_statement_type
*output_section_statement
)
3160 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
3162 switch (s
->header
.type
)
3164 case lang_wild_statement_enum
:
3165 walk_wild (&s
->wild_statement
, check_section_callback
,
3166 output_section_statement
);
3167 if (! output_section_statement
->all_input_readonly
)
3170 case lang_constructors_statement_enum
:
3171 check_input_sections (constructor_list
.head
,
3172 output_section_statement
);
3173 if (! output_section_statement
->all_input_readonly
)
3176 case lang_group_statement_enum
:
3177 check_input_sections (s
->group_statement
.children
.head
,
3178 output_section_statement
);
3179 if (! output_section_statement
->all_input_readonly
)
3188 /* Update wildcard statements if needed. */
3191 update_wild_statements (lang_statement_union_type
*s
)
3193 struct wildcard_list
*sec
;
3195 switch (sort_section
)
3205 for (; s
!= NULL
; s
= s
->header
.next
)
3207 switch (s
->header
.type
)
3212 case lang_wild_statement_enum
:
3213 sec
= s
->wild_statement
.section_list
;
3214 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
3217 switch (sec
->spec
.sorted
)
3220 sec
->spec
.sorted
= sort_section
;
3223 if (sort_section
== by_alignment
)
3224 sec
->spec
.sorted
= by_name_alignment
;
3227 if (sort_section
== by_name
)
3228 sec
->spec
.sorted
= by_alignment_name
;
3236 case lang_constructors_statement_enum
:
3237 update_wild_statements (constructor_list
.head
);
3240 case lang_output_section_statement_enum
:
3241 update_wild_statements
3242 (s
->output_section_statement
.children
.head
);
3245 case lang_group_statement_enum
:
3246 update_wild_statements (s
->group_statement
.children
.head
);
3254 /* Open input files and attach to output sections. */
3257 map_input_to_output_sections
3258 (lang_statement_union_type
*s
, const char *target
,
3259 lang_output_section_statement_type
*os
)
3263 for (; s
!= NULL
; s
= s
->header
.next
)
3265 switch (s
->header
.type
)
3267 case lang_wild_statement_enum
:
3268 wild (&s
->wild_statement
, target
, os
);
3270 case lang_constructors_statement_enum
:
3271 map_input_to_output_sections (constructor_list
.head
,
3275 case lang_output_section_statement_enum
:
3276 if (s
->output_section_statement
.constraint
)
3278 if (s
->output_section_statement
.constraint
!= ONLY_IF_RW
3279 && s
->output_section_statement
.constraint
!= ONLY_IF_RO
)
3281 s
->output_section_statement
.all_input_readonly
= TRUE
;
3282 check_input_sections (s
->output_section_statement
.children
.head
,
3283 &s
->output_section_statement
);
3284 if ((s
->output_section_statement
.all_input_readonly
3285 && s
->output_section_statement
.constraint
== ONLY_IF_RW
)
3286 || (!s
->output_section_statement
.all_input_readonly
3287 && s
->output_section_statement
.constraint
== ONLY_IF_RO
))
3289 s
->output_section_statement
.constraint
= -1;
3294 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
3296 &s
->output_section_statement
);
3298 case lang_output_statement_enum
:
3300 case lang_target_statement_enum
:
3301 target
= s
->target_statement
.target
;
3303 case lang_group_statement_enum
:
3304 map_input_to_output_sections (s
->group_statement
.children
.head
,
3308 case lang_data_statement_enum
:
3309 /* Make sure that any sections mentioned in the expression
3311 exp_init_os (s
->data_statement
.exp
);
3312 flags
= SEC_HAS_CONTENTS
;
3313 /* The output section gets contents, and then we inspect for
3314 any flags set in the input script which override any ALLOC. */
3315 if (!(os
->flags
& SEC_NEVER_LOAD
))
3316 flags
|= SEC_ALLOC
| SEC_LOAD
;
3317 if (os
->bfd_section
== NULL
)
3318 init_os (os
, NULL
, flags
);
3320 os
->bfd_section
->flags
|= flags
;
3322 case lang_input_section_enum
:
3324 case lang_fill_statement_enum
:
3325 case lang_object_symbols_statement_enum
:
3326 case lang_reloc_statement_enum
:
3327 case lang_padding_statement_enum
:
3328 case lang_input_statement_enum
:
3329 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3330 init_os (os
, NULL
, 0);
3332 case lang_assignment_statement_enum
:
3333 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3334 init_os (os
, NULL
, 0);
3336 /* Make sure that any sections mentioned in the assignment
3338 exp_init_os (s
->assignment_statement
.exp
);
3340 case lang_address_statement_enum
:
3341 /* Mark the specified section with the supplied address.
3342 If this section was actually a segment marker, then the
3343 directive is ignored if the linker script explicitly
3344 processed the segment marker. Originally, the linker
3345 treated segment directives (like -Ttext on the
3346 command-line) as section directives. We honor the
3347 section directive semantics for backwards compatibilty;
3348 linker scripts that do not specifically check for
3349 SEGMENT_START automatically get the old semantics. */
3350 if (!s
->address_statement
.segment
3351 || !s
->address_statement
.segment
->used
)
3353 lang_output_section_statement_type
*aos
3354 = (lang_output_section_statement_lookup
3355 (s
->address_statement
.section_name
, 0, TRUE
));
3357 if (aos
->bfd_section
== NULL
)
3358 init_os (aos
, NULL
, 0);
3359 aos
->addr_tree
= s
->address_statement
.address
;
3362 case lang_insert_statement_enum
:
3368 /* An insert statement snips out all the linker statements from the
3369 start of the list and places them after the output section
3370 statement specified by the insert. This operation is complicated
3371 by the fact that we keep a doubly linked list of output section
3372 statements as well as the singly linked list of all statements. */
3375 process_insert_statements (void)
3377 lang_statement_union_type
**s
;
3378 lang_output_section_statement_type
*first_os
= NULL
;
3379 lang_output_section_statement_type
*last_os
= NULL
;
3380 lang_output_section_statement_type
*os
;
3382 /* "start of list" is actually the statement immediately after
3383 the special abs_section output statement, so that it isn't
3385 s
= &lang_output_section_statement
.head
;
3386 while (*(s
= &(*s
)->header
.next
) != NULL
)
3388 if ((*s
)->header
.type
== lang_output_section_statement_enum
)
3390 /* Keep pointers to the first and last output section
3391 statement in the sequence we may be about to move. */
3392 last_os
= &(*s
)->output_section_statement
;
3394 /* Set constraint negative so that lang_output_section_find
3395 won't match this output section statement. At this
3396 stage in linking constraint has values in the range
3397 [-1, ONLY_IN_RW]. */
3398 last_os
->constraint
= -2 - last_os
->constraint
;
3399 if (first_os
== NULL
)
3402 else if ((*s
)->header
.type
== lang_insert_statement_enum
)
3404 lang_insert_statement_type
*i
= &(*s
)->insert_statement
;
3405 lang_output_section_statement_type
*where
;
3406 lang_statement_union_type
**ptr
;
3407 lang_statement_union_type
*first
;
3409 where
= lang_output_section_find (i
->where
);
3410 if (where
!= NULL
&& i
->is_before
)
3413 where
= where
->prev
;
3414 while (where
!= NULL
&& where
->constraint
< 0);
3418 einfo (_("%F%P: %s not found for insert\n"), i
->where
);
3422 /* Deal with reordering the output section statement list. */
3423 if (last_os
!= NULL
)
3425 asection
*first_sec
, *last_sec
;
3426 struct lang_output_section_statement_struct
**next
;
3428 /* Snip out the output sections we are moving. */
3429 first_os
->prev
->next
= last_os
->next
;
3430 if (last_os
->next
== NULL
)
3432 next
= &first_os
->prev
->next
;
3433 lang_output_section_statement
.tail
3434 = (lang_statement_union_type
**) next
;
3437 last_os
->next
->prev
= first_os
->prev
;
3438 /* Add them in at the new position. */
3439 last_os
->next
= where
->next
;
3440 if (where
->next
== NULL
)
3442 next
= &last_os
->next
;
3443 lang_output_section_statement
.tail
3444 = (lang_statement_union_type
**) next
;
3447 where
->next
->prev
= last_os
;
3448 first_os
->prev
= where
;
3449 where
->next
= first_os
;
3451 /* Move the bfd sections in the same way. */
3454 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
3456 os
->constraint
= -2 - os
->constraint
;
3457 if (os
->bfd_section
!= NULL
3458 && os
->bfd_section
->owner
!= NULL
)
3460 last_sec
= os
->bfd_section
;
3461 if (first_sec
== NULL
)
3462 first_sec
= last_sec
;
3467 if (last_sec
!= NULL
)
3469 asection
*sec
= where
->bfd_section
;
3471 sec
= output_prev_sec_find (where
);
3473 /* The place we want to insert must come after the
3474 sections we are moving. So if we find no
3475 section or if the section is the same as our
3476 last section, then no move is needed. */
3477 if (sec
!= NULL
&& sec
!= last_sec
)
3479 /* Trim them off. */
3480 if (first_sec
->prev
!= NULL
)
3481 first_sec
->prev
->next
= last_sec
->next
;
3483 link_info
.output_bfd
->sections
= last_sec
->next
;
3484 if (last_sec
->next
!= NULL
)
3485 last_sec
->next
->prev
= first_sec
->prev
;
3487 link_info
.output_bfd
->section_last
= first_sec
->prev
;
3489 last_sec
->next
= sec
->next
;
3490 if (sec
->next
!= NULL
)
3491 sec
->next
->prev
= last_sec
;
3493 link_info
.output_bfd
->section_last
= last_sec
;
3494 first_sec
->prev
= sec
;
3495 sec
->next
= first_sec
;
3503 ptr
= insert_os_after (where
);
3504 /* Snip everything after the abs_section output statement we
3505 know is at the start of the list, up to and including
3506 the insert statement we are currently processing. */
3507 first
= lang_output_section_statement
.head
->header
.next
;
3508 lang_output_section_statement
.head
->header
.next
= (*s
)->header
.next
;
3509 /* Add them back where they belong. */
3512 statement_list
.tail
= s
;
3514 s
= &lang_output_section_statement
.head
;
3518 /* Undo constraint twiddling. */
3519 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
3521 os
->constraint
= -2 - os
->constraint
;
3527 /* An output section might have been removed after its statement was
3528 added. For example, ldemul_before_allocation can remove dynamic
3529 sections if they turn out to be not needed. Clean them up here. */
3532 strip_excluded_output_sections (void)
3534 lang_output_section_statement_type
*os
;
3536 /* Run lang_size_sections (if not already done). */
3537 if (expld
.phase
!= lang_mark_phase_enum
)
3539 expld
.phase
= lang_mark_phase_enum
;
3540 expld
.dataseg
.phase
= exp_dataseg_none
;
3541 one_lang_size_sections_pass (NULL
, FALSE
);
3542 lang_reset_memory_regions ();
3545 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
3549 asection
*output_section
;
3550 bfd_boolean exclude
;
3552 if (os
->constraint
< 0)
3555 output_section
= os
->bfd_section
;
3556 if (output_section
== NULL
)
3559 exclude
= (output_section
->rawsize
== 0
3560 && (output_section
->flags
& SEC_KEEP
) == 0
3561 && !bfd_section_removed_from_list (link_info
.output_bfd
,
3564 /* Some sections have not yet been sized, notably .gnu.version,
3565 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
3566 input sections, so don't drop output sections that have such
3567 input sections unless they are also marked SEC_EXCLUDE. */
3568 if (exclude
&& output_section
->map_head
.s
!= NULL
)
3572 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
3573 if ((s
->flags
& SEC_LINKER_CREATED
) != 0
3574 && (s
->flags
& SEC_EXCLUDE
) == 0)
3581 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
3582 output_section
->map_head
.link_order
= NULL
;
3583 output_section
->map_tail
.link_order
= NULL
;
3587 /* We don't set bfd_section to NULL since bfd_section of the
3588 removed output section statement may still be used. */
3589 if (!os
->section_relative_symbol
3590 && !os
->update_dot_tree
)
3592 output_section
->flags
|= SEC_EXCLUDE
;
3593 bfd_section_list_remove (link_info
.output_bfd
, output_section
);
3594 link_info
.output_bfd
->section_count
--;
3598 /* Stop future calls to lang_add_section from messing with map_head
3599 and map_tail link_order fields. */
3600 stripped_excluded_sections
= TRUE
;
3604 print_output_section_statement
3605 (lang_output_section_statement_type
*output_section_statement
)
3607 asection
*section
= output_section_statement
->bfd_section
;
3610 if (output_section_statement
!= abs_output_section
)
3612 minfo ("\n%s", output_section_statement
->name
);
3614 if (section
!= NULL
)
3616 print_dot
= section
->vma
;
3618 len
= strlen (output_section_statement
->name
);
3619 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
3624 while (len
< SECTION_NAME_MAP_LENGTH
)
3630 minfo ("0x%V %W", section
->vma
, section
->size
);
3632 if (section
->vma
!= section
->lma
)
3633 minfo (_(" load address 0x%V"), section
->lma
);
3635 if (output_section_statement
->update_dot_tree
!= NULL
)
3636 exp_fold_tree (output_section_statement
->update_dot_tree
,
3637 bfd_abs_section_ptr
, &print_dot
);
3643 print_statement_list (output_section_statement
->children
.head
,
3644 output_section_statement
);
3647 /* Scan for the use of the destination in the right hand side
3648 of an expression. In such cases we will not compute the
3649 correct expression, since the value of DST that is used on
3650 the right hand side will be its final value, not its value
3651 just before this expression is evaluated. */
3654 scan_for_self_assignment (const char * dst
, etree_type
* rhs
)
3656 if (rhs
== NULL
|| dst
== NULL
)
3659 switch (rhs
->type
.node_class
)
3662 return scan_for_self_assignment (dst
, rhs
->binary
.lhs
)
3663 || scan_for_self_assignment (dst
, rhs
->binary
.rhs
);
3666 return scan_for_self_assignment (dst
, rhs
->trinary
.lhs
)
3667 || scan_for_self_assignment (dst
, rhs
->trinary
.rhs
);
3670 case etree_provided
:
3672 if (strcmp (dst
, rhs
->assign
.dst
) == 0)
3674 return scan_for_self_assignment (dst
, rhs
->assign
.src
);
3677 return scan_for_self_assignment (dst
, rhs
->unary
.child
);
3681 return strcmp (dst
, rhs
->value
.str
) == 0;
3686 return strcmp (dst
, rhs
->name
.name
) == 0;
3698 print_assignment (lang_assignment_statement_type
*assignment
,
3699 lang_output_section_statement_type
*output_section
)
3703 bfd_boolean computation_is_valid
= TRUE
;
3706 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
3709 if (assignment
->exp
->type
.node_class
== etree_assert
)
3712 tree
= assignment
->exp
->assert_s
.child
;
3713 computation_is_valid
= TRUE
;
3717 const char *dst
= assignment
->exp
->assign
.dst
;
3719 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
3720 tree
= assignment
->exp
->assign
.src
;
3721 computation_is_valid
= is_dot
|| (scan_for_self_assignment (dst
, tree
) == FALSE
);
3724 exp_fold_tree (tree
, output_section
->bfd_section
, &print_dot
);
3725 if (expld
.result
.valid_p
)
3729 if (computation_is_valid
)
3731 value
= expld
.result
.value
;
3733 if (expld
.result
.section
)
3734 value
+= expld
.result
.section
->vma
;
3736 minfo ("0x%V", value
);
3742 struct bfd_link_hash_entry
*h
;
3744 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
3745 FALSE
, FALSE
, TRUE
);
3748 value
= h
->u
.def
.value
;
3750 if (expld
.result
.section
)
3751 value
+= expld
.result
.section
->vma
;
3753 minfo ("[0x%V]", value
);
3756 minfo ("[unresolved]");
3768 exp_print_tree (assignment
->exp
);
3773 print_input_statement (lang_input_statement_type
*statm
)
3775 if (statm
->filename
!= NULL
3776 && (statm
->the_bfd
== NULL
3777 || (statm
->the_bfd
->flags
& BFD_LINKER_CREATED
) == 0))
3778 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
3781 /* Print all symbols defined in a particular section. This is called
3782 via bfd_link_hash_traverse, or by print_all_symbols. */
3785 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
3787 asection
*sec
= ptr
;
3789 if ((hash_entry
->type
== bfd_link_hash_defined
3790 || hash_entry
->type
== bfd_link_hash_defweak
)
3791 && sec
== hash_entry
->u
.def
.section
)
3795 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
3798 (hash_entry
->u
.def
.value
3799 + hash_entry
->u
.def
.section
->output_offset
3800 + hash_entry
->u
.def
.section
->output_section
->vma
));
3802 minfo (" %T\n", hash_entry
->root
.string
);
3809 print_all_symbols (asection
*sec
)
3811 struct fat_user_section_struct
*ud
= get_userdata (sec
);
3812 struct map_symbol_def
*def
;
3817 *ud
->map_symbol_def_tail
= 0;
3818 for (def
= ud
->map_symbol_def_head
; def
; def
= def
->next
)
3819 print_one_symbol (def
->entry
, sec
);
3822 /* Print information about an input section to the map file. */
3825 print_input_section (asection
*i
)
3827 bfd_size_type size
= i
->size
;
3834 minfo ("%s", i
->name
);
3836 len
= 1 + strlen (i
->name
);
3837 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
3842 while (len
< SECTION_NAME_MAP_LENGTH
)
3848 if (i
->output_section
!= NULL
3849 && i
->output_section
->owner
== link_info
.output_bfd
)
3850 addr
= i
->output_section
->vma
+ i
->output_offset
;
3857 minfo ("0x%V %W %B\n", addr
, TO_ADDR (size
), i
->owner
);
3859 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
3861 len
= SECTION_NAME_MAP_LENGTH
+ 3;
3873 minfo (_("%W (size before relaxing)\n"), i
->rawsize
);
3876 if (i
->output_section
!= NULL
3877 && i
->output_section
->owner
== link_info
.output_bfd
)
3879 if (link_info
.reduce_memory_overheads
)
3880 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, i
);
3882 print_all_symbols (i
);
3884 /* Update print_dot, but make sure that we do not move it
3885 backwards - this could happen if we have overlays and a
3886 later overlay is shorter than an earier one. */
3887 if (addr
+ TO_ADDR (size
) > print_dot
)
3888 print_dot
= addr
+ TO_ADDR (size
);
3893 print_fill_statement (lang_fill_statement_type
*fill
)
3897 fputs (" FILL mask 0x", config
.map_file
);
3898 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
3899 fprintf (config
.map_file
, "%02x", *p
);
3900 fputs ("\n", config
.map_file
);
3904 print_data_statement (lang_data_statement_type
*data
)
3912 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
3915 addr
= data
->output_offset
;
3916 if (data
->output_section
!= NULL
)
3917 addr
+= data
->output_section
->vma
;
3945 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
3947 if (data
->exp
->type
.node_class
!= etree_value
)
3950 exp_print_tree (data
->exp
);
3955 print_dot
= addr
+ TO_ADDR (size
);
3958 /* Print an address statement. These are generated by options like
3962 print_address_statement (lang_address_statement_type
*address
)
3964 minfo (_("Address of section %s set to "), address
->section_name
);
3965 exp_print_tree (address
->address
);
3969 /* Print a reloc statement. */
3972 print_reloc_statement (lang_reloc_statement_type
*reloc
)
3979 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
3982 addr
= reloc
->output_offset
;
3983 if (reloc
->output_section
!= NULL
)
3984 addr
+= reloc
->output_section
->vma
;
3986 size
= bfd_get_reloc_size (reloc
->howto
);
3988 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
3990 if (reloc
->name
!= NULL
)
3991 minfo ("%s+", reloc
->name
);
3993 minfo ("%s+", reloc
->section
->name
);
3995 exp_print_tree (reloc
->addend_exp
);
3999 print_dot
= addr
+ TO_ADDR (size
);
4003 print_padding_statement (lang_padding_statement_type
*s
)
4011 len
= sizeof " *fill*" - 1;
4012 while (len
< SECTION_NAME_MAP_LENGTH
)
4018 addr
= s
->output_offset
;
4019 if (s
->output_section
!= NULL
)
4020 addr
+= s
->output_section
->vma
;
4021 minfo ("0x%V %W ", addr
, (bfd_vma
) s
->size
);
4023 if (s
->fill
->size
!= 0)
4027 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
4028 fprintf (config
.map_file
, "%02x", *p
);
4033 print_dot
= addr
+ TO_ADDR (s
->size
);
4037 print_wild_statement (lang_wild_statement_type
*w
,
4038 lang_output_section_statement_type
*os
)
4040 struct wildcard_list
*sec
;
4044 if (w
->filenames_sorted
)
4046 if (w
->filename
!= NULL
)
4047 minfo ("%s", w
->filename
);
4050 if (w
->filenames_sorted
)
4054 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
4056 if (sec
->spec
.sorted
)
4058 if (sec
->spec
.exclude_name_list
!= NULL
)
4061 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
4062 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4063 minfo (" %s", tmp
->name
);
4066 if (sec
->spec
.name
!= NULL
)
4067 minfo ("%s", sec
->spec
.name
);
4070 if (sec
->spec
.sorted
)
4079 print_statement_list (w
->children
.head
, os
);
4082 /* Print a group statement. */
4085 print_group (lang_group_statement_type
*s
,
4086 lang_output_section_statement_type
*os
)
4088 fprintf (config
.map_file
, "START GROUP\n");
4089 print_statement_list (s
->children
.head
, os
);
4090 fprintf (config
.map_file
, "END GROUP\n");
4093 /* Print the list of statements in S.
4094 This can be called for any statement type. */
4097 print_statement_list (lang_statement_union_type
*s
,
4098 lang_output_section_statement_type
*os
)
4102 print_statement (s
, os
);
4107 /* Print the first statement in statement list S.
4108 This can be called for any statement type. */
4111 print_statement (lang_statement_union_type
*s
,
4112 lang_output_section_statement_type
*os
)
4114 switch (s
->header
.type
)
4117 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
4120 case lang_constructors_statement_enum
:
4121 if (constructor_list
.head
!= NULL
)
4123 if (constructors_sorted
)
4124 minfo (" SORT (CONSTRUCTORS)\n");
4126 minfo (" CONSTRUCTORS\n");
4127 print_statement_list (constructor_list
.head
, os
);
4130 case lang_wild_statement_enum
:
4131 print_wild_statement (&s
->wild_statement
, os
);
4133 case lang_address_statement_enum
:
4134 print_address_statement (&s
->address_statement
);
4136 case lang_object_symbols_statement_enum
:
4137 minfo (" CREATE_OBJECT_SYMBOLS\n");
4139 case lang_fill_statement_enum
:
4140 print_fill_statement (&s
->fill_statement
);
4142 case lang_data_statement_enum
:
4143 print_data_statement (&s
->data_statement
);
4145 case lang_reloc_statement_enum
:
4146 print_reloc_statement (&s
->reloc_statement
);
4148 case lang_input_section_enum
:
4149 print_input_section (s
->input_section
.section
);
4151 case lang_padding_statement_enum
:
4152 print_padding_statement (&s
->padding_statement
);
4154 case lang_output_section_statement_enum
:
4155 print_output_section_statement (&s
->output_section_statement
);
4157 case lang_assignment_statement_enum
:
4158 print_assignment (&s
->assignment_statement
, os
);
4160 case lang_target_statement_enum
:
4161 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
4163 case lang_output_statement_enum
:
4164 minfo ("OUTPUT(%s", s
->output_statement
.name
);
4165 if (output_target
!= NULL
)
4166 minfo (" %s", output_target
);
4169 case lang_input_statement_enum
:
4170 print_input_statement (&s
->input_statement
);
4172 case lang_group_statement_enum
:
4173 print_group (&s
->group_statement
, os
);
4175 case lang_insert_statement_enum
:
4176 minfo ("INSERT %s %s\n",
4177 s
->insert_statement
.is_before
? "BEFORE" : "AFTER",
4178 s
->insert_statement
.where
);
4184 print_statements (void)
4186 print_statement_list (statement_list
.head
, abs_output_section
);
4189 /* Print the first N statements in statement list S to STDERR.
4190 If N == 0, nothing is printed.
4191 If N < 0, the entire list is printed.
4192 Intended to be called from GDB. */
4195 dprint_statement (lang_statement_union_type
*s
, int n
)
4197 FILE *map_save
= config
.map_file
;
4199 config
.map_file
= stderr
;
4202 print_statement_list (s
, abs_output_section
);
4205 while (s
&& --n
>= 0)
4207 print_statement (s
, abs_output_section
);
4212 config
.map_file
= map_save
;
4216 insert_pad (lang_statement_union_type
**ptr
,
4218 unsigned int alignment_needed
,
4219 asection
*output_section
,
4222 static fill_type zero_fill
= { 1, { 0 } };
4223 lang_statement_union_type
*pad
= NULL
;
4225 if (ptr
!= &statement_list
.head
)
4226 pad
= ((lang_statement_union_type
*)
4227 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
4229 && pad
->header
.type
== lang_padding_statement_enum
4230 && pad
->padding_statement
.output_section
== output_section
)
4232 /* Use the existing pad statement. */
4234 else if ((pad
= *ptr
) != NULL
4235 && pad
->header
.type
== lang_padding_statement_enum
4236 && pad
->padding_statement
.output_section
== output_section
)
4238 /* Use the existing pad statement. */
4242 /* Make a new padding statement, linked into existing chain. */
4243 pad
= stat_alloc (sizeof (lang_padding_statement_type
));
4244 pad
->header
.next
= *ptr
;
4246 pad
->header
.type
= lang_padding_statement_enum
;
4247 pad
->padding_statement
.output_section
= output_section
;
4250 pad
->padding_statement
.fill
= fill
;
4252 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
4253 pad
->padding_statement
.size
= alignment_needed
;
4254 output_section
->size
+= alignment_needed
;
4257 /* Work out how much this section will move the dot point. */
4261 (lang_statement_union_type
**this_ptr
,
4262 lang_output_section_statement_type
*output_section_statement
,
4266 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
4267 asection
*i
= is
->section
;
4269 if (!((lang_input_statement_type
*) i
->owner
->usrdata
)->just_syms_flag
4270 && (i
->flags
& SEC_EXCLUDE
) == 0)
4272 unsigned int alignment_needed
;
4275 /* Align this section first to the input sections requirement,
4276 then to the output section's requirement. If this alignment
4277 is greater than any seen before, then record it too. Perform
4278 the alignment by inserting a magic 'padding' statement. */
4280 if (output_section_statement
->subsection_alignment
!= -1)
4281 i
->alignment_power
= output_section_statement
->subsection_alignment
;
4283 o
= output_section_statement
->bfd_section
;
4284 if (o
->alignment_power
< i
->alignment_power
)
4285 o
->alignment_power
= i
->alignment_power
;
4287 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
4289 if (alignment_needed
!= 0)
4291 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
4292 dot
+= alignment_needed
;
4295 /* Remember where in the output section this input section goes. */
4297 i
->output_offset
= dot
- o
->vma
;
4299 /* Mark how big the output section must be to contain this now. */
4300 dot
+= TO_ADDR (i
->size
);
4301 o
->size
= TO_SIZE (dot
- o
->vma
);
4305 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
4312 sort_sections_by_lma (const void *arg1
, const void *arg2
)
4314 const asection
*sec1
= *(const asection
**) arg1
;
4315 const asection
*sec2
= *(const asection
**) arg2
;
4317 if (bfd_section_lma (sec1
->owner
, sec1
)
4318 < bfd_section_lma (sec2
->owner
, sec2
))
4320 else if (bfd_section_lma (sec1
->owner
, sec1
)
4321 > bfd_section_lma (sec2
->owner
, sec2
))
4323 else if (sec1
->id
< sec2
->id
)
4325 else if (sec1
->id
> sec2
->id
)
4331 #define IGNORE_SECTION(s) \
4332 ((s->flags & SEC_NEVER_LOAD) != 0 \
4333 || (s->flags & SEC_ALLOC) == 0 \
4334 || ((s->flags & SEC_THREAD_LOCAL) != 0 \
4335 && (s->flags & SEC_LOAD) == 0))
4337 /* Check to see if any allocated sections overlap with other allocated
4338 sections. This can happen if a linker script specifies the output
4339 section addresses of the two sections. Also check whether any memory
4340 region has overflowed. */
4343 lang_check_section_addresses (void)
4346 asection
**sections
, **spp
;
4353 lang_memory_region_type
*m
;
4355 if (bfd_count_sections (link_info
.output_bfd
) <= 1)
4358 amt
= bfd_count_sections (link_info
.output_bfd
) * sizeof (asection
*);
4359 sections
= xmalloc (amt
);
4361 /* Scan all sections in the output list. */
4363 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
4365 /* Only consider loadable sections with real contents. */
4366 if (IGNORE_SECTION (s
) || s
->size
== 0)
4369 sections
[count
] = s
;
4376 qsort (sections
, (size_t) count
, sizeof (asection
*),
4377 sort_sections_by_lma
);
4381 s_start
= bfd_section_lma (link_info
.output_bfd
, s
);
4382 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
4383 for (count
--; count
; count
--)
4385 /* We must check the sections' LMA addresses not their VMA
4386 addresses because overlay sections can have overlapping VMAs
4387 but they must have distinct LMAs. */
4392 s_start
= bfd_section_lma (link_info
.output_bfd
, s
);
4393 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
4395 /* Look for an overlap. */
4396 if (s_end
>= os_start
&& s_start
<= os_end
)
4397 einfo (_("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
4398 s
->name
, s_start
, s_end
, os
->name
, os_start
, os_end
);
4403 /* If any memory region has overflowed, report by how much.
4404 We do not issue this diagnostic for regions that had sections
4405 explicitly placed outside their bounds; os_region_check's
4406 diagnostics are adequate for that case.
4408 FIXME: It is conceivable that m->current - (m->origin + m->length)
4409 might overflow a 32-bit integer. There is, alas, no way to print
4410 a bfd_vma quantity in decimal. */
4411 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
4412 if (m
->had_full_message
)
4413 einfo (_("%X%P: region %s overflowed by %ld bytes\n"),
4414 m
->name
, (long)(m
->current
- (m
->origin
+ m
->length
)));
4418 /* Make sure the new address is within the region. We explicitly permit the
4419 current address to be at the exact end of the region when the address is
4420 non-zero, in case the region is at the end of addressable memory and the
4421 calculation wraps around. */
4424 os_region_check (lang_output_section_statement_type
*os
,
4425 lang_memory_region_type
*region
,
4429 if ((region
->current
< region
->origin
4430 || (region
->current
- region
->origin
> region
->length
))
4431 && ((region
->current
!= region
->origin
+ region
->length
)
4436 einfo (_("%X%P: address 0x%v of %B section %s"
4437 " is not within region %s\n"),
4439 os
->bfd_section
->owner
,
4440 os
->bfd_section
->name
,
4443 else if (!region
->had_full_message
)
4445 region
->had_full_message
= TRUE
;
4447 einfo (_("%X%P: %B section %s will not fit in region %s\n"),
4448 os
->bfd_section
->owner
,
4449 os
->bfd_section
->name
,
4455 /* Set the sizes for all the output sections. */
4458 lang_size_sections_1
4459 (lang_statement_union_type
*s
,
4460 lang_output_section_statement_type
*output_section_statement
,
4461 lang_statement_union_type
**prev
,
4465 bfd_boolean check_regions
)
4467 /* Size up the sections from their constituent parts. */
4468 for (; s
!= NULL
; s
= s
->header
.next
)
4470 switch (s
->header
.type
)
4472 case lang_output_section_statement_enum
:
4474 bfd_vma newdot
, after
;
4475 lang_output_section_statement_type
*os
;
4476 lang_memory_region_type
*r
;
4478 os
= &s
->output_section_statement
;
4479 if (os
->addr_tree
!= NULL
)
4481 os
->processed_vma
= FALSE
;
4482 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
4484 if (expld
.result
.valid_p
)
4485 dot
= expld
.result
.value
+ expld
.result
.section
->vma
;
4486 else if (expld
.phase
!= lang_mark_phase_enum
)
4487 einfo (_("%F%S: non constant or forward reference"
4488 " address expression for section %s\n"),
4492 if (os
->bfd_section
== NULL
)
4493 /* This section was removed or never actually created. */
4496 /* If this is a COFF shared library section, use the size and
4497 address from the input section. FIXME: This is COFF
4498 specific; it would be cleaner if there were some other way
4499 to do this, but nothing simple comes to mind. */
4500 if (((bfd_get_flavour (link_info
.output_bfd
)
4501 == bfd_target_ecoff_flavour
)
4502 || (bfd_get_flavour (link_info
.output_bfd
)
4503 == bfd_target_coff_flavour
))
4504 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
4508 if (os
->children
.head
== NULL
4509 || os
->children
.head
->header
.next
!= NULL
4510 || (os
->children
.head
->header
.type
4511 != lang_input_section_enum
))
4512 einfo (_("%P%X: Internal error on COFF shared library"
4513 " section %s\n"), os
->name
);
4515 input
= os
->children
.head
->input_section
.section
;
4516 bfd_set_section_vma (os
->bfd_section
->owner
,
4518 bfd_section_vma (input
->owner
, input
));
4519 os
->bfd_section
->size
= input
->size
;
4524 if (bfd_is_abs_section (os
->bfd_section
))
4526 /* No matter what happens, an abs section starts at zero. */
4527 ASSERT (os
->bfd_section
->vma
== 0);
4533 if (os
->addr_tree
== NULL
)
4535 /* No address specified for this section, get one
4536 from the region specification. */
4537 if (os
->region
== NULL
4538 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
4539 && os
->region
->name
[0] == '*'
4540 && strcmp (os
->region
->name
,
4541 DEFAULT_MEMORY_REGION
) == 0))
4543 os
->region
= lang_memory_default (os
->bfd_section
);
4546 /* If a loadable section is using the default memory
4547 region, and some non default memory regions were
4548 defined, issue an error message. */
4550 && !IGNORE_SECTION (os
->bfd_section
)
4551 && ! link_info
.relocatable
4553 && strcmp (os
->region
->name
,
4554 DEFAULT_MEMORY_REGION
) == 0
4555 && lang_memory_region_list
!= NULL
4556 && (strcmp (lang_memory_region_list
->name
,
4557 DEFAULT_MEMORY_REGION
) != 0
4558 || lang_memory_region_list
->next
!= NULL
)
4559 && expld
.phase
!= lang_mark_phase_enum
)
4561 /* By default this is an error rather than just a
4562 warning because if we allocate the section to the
4563 default memory region we can end up creating an
4564 excessively large binary, or even seg faulting when
4565 attempting to perform a negative seek. See
4566 sources.redhat.com/ml/binutils/2003-04/msg00423.html
4567 for an example of this. This behaviour can be
4568 overridden by the using the --no-check-sections
4570 if (command_line
.check_section_addresses
)
4571 einfo (_("%P%F: error: no memory region specified"
4572 " for loadable section `%s'\n"),
4573 bfd_get_section_name (link_info
.output_bfd
,
4576 einfo (_("%P: warning: no memory region specified"
4577 " for loadable section `%s'\n"),
4578 bfd_get_section_name (link_info
.output_bfd
,
4582 newdot
= os
->region
->current
;
4583 align
= os
->bfd_section
->alignment_power
;
4586 align
= os
->section_alignment
;
4588 /* Align to what the section needs. */
4591 bfd_vma savedot
= newdot
;
4592 newdot
= align_power (newdot
, align
);
4594 if (newdot
!= savedot
4595 && (config
.warn_section_align
4596 || os
->addr_tree
!= NULL
)
4597 && expld
.phase
!= lang_mark_phase_enum
)
4598 einfo (_("%P: warning: changing start of section"
4599 " %s by %lu bytes\n"),
4600 os
->name
, (unsigned long) (newdot
- savedot
));
4603 bfd_set_section_vma (0, os
->bfd_section
, newdot
);
4605 os
->bfd_section
->output_offset
= 0;
4608 lang_size_sections_1 (os
->children
.head
, os
, &os
->children
.head
,
4609 os
->fill
, newdot
, relax
, check_regions
);
4611 os
->processed_vma
= TRUE
;
4613 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
4614 /* Except for some special linker created sections,
4615 no output section should change from zero size
4616 after strip_excluded_output_sections. A non-zero
4617 size on an ignored section indicates that some
4618 input section was not sized early enough. */
4619 ASSERT (os
->bfd_section
->size
== 0);
4622 dot
= os
->bfd_section
->vma
;
4624 /* Put the section within the requested block size, or
4625 align at the block boundary. */
4627 + TO_ADDR (os
->bfd_section
->size
)
4628 + os
->block_value
- 1)
4629 & - (bfd_vma
) os
->block_value
);
4631 os
->bfd_section
->size
= TO_SIZE (after
- os
->bfd_section
->vma
);
4634 /* Set section lma. */
4637 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
4641 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
4642 os
->bfd_section
->lma
= lma
;
4644 else if (os
->lma_region
!= NULL
)
4646 bfd_vma lma
= os
->lma_region
->current
;
4648 if (os
->section_alignment
!= -1)
4649 lma
= align_power (lma
, os
->section_alignment
);
4650 os
->bfd_section
->lma
= lma
;
4652 else if (r
->last_os
!= NULL
4653 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
4658 last
= r
->last_os
->output_section_statement
.bfd_section
;
4660 /* A backwards move of dot should be accompanied by
4661 an explicit assignment to the section LMA (ie.
4662 os->load_base set) because backwards moves can
4663 create overlapping LMAs. */
4665 && os
->bfd_section
->size
!= 0
4666 && dot
+ os
->bfd_section
->size
<= last
->vma
)
4668 /* If dot moved backwards then leave lma equal to
4669 vma. This is the old default lma, which might
4670 just happen to work when the backwards move is
4671 sufficiently large. Nag if this changes anything,
4672 so people can fix their linker scripts. */
4674 if (last
->vma
!= last
->lma
)
4675 einfo (_("%P: warning: dot moved backwards before `%s'\n"),
4680 /* If this is an overlay, set the current lma to that
4681 at the end of the previous section. */
4682 if (os
->sectype
== overlay_section
)
4683 lma
= last
->lma
+ last
->size
;
4685 /* Otherwise, keep the same lma to vma relationship
4686 as the previous section. */
4688 lma
= dot
+ last
->lma
- last
->vma
;
4690 if (os
->section_alignment
!= -1)
4691 lma
= align_power (lma
, os
->section_alignment
);
4692 os
->bfd_section
->lma
= lma
;
4695 os
->processed_lma
= TRUE
;
4697 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
4700 /* Keep track of normal sections using the default
4701 lma region. We use this to set the lma for
4702 following sections. Overlays or other linker
4703 script assignment to lma might mean that the
4704 default lma == vma is incorrect.
4705 To avoid warnings about dot moving backwards when using
4706 -Ttext, don't start tracking sections until we find one
4707 of non-zero size or with lma set differently to vma. */
4708 if (((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
4709 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0)
4710 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0
4711 && (os
->bfd_section
->size
!= 0
4712 || (r
->last_os
== NULL
4713 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
4714 || (r
->last_os
!= NULL
4715 && dot
>= (r
->last_os
->output_section_statement
4716 .bfd_section
->vma
)))
4717 && os
->lma_region
== NULL
4718 && !link_info
.relocatable
)
4721 /* .tbss sections effectively have zero size. */
4722 if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
4723 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0
4724 || link_info
.relocatable
)
4725 dot
+= TO_ADDR (os
->bfd_section
->size
);
4727 if (os
->update_dot_tree
!= 0)
4728 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
4730 /* Update dot in the region ?
4731 We only do this if the section is going to be allocated,
4732 since unallocated sections do not contribute to the region's
4733 overall size in memory.
4735 If the SEC_NEVER_LOAD bit is not set, it will affect the
4736 addresses of sections after it. We have to update
4738 if (os
->region
!= NULL
4739 && ((os
->bfd_section
->flags
& SEC_NEVER_LOAD
) == 0
4740 || (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))))
4742 os
->region
->current
= dot
;
4745 /* Make sure the new address is within the region. */
4746 os_region_check (os
, os
->region
, os
->addr_tree
,
4747 os
->bfd_section
->vma
);
4749 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
4750 && (os
->bfd_section
->flags
& SEC_LOAD
))
4752 os
->lma_region
->current
4753 = os
->bfd_section
->lma
+ TO_ADDR (os
->bfd_section
->size
);
4756 os_region_check (os
, os
->lma_region
, NULL
,
4757 os
->bfd_section
->lma
);
4763 case lang_constructors_statement_enum
:
4764 dot
= lang_size_sections_1 (constructor_list
.head
,
4765 output_section_statement
,
4766 &s
->wild_statement
.children
.head
,
4767 fill
, dot
, relax
, check_regions
);
4770 case lang_data_statement_enum
:
4772 unsigned int size
= 0;
4774 s
->data_statement
.output_offset
=
4775 dot
- output_section_statement
->bfd_section
->vma
;
4776 s
->data_statement
.output_section
=
4777 output_section_statement
->bfd_section
;
4779 /* We might refer to provided symbols in the expression, and
4780 need to mark them as needed. */
4781 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
4783 switch (s
->data_statement
.type
)
4801 if (size
< TO_SIZE ((unsigned) 1))
4802 size
= TO_SIZE ((unsigned) 1);
4803 dot
+= TO_ADDR (size
);
4804 output_section_statement
->bfd_section
->size
+= size
;
4808 case lang_reloc_statement_enum
:
4812 s
->reloc_statement
.output_offset
=
4813 dot
- output_section_statement
->bfd_section
->vma
;
4814 s
->reloc_statement
.output_section
=
4815 output_section_statement
->bfd_section
;
4816 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
4817 dot
+= TO_ADDR (size
);
4818 output_section_statement
->bfd_section
->size
+= size
;
4822 case lang_wild_statement_enum
:
4823 dot
= lang_size_sections_1 (s
->wild_statement
.children
.head
,
4824 output_section_statement
,
4825 &s
->wild_statement
.children
.head
,
4826 fill
, dot
, relax
, check_regions
);
4829 case lang_object_symbols_statement_enum
:
4830 link_info
.create_object_symbols_section
=
4831 output_section_statement
->bfd_section
;
4834 case lang_output_statement_enum
:
4835 case lang_target_statement_enum
:
4838 case lang_input_section_enum
:
4842 i
= (*prev
)->input_section
.section
;
4847 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
4848 einfo (_("%P%F: can't relax section: %E\n"));
4852 dot
= size_input_section (prev
, output_section_statement
,
4853 output_section_statement
->fill
, dot
);
4857 case lang_input_statement_enum
:
4860 case lang_fill_statement_enum
:
4861 s
->fill_statement
.output_section
=
4862 output_section_statement
->bfd_section
;
4864 fill
= s
->fill_statement
.fill
;
4867 case lang_assignment_statement_enum
:
4869 bfd_vma newdot
= dot
;
4870 etree_type
*tree
= s
->assignment_statement
.exp
;
4872 expld
.dataseg
.relro
= exp_dataseg_relro_none
;
4874 exp_fold_tree (tree
,
4875 output_section_statement
->bfd_section
,
4878 if (expld
.dataseg
.relro
== exp_dataseg_relro_start
)
4880 if (!expld
.dataseg
.relro_start_stat
)
4881 expld
.dataseg
.relro_start_stat
= s
;
4884 ASSERT (expld
.dataseg
.relro_start_stat
== s
);
4887 else if (expld
.dataseg
.relro
== exp_dataseg_relro_end
)
4889 if (!expld
.dataseg
.relro_end_stat
)
4890 expld
.dataseg
.relro_end_stat
= s
;
4893 ASSERT (expld
.dataseg
.relro_end_stat
== s
);
4896 expld
.dataseg
.relro
= exp_dataseg_relro_none
;
4898 /* This symbol is relative to this section. */
4899 if ((tree
->type
.node_class
== etree_provided
4900 || tree
->type
.node_class
== etree_assign
)
4901 && (tree
->assign
.dst
[0] != '.'
4902 || tree
->assign
.dst
[1] != '\0'))
4903 output_section_statement
->section_relative_symbol
= 1;
4905 if (!output_section_statement
->ignored
)
4907 if (output_section_statement
== abs_output_section
)
4909 /* If we don't have an output section, then just adjust
4910 the default memory address. */
4911 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
4912 FALSE
)->current
= newdot
;
4914 else if (newdot
!= dot
)
4916 /* Insert a pad after this statement. We can't
4917 put the pad before when relaxing, in case the
4918 assignment references dot. */
4919 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
4920 output_section_statement
->bfd_section
, dot
);
4922 /* Don't neuter the pad below when relaxing. */
4925 /* If dot is advanced, this implies that the section
4926 should have space allocated to it, unless the
4927 user has explicitly stated that the section
4928 should never be loaded. */
4929 if (!(output_section_statement
->flags
& SEC_NEVER_LOAD
))
4930 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
4937 case lang_padding_statement_enum
:
4938 /* If this is the first time lang_size_sections is called,
4939 we won't have any padding statements. If this is the
4940 second or later passes when relaxing, we should allow
4941 padding to shrink. If padding is needed on this pass, it
4942 will be added back in. */
4943 s
->padding_statement
.size
= 0;
4945 /* Make sure output_offset is valid. If relaxation shrinks
4946 the section and this pad isn't needed, it's possible to
4947 have output_offset larger than the final size of the
4948 section. bfd_set_section_contents will complain even for
4949 a pad size of zero. */
4950 s
->padding_statement
.output_offset
4951 = dot
- output_section_statement
->bfd_section
->vma
;
4954 case lang_group_statement_enum
:
4955 dot
= lang_size_sections_1 (s
->group_statement
.children
.head
,
4956 output_section_statement
,
4957 &s
->group_statement
.children
.head
,
4958 fill
, dot
, relax
, check_regions
);
4961 case lang_insert_statement_enum
:
4964 /* We can only get here when relaxing is turned on. */
4965 case lang_address_statement_enum
:
4972 prev
= &s
->header
.next
;
4977 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
4978 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
4979 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
4980 segments. We are allowed an opportunity to override this decision. */
4983 ldlang_override_segment_assignment (struct bfd_link_info
* info ATTRIBUTE_UNUSED
,
4984 bfd
* abfd ATTRIBUTE_UNUSED
,
4985 asection
* current_section
,
4986 asection
* previous_section
,
4987 bfd_boolean new_segment
)
4989 lang_output_section_statement_type
* cur
;
4990 lang_output_section_statement_type
* prev
;
4992 /* The checks below are only necessary when the BFD library has decided
4993 that the two sections ought to be placed into the same segment. */
4997 /* Paranoia checks. */
4998 if (current_section
== NULL
|| previous_section
== NULL
)
5001 /* Find the memory regions associated with the two sections.
5002 We call lang_output_section_find() here rather than scanning the list
5003 of output sections looking for a matching section pointer because if
5004 we have a large number of sections then a hash lookup is faster. */
5005 cur
= lang_output_section_find (current_section
->name
);
5006 prev
= lang_output_section_find (previous_section
->name
);
5008 /* More paranoia. */
5009 if (cur
== NULL
|| prev
== NULL
)
5012 /* If the regions are different then force the sections to live in
5013 different segments. See the email thread starting at the following
5014 URL for the reasons why this is necessary:
5015 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
5016 return cur
->region
!= prev
->region
;
5020 one_lang_size_sections_pass (bfd_boolean
*relax
, bfd_boolean check_regions
)
5022 lang_statement_iteration
++;
5023 lang_size_sections_1 (statement_list
.head
, abs_output_section
,
5024 &statement_list
.head
, 0, 0, relax
, check_regions
);
5028 lang_size_sections (bfd_boolean
*relax
, bfd_boolean check_regions
)
5030 expld
.phase
= lang_allocating_phase_enum
;
5031 expld
.dataseg
.phase
= exp_dataseg_none
;
5033 one_lang_size_sections_pass (relax
, check_regions
);
5034 if (expld
.dataseg
.phase
== exp_dataseg_end_seen
5035 && link_info
.relro
&& expld
.dataseg
.relro_end
)
5037 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try
5038 to put expld.dataseg.relro on a (common) page boundary. */
5039 bfd_vma min_base
, old_base
, relro_end
, maxpage
;
5041 expld
.dataseg
.phase
= exp_dataseg_relro_adjust
;
5042 maxpage
= expld
.dataseg
.maxpagesize
;
5043 /* MIN_BASE is the absolute minimum address we are allowed to start the
5044 read-write segment (byte before will be mapped read-only). */
5045 min_base
= (expld
.dataseg
.min_base
+ maxpage
- 1) & ~(maxpage
- 1);
5046 /* OLD_BASE is the address for a feasible minimum address which will
5047 still not cause a data overlap inside MAXPAGE causing file offset skip
5049 old_base
= expld
.dataseg
.base
;
5050 expld
.dataseg
.base
+= (-expld
.dataseg
.relro_end
5051 & (expld
.dataseg
.pagesize
- 1));
5052 /* Compute the expected PT_GNU_RELRO segment end. */
5053 relro_end
= ((expld
.dataseg
.relro_end
+ expld
.dataseg
.pagesize
- 1)
5054 & ~(expld
.dataseg
.pagesize
- 1));
5055 if (min_base
+ maxpage
< expld
.dataseg
.base
)
5057 expld
.dataseg
.base
-= maxpage
;
5058 relro_end
-= maxpage
;
5060 lang_reset_memory_regions ();
5061 one_lang_size_sections_pass (relax
, check_regions
);
5062 if (expld
.dataseg
.relro_end
> relro_end
)
5064 /* The alignment of sections between DATA_SEGMENT_ALIGN
5065 and DATA_SEGMENT_RELRO_END caused huge padding to be
5066 inserted at DATA_SEGMENT_RELRO_END. Try to start a bit lower so
5067 that the section alignments will fit in. */
5069 unsigned int max_alignment_power
= 0;
5071 /* Find maximum alignment power of sections between
5072 DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END. */
5073 for (sec
= link_info
.output_bfd
->sections
; sec
; sec
= sec
->next
)
5074 if (sec
->vma
>= expld
.dataseg
.base
5075 && sec
->vma
< expld
.dataseg
.relro_end
5076 && sec
->alignment_power
> max_alignment_power
)
5077 max_alignment_power
= sec
->alignment_power
;
5079 if (((bfd_vma
) 1 << max_alignment_power
) < expld
.dataseg
.pagesize
)
5081 if (expld
.dataseg
.base
- (1 << max_alignment_power
) < old_base
)
5082 expld
.dataseg
.base
+= expld
.dataseg
.pagesize
;
5083 expld
.dataseg
.base
-= (1 << max_alignment_power
);
5084 lang_reset_memory_regions ();
5085 one_lang_size_sections_pass (relax
, check_regions
);
5088 link_info
.relro_start
= expld
.dataseg
.base
;
5089 link_info
.relro_end
= expld
.dataseg
.relro_end
;
5091 else if (expld
.dataseg
.phase
== exp_dataseg_end_seen
)
5093 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
5094 a page could be saved in the data segment. */
5095 bfd_vma first
, last
;
5097 first
= -expld
.dataseg
.base
& (expld
.dataseg
.pagesize
- 1);
5098 last
= expld
.dataseg
.end
& (expld
.dataseg
.pagesize
- 1);
5100 && ((expld
.dataseg
.base
& ~(expld
.dataseg
.pagesize
- 1))
5101 != (expld
.dataseg
.end
& ~(expld
.dataseg
.pagesize
- 1)))
5102 && first
+ last
<= expld
.dataseg
.pagesize
)
5104 expld
.dataseg
.phase
= exp_dataseg_adjust
;
5105 lang_reset_memory_regions ();
5106 one_lang_size_sections_pass (relax
, check_regions
);
5110 expld
.phase
= lang_final_phase_enum
;
5113 /* Worker function for lang_do_assignments. Recursiveness goes here. */
5116 lang_do_assignments_1 (lang_statement_union_type
*s
,
5117 lang_output_section_statement_type
*current_os
,
5121 for (; s
!= NULL
; s
= s
->header
.next
)
5123 switch (s
->header
.type
)
5125 case lang_constructors_statement_enum
:
5126 dot
= lang_do_assignments_1 (constructor_list
.head
,
5127 current_os
, fill
, dot
);
5130 case lang_output_section_statement_enum
:
5132 lang_output_section_statement_type
*os
;
5134 os
= &(s
->output_section_statement
);
5135 if (os
->bfd_section
!= NULL
&& !os
->ignored
)
5137 dot
= os
->bfd_section
->vma
;
5139 lang_do_assignments_1 (os
->children
.head
, os
, os
->fill
, dot
);
5141 /* .tbss sections effectively have zero size. */
5142 if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
5143 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0
5144 || link_info
.relocatable
)
5145 dot
+= TO_ADDR (os
->bfd_section
->size
);
5147 if (os
->update_dot_tree
!= NULL
)
5148 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5153 case lang_wild_statement_enum
:
5155 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
5156 current_os
, fill
, dot
);
5159 case lang_object_symbols_statement_enum
:
5160 case lang_output_statement_enum
:
5161 case lang_target_statement_enum
:
5164 case lang_data_statement_enum
:
5165 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5166 if (expld
.result
.valid_p
)
5167 s
->data_statement
.value
= (expld
.result
.value
5168 + expld
.result
.section
->vma
);
5170 einfo (_("%F%P: invalid data statement\n"));
5173 switch (s
->data_statement
.type
)
5191 if (size
< TO_SIZE ((unsigned) 1))
5192 size
= TO_SIZE ((unsigned) 1);
5193 dot
+= TO_ADDR (size
);
5197 case lang_reloc_statement_enum
:
5198 exp_fold_tree (s
->reloc_statement
.addend_exp
,
5199 bfd_abs_section_ptr
, &dot
);
5200 if (expld
.result
.valid_p
)
5201 s
->reloc_statement
.addend_value
= expld
.result
.value
;
5203 einfo (_("%F%P: invalid reloc statement\n"));
5204 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
5207 case lang_input_section_enum
:
5209 asection
*in
= s
->input_section
.section
;
5211 if ((in
->flags
& SEC_EXCLUDE
) == 0)
5212 dot
+= TO_ADDR (in
->size
);
5216 case lang_input_statement_enum
:
5219 case lang_fill_statement_enum
:
5220 fill
= s
->fill_statement
.fill
;
5223 case lang_assignment_statement_enum
:
5224 exp_fold_tree (s
->assignment_statement
.exp
,
5225 current_os
->bfd_section
,
5229 case lang_padding_statement_enum
:
5230 dot
+= TO_ADDR (s
->padding_statement
.size
);
5233 case lang_group_statement_enum
:
5234 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
5235 current_os
, fill
, dot
);
5238 case lang_insert_statement_enum
:
5241 case lang_address_statement_enum
:
5253 lang_do_assignments (void)
5255 lang_statement_iteration
++;
5256 lang_do_assignments_1 (statement_list
.head
, abs_output_section
, NULL
, 0);
5259 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
5260 operator .startof. (section_name), it produces an undefined symbol
5261 .startof.section_name. Similarly, when it sees
5262 .sizeof. (section_name), it produces an undefined symbol
5263 .sizeof.section_name. For all the output sections, we look for
5264 such symbols, and set them to the correct value. */
5267 lang_set_startof (void)
5271 if (link_info
.relocatable
)
5274 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5276 const char *secname
;
5278 struct bfd_link_hash_entry
*h
;
5280 secname
= bfd_get_section_name (link_info
.output_bfd
, s
);
5281 buf
= xmalloc (10 + strlen (secname
));
5283 sprintf (buf
, ".startof.%s", secname
);
5284 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
5285 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
5287 h
->type
= bfd_link_hash_defined
;
5288 h
->u
.def
.value
= bfd_get_section_vma (link_info
.output_bfd
, s
);
5289 h
->u
.def
.section
= bfd_abs_section_ptr
;
5292 sprintf (buf
, ".sizeof.%s", secname
);
5293 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
5294 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
5296 h
->type
= bfd_link_hash_defined
;
5297 h
->u
.def
.value
= TO_ADDR (s
->size
);
5298 h
->u
.def
.section
= bfd_abs_section_ptr
;
5308 struct bfd_link_hash_entry
*h
;
5311 if ((link_info
.relocatable
&& !link_info
.gc_sections
)
5312 || link_info
.shared
)
5313 warn
= entry_from_cmdline
;
5317 /* Force the user to specify a root when generating a relocatable with
5319 if (link_info
.gc_sections
&& link_info
.relocatable
5320 && (entry_symbol
.name
== NULL
5321 && ldlang_undef_chain_list_head
== NULL
))
5322 einfo (_("%P%F: gc-sections requires either an entry or "
5323 "an undefined symbol\n"));
5325 if (entry_symbol
.name
== NULL
)
5327 /* No entry has been specified. Look for the default entry, but
5328 don't warn if we don't find it. */
5329 entry_symbol
.name
= entry_symbol_default
;
5333 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
5334 FALSE
, FALSE
, TRUE
);
5336 && (h
->type
== bfd_link_hash_defined
5337 || h
->type
== bfd_link_hash_defweak
)
5338 && h
->u
.def
.section
->output_section
!= NULL
)
5342 val
= (h
->u
.def
.value
5343 + bfd_get_section_vma (link_info
.output_bfd
,
5344 h
->u
.def
.section
->output_section
)
5345 + h
->u
.def
.section
->output_offset
);
5346 if (! bfd_set_start_address (link_info
.output_bfd
, val
))
5347 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
.name
);
5354 /* We couldn't find the entry symbol. Try parsing it as a
5356 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
5359 if (! bfd_set_start_address (link_info
.output_bfd
, val
))
5360 einfo (_("%P%F: can't set start address\n"));
5366 /* Can't find the entry symbol, and it's not a number. Use
5367 the first address in the text section. */
5368 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
5372 einfo (_("%P: warning: cannot find entry symbol %s;"
5373 " defaulting to %V\n"),
5375 bfd_get_section_vma (link_info
.output_bfd
, ts
));
5376 if (!(bfd_set_start_address
5377 (link_info
.output_bfd
,
5378 bfd_get_section_vma (link_info
.output_bfd
, ts
))))
5379 einfo (_("%P%F: can't set start address\n"));
5384 einfo (_("%P: warning: cannot find entry symbol %s;"
5385 " not setting start address\n"),
5391 /* Don't bfd_hash_table_free (&lang_definedness_table);
5392 map file output may result in a call of lang_track_definedness. */
5395 /* This is a small function used when we want to ignore errors from
5399 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
5401 /* Don't do anything. */
5404 /* Check that the architecture of all the input files is compatible
5405 with the output file. Also call the backend to let it do any
5406 other checking that is needed. */
5411 lang_statement_union_type
*file
;
5413 const bfd_arch_info_type
*compatible
;
5415 for (file
= file_chain
.head
; file
!= NULL
; file
= file
->input_statement
.next
)
5417 input_bfd
= file
->input_statement
.the_bfd
;
5419 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
5420 command_line
.accept_unknown_input_arch
);
5422 /* In general it is not possible to perform a relocatable
5423 link between differing object formats when the input
5424 file has relocations, because the relocations in the
5425 input format may not have equivalent representations in
5426 the output format (and besides BFD does not translate
5427 relocs for other link purposes than a final link). */
5428 if ((link_info
.relocatable
|| link_info
.emitrelocations
)
5429 && (compatible
== NULL
5430 || (bfd_get_flavour (input_bfd
)
5431 != bfd_get_flavour (link_info
.output_bfd
)))
5432 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
5434 einfo (_("%P%F: Relocatable linking with relocations from"
5435 " format %s (%B) to format %s (%B) is not supported\n"),
5436 bfd_get_target (input_bfd
), input_bfd
,
5437 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
5438 /* einfo with %F exits. */
5441 if (compatible
== NULL
)
5443 if (command_line
.warn_mismatch
)
5444 einfo (_("%P%X: %s architecture of input file `%B'"
5445 " is incompatible with %s output\n"),
5446 bfd_printable_name (input_bfd
), input_bfd
,
5447 bfd_printable_name (link_info
.output_bfd
));
5449 else if (bfd_count_sections (input_bfd
))
5451 /* If the input bfd has no contents, it shouldn't set the
5452 private data of the output bfd. */
5454 bfd_error_handler_type pfn
= NULL
;
5456 /* If we aren't supposed to warn about mismatched input
5457 files, temporarily set the BFD error handler to a
5458 function which will do nothing. We still want to call
5459 bfd_merge_private_bfd_data, since it may set up
5460 information which is needed in the output file. */
5461 if (! command_line
.warn_mismatch
)
5462 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
5463 if (! bfd_merge_private_bfd_data (input_bfd
, link_info
.output_bfd
))
5465 if (command_line
.warn_mismatch
)
5466 einfo (_("%P%X: failed to merge target specific data"
5467 " of file %B\n"), input_bfd
);
5469 if (! command_line
.warn_mismatch
)
5470 bfd_set_error_handler (pfn
);
5475 /* Look through all the global common symbols and attach them to the
5476 correct section. The -sort-common command line switch may be used
5477 to roughly sort the entries by alignment. */
5482 if (command_line
.inhibit_common_definition
)
5484 if (link_info
.relocatable
5485 && ! command_line
.force_common_definition
)
5488 if (! config
.sort_common
)
5489 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
5494 if (config
.sort_common
== sort_descending
)
5496 for (power
= 4; power
> 0; power
--)
5497 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
5500 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
5504 for (power
= 0; power
<= 4; power
++)
5505 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
5508 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
5513 /* Place one common symbol in the correct section. */
5516 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
5518 unsigned int power_of_two
;
5522 if (h
->type
!= bfd_link_hash_common
)
5526 power_of_two
= h
->u
.c
.p
->alignment_power
;
5528 if (config
.sort_common
== sort_descending
5529 && power_of_two
< *(unsigned int *) info
)
5531 else if (config
.sort_common
== sort_ascending
5532 && power_of_two
> *(unsigned int *) info
)
5535 section
= h
->u
.c
.p
->section
;
5537 /* Increase the size of the section to align the common sym. */
5538 section
->size
+= ((bfd_vma
) 1 << (power_of_two
+ opb_shift
)) - 1;
5539 section
->size
&= (- (bfd_vma
) 1 << (power_of_two
+ opb_shift
));
5541 /* Adjust the alignment if necessary. */
5542 if (power_of_two
> section
->alignment_power
)
5543 section
->alignment_power
= power_of_two
;
5545 /* Change the symbol from common to defined. */
5546 h
->type
= bfd_link_hash_defined
;
5547 h
->u
.def
.section
= section
;
5548 h
->u
.def
.value
= section
->size
;
5550 /* Increase the size of the section. */
5551 section
->size
+= size
;
5553 /* Make sure the section is allocated in memory, and make sure that
5554 it is no longer a common section. */
5555 section
->flags
|= SEC_ALLOC
;
5556 section
->flags
&= ~SEC_IS_COMMON
;
5558 if (config
.map_file
!= NULL
)
5560 static bfd_boolean header_printed
;
5565 if (! header_printed
)
5567 minfo (_("\nAllocating common symbols\n"));
5568 minfo (_("Common symbol size file\n\n"));
5569 header_printed
= TRUE
;
5572 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
5573 DMGL_ANSI
| DMGL_PARAMS
);
5576 minfo ("%s", h
->root
.string
);
5577 len
= strlen (h
->root
.string
);
5582 len
= strlen (name
);
5598 if (size
<= 0xffffffff)
5599 sprintf (buf
, "%lx", (unsigned long) size
);
5601 sprintf_vma (buf
, size
);
5611 minfo ("%B\n", section
->owner
);
5617 /* Run through the input files and ensure that every input section has
5618 somewhere to go. If one is found without a destination then create
5619 an input request and place it into the statement tree. */
5622 lang_place_orphans (void)
5624 LANG_FOR_EACH_INPUT_STATEMENT (file
)
5628 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5630 if (s
->output_section
== NULL
)
5632 /* This section of the file is not attached, root
5633 around for a sensible place for it to go. */
5635 if (file
->just_syms_flag
)
5636 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
5637 else if ((s
->flags
& SEC_EXCLUDE
) != 0)
5638 s
->output_section
= bfd_abs_section_ptr
;
5639 else if (strcmp (s
->name
, "COMMON") == 0)
5641 /* This is a lonely common section which must have
5642 come from an archive. We attach to the section
5643 with the wildcard. */
5644 if (! link_info
.relocatable
5645 || command_line
.force_common_definition
)
5647 if (default_common_section
== NULL
)
5648 default_common_section
5649 = lang_output_section_statement_lookup (".bss", 0,
5651 lang_add_section (&default_common_section
->children
, s
,
5652 default_common_section
);
5655 else if (ldemul_place_orphan (s
))
5659 lang_output_section_statement_type
*os
;
5661 os
= lang_output_section_statement_lookup (s
->name
, 0, TRUE
);
5662 lang_add_section (&os
->children
, s
, os
);
5670 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
5672 flagword
*ptr_flags
;
5674 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
5680 *ptr_flags
|= SEC_ALLOC
;
5684 *ptr_flags
|= SEC_READONLY
;
5688 *ptr_flags
|= SEC_DATA
;
5692 *ptr_flags
|= SEC_CODE
;
5697 *ptr_flags
|= SEC_LOAD
;
5701 einfo (_("%P%F: invalid syntax in flags\n"));
5708 /* Call a function on each input file. This function will be called
5709 on an archive, but not on the elements. */
5712 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
5714 lang_input_statement_type
*f
;
5716 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
5718 f
= (lang_input_statement_type
*) f
->next_real_file
)
5722 /* Call a function on each file. The function will be called on all
5723 the elements of an archive which are included in the link, but will
5724 not be called on the archive file itself. */
5727 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
5729 LANG_FOR_EACH_INPUT_STATEMENT (f
)
5736 ldlang_add_file (lang_input_statement_type
*entry
)
5738 lang_statement_append (&file_chain
,
5739 (lang_statement_union_type
*) entry
,
5742 /* The BFD linker needs to have a list of all input BFDs involved in
5744 ASSERT (entry
->the_bfd
->link_next
== NULL
);
5745 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
5747 *link_info
.input_bfds_tail
= entry
->the_bfd
;
5748 link_info
.input_bfds_tail
= &entry
->the_bfd
->link_next
;
5749 entry
->the_bfd
->usrdata
= entry
;
5750 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
5752 /* Look through the sections and check for any which should not be
5753 included in the link. We need to do this now, so that we can
5754 notice when the backend linker tries to report multiple
5755 definition errors for symbols which are in sections we aren't
5756 going to link. FIXME: It might be better to entirely ignore
5757 symbols which are defined in sections which are going to be
5758 discarded. This would require modifying the backend linker for
5759 each backend which might set the SEC_LINK_ONCE flag. If we do
5760 this, we should probably handle SEC_EXCLUDE in the same way. */
5762 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
5766 lang_add_output (const char *name
, int from_script
)
5768 /* Make -o on command line override OUTPUT in script. */
5769 if (!had_output_filename
|| !from_script
)
5771 output_filename
= name
;
5772 had_output_filename
= TRUE
;
5776 static lang_output_section_statement_type
*current_section
;
5787 for (l
= 0; l
< 32; l
++)
5789 if (i
>= (unsigned int) x
)
5797 lang_output_section_statement_type
*
5798 lang_enter_output_section_statement (const char *output_section_statement_name
,
5799 etree_type
*address_exp
,
5800 enum section_type sectype
,
5802 etree_type
*subalign
,
5806 lang_output_section_statement_type
*os
;
5808 os
= lang_output_section_statement_lookup (output_section_statement_name
,
5810 current_section
= os
;
5812 if (os
->addr_tree
== NULL
)
5814 os
->addr_tree
= address_exp
;
5816 os
->sectype
= sectype
;
5817 if (sectype
!= noload_section
)
5818 os
->flags
= SEC_NO_FLAGS
;
5820 os
->flags
= SEC_NEVER_LOAD
;
5821 os
->block_value
= 1;
5823 /* Make next things chain into subchain of this. */
5824 stat_ptr
= &os
->children
;
5826 os
->subsection_alignment
=
5827 topower (exp_get_value_int (subalign
, -1, "subsection alignment"));
5828 os
->section_alignment
=
5829 topower (exp_get_value_int (align
, -1, "section alignment"));
5831 os
->load_base
= ebase
;
5838 lang_output_statement_type
*new;
5840 new = new_stat (lang_output_statement
, stat_ptr
);
5841 new->name
= output_filename
;
5844 /* Reset the current counters in the regions. */
5847 lang_reset_memory_regions (void)
5849 lang_memory_region_type
*p
= lang_memory_region_list
;
5851 lang_output_section_statement_type
*os
;
5853 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
5855 p
->current
= p
->origin
;
5859 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
5863 os
->processed_vma
= FALSE
;
5864 os
->processed_lma
= FALSE
;
5867 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
5869 /* Save the last size for possible use by bfd_relax_section. */
5870 o
->rawsize
= o
->size
;
5875 /* Worker for lang_gc_sections_1. */
5878 gc_section_callback (lang_wild_statement_type
*ptr
,
5879 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
5881 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
5882 void *data ATTRIBUTE_UNUSED
)
5884 /* If the wild pattern was marked KEEP, the member sections
5885 should be as well. */
5886 if (ptr
->keep_sections
)
5887 section
->flags
|= SEC_KEEP
;
5890 /* Iterate over sections marking them against GC. */
5893 lang_gc_sections_1 (lang_statement_union_type
*s
)
5895 for (; s
!= NULL
; s
= s
->header
.next
)
5897 switch (s
->header
.type
)
5899 case lang_wild_statement_enum
:
5900 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
5902 case lang_constructors_statement_enum
:
5903 lang_gc_sections_1 (constructor_list
.head
);
5905 case lang_output_section_statement_enum
:
5906 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
5908 case lang_group_statement_enum
:
5909 lang_gc_sections_1 (s
->group_statement
.children
.head
);
5918 lang_gc_sections (void)
5920 /* Keep all sections so marked in the link script. */
5922 lang_gc_sections_1 (statement_list
.head
);
5924 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
5925 the special case of debug info. (See bfd/stabs.c)
5926 Twiddle the flag here, to simplify later linker code. */
5927 if (link_info
.relocatable
)
5929 LANG_FOR_EACH_INPUT_STATEMENT (f
)
5932 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
5933 if ((sec
->flags
& SEC_DEBUGGING
) == 0)
5934 sec
->flags
&= ~SEC_EXCLUDE
;
5938 if (link_info
.gc_sections
)
5939 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
5942 /* Worker for lang_find_relro_sections_1. */
5945 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
5946 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
5948 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
5951 /* Discarded, excluded and ignored sections effectively have zero
5953 if (section
->output_section
!= NULL
5954 && section
->output_section
->owner
== link_info
.output_bfd
5955 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
5956 && !IGNORE_SECTION (section
)
5957 && section
->size
!= 0)
5959 bfd_boolean
*has_relro_section
= (bfd_boolean
*) data
;
5960 *has_relro_section
= TRUE
;
5964 /* Iterate over sections for relro sections. */
5967 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
5968 bfd_boolean
*has_relro_section
)
5970 if (*has_relro_section
)
5973 for (; s
!= NULL
; s
= s
->header
.next
)
5975 if (s
== expld
.dataseg
.relro_end_stat
)
5978 switch (s
->header
.type
)
5980 case lang_wild_statement_enum
:
5981 walk_wild (&s
->wild_statement
,
5982 find_relro_section_callback
,
5985 case lang_constructors_statement_enum
:
5986 lang_find_relro_sections_1 (constructor_list
.head
,
5989 case lang_output_section_statement_enum
:
5990 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
5993 case lang_group_statement_enum
:
5994 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
6004 lang_find_relro_sections (void)
6006 bfd_boolean has_relro_section
= FALSE
;
6008 /* Check all sections in the link script. */
6010 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
6011 &has_relro_section
);
6013 if (!has_relro_section
)
6014 link_info
.relro
= FALSE
;
6017 /* Relax all sections until bfd_relax_section gives up. */
6020 relax_sections (void)
6022 /* Keep relaxing until bfd_relax_section gives up. */
6023 bfd_boolean relax_again
;
6025 link_info
.relax_trip
= -1;
6028 relax_again
= FALSE
;
6029 link_info
.relax_trip
++;
6031 /* Note: pe-dll.c does something like this also. If you find
6032 you need to change this code, you probably need to change
6033 pe-dll.c also. DJ */
6035 /* Do all the assignments with our current guesses as to
6037 lang_do_assignments ();
6039 /* We must do this after lang_do_assignments, because it uses
6041 lang_reset_memory_regions ();
6043 /* Perform another relax pass - this time we know where the
6044 globals are, so can make a better guess. */
6045 lang_size_sections (&relax_again
, FALSE
);
6047 while (relax_again
);
6053 /* Finalize dynamic list. */
6054 if (link_info
.dynamic_list
)
6055 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
6057 current_target
= default_target
;
6059 /* Open the output file. */
6060 lang_for_each_statement (ldlang_open_output
);
6063 ldemul_create_output_section_statements ();
6065 /* Add to the hash table all undefineds on the command line. */
6066 lang_place_undefineds ();
6068 if (!bfd_section_already_linked_table_init ())
6069 einfo (_("%P%F: Failed to create hash table\n"));
6071 /* Create a bfd for each input file. */
6072 current_target
= default_target
;
6073 open_input_bfds (statement_list
.head
, FALSE
);
6075 link_info
.gc_sym_list
= &entry_symbol
;
6076 if (entry_symbol
.name
== NULL
)
6077 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
6079 ldemul_after_open ();
6081 bfd_section_already_linked_table_free ();
6083 /* Make sure that we're not mixing architectures. We call this
6084 after all the input files have been opened, but before we do any
6085 other processing, so that any operations merge_private_bfd_data
6086 does on the output file will be known during the rest of the
6090 /* Handle .exports instead of a version script if we're told to do so. */
6091 if (command_line
.version_exports_section
)
6092 lang_do_version_exports_section ();
6094 /* Build all sets based on the information gathered from the input
6096 ldctor_build_sets ();
6098 /* Remove unreferenced sections if asked to. */
6099 lang_gc_sections ();
6101 /* Size up the common data. */
6104 /* Update wild statements. */
6105 update_wild_statements (statement_list
.head
);
6107 /* Run through the contours of the script and attach input sections
6108 to the correct output sections. */
6109 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
6111 process_insert_statements ();
6113 /* Find any sections not attached explicitly and handle them. */
6114 lang_place_orphans ();
6116 if (! link_info
.relocatable
)
6120 /* Merge SEC_MERGE sections. This has to be done after GC of
6121 sections, so that GCed sections are not merged, but before
6122 assigning dynamic symbols, since removing whole input sections
6124 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
6126 /* Look for a text section and set the readonly attribute in it. */
6127 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
6131 if (config
.text_read_only
)
6132 found
->flags
|= SEC_READONLY
;
6134 found
->flags
&= ~SEC_READONLY
;
6138 /* Do anything special before sizing sections. This is where ELF
6139 and other back-ends size dynamic sections. */
6140 ldemul_before_allocation ();
6142 /* We must record the program headers before we try to fix the
6143 section positions, since they will affect SIZEOF_HEADERS. */
6144 lang_record_phdrs ();
6146 /* Check relro sections. */
6147 if (link_info
.relro
&& ! link_info
.relocatable
)
6148 lang_find_relro_sections ();
6150 /* Size up the sections. */
6151 lang_size_sections (NULL
, !command_line
.relax
);
6153 /* Now run around and relax if we can. */
6154 if (command_line
.relax
)
6156 /* We may need more than one relaxation pass. */
6157 int i
= link_info
.relax_pass
;
6159 /* The backend can use it to determine the current pass. */
6160 link_info
.relax_pass
= 0;
6165 link_info
.relax_pass
++;
6168 /* Final extra sizing to report errors. */
6169 lang_do_assignments ();
6170 lang_reset_memory_regions ();
6171 lang_size_sections (NULL
, TRUE
);
6174 /* See if anything special should be done now we know how big
6176 ldemul_after_allocation ();
6178 /* Fix any .startof. or .sizeof. symbols. */
6179 lang_set_startof ();
6181 /* Do all the assignments, now that we know the final resting places
6182 of all the symbols. */
6184 lang_do_assignments ();
6188 /* Make sure that the section addresses make sense. */
6189 if (! link_info
.relocatable
6190 && command_line
.check_section_addresses
)
6191 lang_check_section_addresses ();
6196 /* EXPORTED TO YACC */
6199 lang_add_wild (struct wildcard_spec
*filespec
,
6200 struct wildcard_list
*section_list
,
6201 bfd_boolean keep_sections
)
6203 struct wildcard_list
*curr
, *next
;
6204 lang_wild_statement_type
*new;
6206 /* Reverse the list as the parser puts it back to front. */
6207 for (curr
= section_list
, section_list
= NULL
;
6209 section_list
= curr
, curr
= next
)
6211 if (curr
->spec
.name
!= NULL
&& strcmp (curr
->spec
.name
, "COMMON") == 0)
6212 placed_commons
= TRUE
;
6215 curr
->next
= section_list
;
6218 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
6220 if (strcmp (filespec
->name
, "*") == 0)
6221 filespec
->name
= NULL
;
6222 else if (! wildcardp (filespec
->name
))
6223 lang_has_input_file
= TRUE
;
6226 new = new_stat (lang_wild_statement
, stat_ptr
);
6227 new->filename
= NULL
;
6228 new->filenames_sorted
= FALSE
;
6229 if (filespec
!= NULL
)
6231 new->filename
= filespec
->name
;
6232 new->filenames_sorted
= filespec
->sorted
== by_name
;
6234 new->section_list
= section_list
;
6235 new->keep_sections
= keep_sections
;
6236 lang_list_init (&new->children
);
6237 analyze_walk_wild_section_handler (new);
6241 lang_section_start (const char *name
, etree_type
*address
,
6242 const segment_type
*segment
)
6244 lang_address_statement_type
*ad
;
6246 ad
= new_stat (lang_address_statement
, stat_ptr
);
6247 ad
->section_name
= name
;
6248 ad
->address
= address
;
6249 ad
->segment
= segment
;
6252 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
6253 because of a -e argument on the command line, or zero if this is
6254 called by ENTRY in a linker script. Command line arguments take
6258 lang_add_entry (const char *name
, bfd_boolean cmdline
)
6260 if (entry_symbol
.name
== NULL
6262 || ! entry_from_cmdline
)
6264 entry_symbol
.name
= name
;
6265 entry_from_cmdline
= cmdline
;
6269 /* Set the default start symbol to NAME. .em files should use this,
6270 not lang_add_entry, to override the use of "start" if neither the
6271 linker script nor the command line specifies an entry point. NAME
6272 must be permanently allocated. */
6274 lang_default_entry (const char *name
)
6276 entry_symbol_default
= name
;
6280 lang_add_target (const char *name
)
6282 lang_target_statement_type
*new;
6284 new = new_stat (lang_target_statement
, stat_ptr
);
6289 lang_add_map (const char *name
)
6296 map_option_f
= TRUE
;
6304 lang_add_fill (fill_type
*fill
)
6306 lang_fill_statement_type
*new;
6308 new = new_stat (lang_fill_statement
, stat_ptr
);
6313 lang_add_data (int type
, union etree_union
*exp
)
6315 lang_data_statement_type
*new;
6317 new = new_stat (lang_data_statement
, stat_ptr
);
6322 /* Create a new reloc statement. RELOC is the BFD relocation type to
6323 generate. HOWTO is the corresponding howto structure (we could
6324 look this up, but the caller has already done so). SECTION is the
6325 section to generate a reloc against, or NAME is the name of the
6326 symbol to generate a reloc against. Exactly one of SECTION and
6327 NAME must be NULL. ADDEND is an expression for the addend. */
6330 lang_add_reloc (bfd_reloc_code_real_type reloc
,
6331 reloc_howto_type
*howto
,
6334 union etree_union
*addend
)
6336 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
6340 p
->section
= section
;
6342 p
->addend_exp
= addend
;
6344 p
->addend_value
= 0;
6345 p
->output_section
= NULL
;
6346 p
->output_offset
= 0;
6349 lang_assignment_statement_type
*
6350 lang_add_assignment (etree_type
*exp
)
6352 lang_assignment_statement_type
*new;
6354 new = new_stat (lang_assignment_statement
, stat_ptr
);
6360 lang_add_attribute (enum statement_enum attribute
)
6362 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
6366 lang_startup (const char *name
)
6368 if (startup_file
!= NULL
)
6370 einfo (_("%P%F: multiple STARTUP files\n"));
6372 first_file
->filename
= name
;
6373 first_file
->local_sym_name
= name
;
6374 first_file
->real
= TRUE
;
6376 startup_file
= name
;
6380 lang_float (bfd_boolean maybe
)
6382 lang_float_flag
= maybe
;
6386 /* Work out the load- and run-time regions from a script statement, and
6387 store them in *LMA_REGION and *REGION respectively.
6389 MEMSPEC is the name of the run-time region, or the value of
6390 DEFAULT_MEMORY_REGION if the statement didn't specify one.
6391 LMA_MEMSPEC is the name of the load-time region, or null if the
6392 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
6393 had an explicit load address.
6395 It is an error to specify both a load region and a load address. */
6398 lang_get_regions (lang_memory_region_type
**region
,
6399 lang_memory_region_type
**lma_region
,
6400 const char *memspec
,
6401 const char *lma_memspec
,
6402 bfd_boolean have_lma
,
6403 bfd_boolean have_vma
)
6405 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
6407 /* If no runtime region or VMA has been specified, but the load region
6408 has been specified, then use the load region for the runtime region
6410 if (lma_memspec
!= NULL
6412 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
6413 *region
= *lma_region
;
6415 *region
= lang_memory_region_lookup (memspec
, FALSE
);
6417 if (have_lma
&& lma_memspec
!= 0)
6418 einfo (_("%X%P:%S: section has both a load address and a load region\n"));
6422 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
6423 lang_output_section_phdr_list
*phdrs
,
6424 const char *lma_memspec
)
6426 lang_get_regions (¤t_section
->region
,
6427 ¤t_section
->lma_region
,
6428 memspec
, lma_memspec
,
6429 current_section
->load_base
!= NULL
,
6430 current_section
->addr_tree
!= NULL
);
6431 current_section
->fill
= fill
;
6432 current_section
->phdrs
= phdrs
;
6433 stat_ptr
= &statement_list
;
6436 /* Create an absolute symbol with the given name with the value of the
6437 address of first byte of the section named.
6439 If the symbol already exists, then do nothing. */
6442 lang_abs_symbol_at_beginning_of (const char *secname
, const char *name
)
6444 struct bfd_link_hash_entry
*h
;
6446 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, TRUE
, TRUE
);
6448 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6450 if (h
->type
== bfd_link_hash_new
6451 || h
->type
== bfd_link_hash_undefined
)
6455 h
->type
= bfd_link_hash_defined
;
6457 sec
= bfd_get_section_by_name (link_info
.output_bfd
, secname
);
6461 h
->u
.def
.value
= bfd_get_section_vma (link_info
.output_bfd
, sec
);
6463 h
->u
.def
.section
= bfd_abs_section_ptr
;
6467 /* Create an absolute symbol with the given name with the value of the
6468 address of the first byte after the end of the section named.
6470 If the symbol already exists, then do nothing. */
6473 lang_abs_symbol_at_end_of (const char *secname
, const char *name
)
6475 struct bfd_link_hash_entry
*h
;
6477 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, TRUE
, TRUE
);
6479 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6481 if (h
->type
== bfd_link_hash_new
6482 || h
->type
== bfd_link_hash_undefined
)
6486 h
->type
= bfd_link_hash_defined
;
6488 sec
= bfd_get_section_by_name (link_info
.output_bfd
, secname
);
6492 h
->u
.def
.value
= (bfd_get_section_vma (link_info
.output_bfd
, sec
)
6493 + TO_ADDR (sec
->size
));
6495 h
->u
.def
.section
= bfd_abs_section_ptr
;
6500 lang_statement_append (lang_statement_list_type
*list
,
6501 lang_statement_union_type
*element
,
6502 lang_statement_union_type
**field
)
6504 *(list
->tail
) = element
;
6508 /* Set the output format type. -oformat overrides scripts. */
6511 lang_add_output_format (const char *format
,
6516 if (output_target
== NULL
|| !from_script
)
6518 if (command_line
.endian
== ENDIAN_BIG
6521 else if (command_line
.endian
== ENDIAN_LITTLE
6525 output_target
= format
;
6530 lang_add_insert (const char *where
, int is_before
)
6532 lang_insert_statement_type
*new;
6534 new = new_stat (lang_insert_statement
, stat_ptr
);
6536 new->is_before
= is_before
;
6537 saved_script_handle
= previous_script_handle
;
6540 /* Enter a group. This creates a new lang_group_statement, and sets
6541 stat_ptr to build new statements within the group. */
6544 lang_enter_group (void)
6546 lang_group_statement_type
*g
;
6548 g
= new_stat (lang_group_statement
, stat_ptr
);
6549 lang_list_init (&g
->children
);
6550 stat_ptr
= &g
->children
;
6553 /* Leave a group. This just resets stat_ptr to start writing to the
6554 regular list of statements again. Note that this will not work if
6555 groups can occur inside anything else which can adjust stat_ptr,
6556 but currently they can't. */
6559 lang_leave_group (void)
6561 stat_ptr
= &statement_list
;
6564 /* Add a new program header. This is called for each entry in a PHDRS
6565 command in a linker script. */
6568 lang_new_phdr (const char *name
,
6570 bfd_boolean filehdr
,
6575 struct lang_phdr
*n
, **pp
;
6577 n
= stat_alloc (sizeof (struct lang_phdr
));
6580 n
->type
= exp_get_value_int (type
, 0, "program header type");
6581 n
->filehdr
= filehdr
;
6586 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
6591 /* Record the program header information in the output BFD. FIXME: We
6592 should not be calling an ELF specific function here. */
6595 lang_record_phdrs (void)
6599 lang_output_section_phdr_list
*last
;
6600 struct lang_phdr
*l
;
6601 lang_output_section_statement_type
*os
;
6604 secs
= xmalloc (alc
* sizeof (asection
*));
6607 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
6614 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
6618 lang_output_section_phdr_list
*pl
;
6620 if (os
->constraint
< 0)
6628 if (os
->sectype
== noload_section
6629 || os
->bfd_section
== NULL
6630 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
6635 lang_output_section_statement_type
* tmp_os
;
6637 /* If we have not run across a section with a program
6638 header assigned to it yet, then scan forwards to find
6639 one. This prevents inconsistencies in the linker's
6640 behaviour when a script has specified just a single
6641 header and there are sections in that script which are
6642 not assigned to it, and which occur before the first
6643 use of that header. See here for more details:
6644 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
6645 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
6648 last
= tmp_os
->phdrs
;
6652 einfo (_("%F%P: no sections assigned to phdrs\n"));
6657 if (os
->bfd_section
== NULL
)
6660 for (; pl
!= NULL
; pl
= pl
->next
)
6662 if (strcmp (pl
->name
, l
->name
) == 0)
6667 secs
= xrealloc (secs
, alc
* sizeof (asection
*));
6669 secs
[c
] = os
->bfd_section
;
6676 if (l
->flags
== NULL
)
6679 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
6684 at
= exp_get_vma (l
->at
, 0, "phdr load address");
6686 if (! bfd_record_phdr (link_info
.output_bfd
, l
->type
,
6687 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
6688 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
6689 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
6694 /* Make sure all the phdr assignments succeeded. */
6695 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
6699 lang_output_section_phdr_list
*pl
;
6701 if (os
->constraint
< 0
6702 || os
->bfd_section
== NULL
)
6705 for (pl
= os
->phdrs
;
6708 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
6709 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
6710 os
->name
, pl
->name
);
6714 /* Record a list of sections which may not be cross referenced. */
6717 lang_add_nocrossref (lang_nocrossref_type
*l
)
6719 struct lang_nocrossrefs
*n
;
6721 n
= xmalloc (sizeof *n
);
6722 n
->next
= nocrossref_list
;
6724 nocrossref_list
= n
;
6726 /* Set notice_all so that we get informed about all symbols. */
6727 link_info
.notice_all
= TRUE
;
6730 /* Overlay handling. We handle overlays with some static variables. */
6732 /* The overlay virtual address. */
6733 static etree_type
*overlay_vma
;
6734 /* And subsection alignment. */
6735 static etree_type
*overlay_subalign
;
6737 /* An expression for the maximum section size seen so far. */
6738 static etree_type
*overlay_max
;
6740 /* A list of all the sections in this overlay. */
6742 struct overlay_list
{
6743 struct overlay_list
*next
;
6744 lang_output_section_statement_type
*os
;
6747 static struct overlay_list
*overlay_list
;
6749 /* Start handling an overlay. */
6752 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
6754 /* The grammar should prevent nested overlays from occurring. */
6755 ASSERT (overlay_vma
== NULL
6756 && overlay_subalign
== NULL
6757 && overlay_max
== NULL
);
6759 overlay_vma
= vma_expr
;
6760 overlay_subalign
= subalign
;
6763 /* Start a section in an overlay. We handle this by calling
6764 lang_enter_output_section_statement with the correct VMA.
6765 lang_leave_overlay sets up the LMA and memory regions. */
6768 lang_enter_overlay_section (const char *name
)
6770 struct overlay_list
*n
;
6773 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
6774 0, overlay_subalign
, 0, 0);
6776 /* If this is the first section, then base the VMA of future
6777 sections on this one. This will work correctly even if `.' is
6778 used in the addresses. */
6779 if (overlay_list
== NULL
)
6780 overlay_vma
= exp_nameop (ADDR
, name
);
6782 /* Remember the section. */
6783 n
= xmalloc (sizeof *n
);
6784 n
->os
= current_section
;
6785 n
->next
= overlay_list
;
6788 size
= exp_nameop (SIZEOF
, name
);
6790 /* Arrange to work out the maximum section end address. */
6791 if (overlay_max
== NULL
)
6794 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
6797 /* Finish a section in an overlay. There isn't any special to do
6801 lang_leave_overlay_section (fill_type
*fill
,
6802 lang_output_section_phdr_list
*phdrs
)
6809 name
= current_section
->name
;
6811 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
6812 region and that no load-time region has been specified. It doesn't
6813 really matter what we say here, since lang_leave_overlay will
6815 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
6817 /* Define the magic symbols. */
6819 clean
= xmalloc (strlen (name
) + 1);
6821 for (s1
= name
; *s1
!= '\0'; s1
++)
6822 if (ISALNUM (*s1
) || *s1
== '_')
6826 buf
= xmalloc (strlen (clean
) + sizeof "__load_start_");
6827 sprintf (buf
, "__load_start_%s", clean
);
6828 lang_add_assignment (exp_provide (buf
,
6829 exp_nameop (LOADADDR
, name
),
6832 buf
= xmalloc (strlen (clean
) + sizeof "__load_stop_");
6833 sprintf (buf
, "__load_stop_%s", clean
);
6834 lang_add_assignment (exp_provide (buf
,
6836 exp_nameop (LOADADDR
, name
),
6837 exp_nameop (SIZEOF
, name
)),
6843 /* Finish an overlay. If there are any overlay wide settings, this
6844 looks through all the sections in the overlay and sets them. */
6847 lang_leave_overlay (etree_type
*lma_expr
,
6850 const char *memspec
,
6851 lang_output_section_phdr_list
*phdrs
,
6852 const char *lma_memspec
)
6854 lang_memory_region_type
*region
;
6855 lang_memory_region_type
*lma_region
;
6856 struct overlay_list
*l
;
6857 lang_nocrossref_type
*nocrossref
;
6859 lang_get_regions (®ion
, &lma_region
,
6860 memspec
, lma_memspec
,
6861 lma_expr
!= NULL
, FALSE
);
6865 /* After setting the size of the last section, set '.' to end of the
6867 if (overlay_list
!= NULL
)
6868 overlay_list
->os
->update_dot_tree
6869 = exp_assop ('=', ".", exp_binop ('+', overlay_vma
, overlay_max
));
6874 struct overlay_list
*next
;
6876 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
6879 l
->os
->region
= region
;
6880 l
->os
->lma_region
= lma_region
;
6882 /* The first section has the load address specified in the
6883 OVERLAY statement. The rest are worked out from that.
6884 The base address is not needed (and should be null) if
6885 an LMA region was specified. */
6888 l
->os
->load_base
= lma_expr
;
6889 l
->os
->sectype
= normal_section
;
6891 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
6892 l
->os
->phdrs
= phdrs
;
6896 lang_nocrossref_type
*nc
;
6898 nc
= xmalloc (sizeof *nc
);
6899 nc
->name
= l
->os
->name
;
6900 nc
->next
= nocrossref
;
6909 if (nocrossref
!= NULL
)
6910 lang_add_nocrossref (nocrossref
);
6913 overlay_list
= NULL
;
6917 /* Version handling. This is only useful for ELF. */
6919 /* This global variable holds the version tree that we build. */
6921 struct bfd_elf_version_tree
*lang_elf_version_info
;
6923 /* If PREV is NULL, return first version pattern matching particular symbol.
6924 If PREV is non-NULL, return first version pattern matching particular
6925 symbol after PREV (previously returned by lang_vers_match). */
6927 static struct bfd_elf_version_expr
*
6928 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
6929 struct bfd_elf_version_expr
*prev
,
6932 const char *cxx_sym
= sym
;
6933 const char *java_sym
= sym
;
6934 struct bfd_elf_version_expr
*expr
= NULL
;
6936 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
6938 cxx_sym
= cplus_demangle (sym
, DMGL_PARAMS
| DMGL_ANSI
);
6942 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
6944 java_sym
= cplus_demangle (sym
, DMGL_JAVA
);
6949 if (head
->htab
&& (prev
== NULL
|| prev
->symbol
))
6951 struct bfd_elf_version_expr e
;
6953 switch (prev
? prev
->mask
: 0)
6956 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
6959 expr
= htab_find (head
->htab
, &e
);
6960 while (expr
&& strcmp (expr
->symbol
, sym
) == 0)
6961 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
6967 case BFD_ELF_VERSION_C_TYPE
:
6968 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
6971 expr
= htab_find (head
->htab
, &e
);
6972 while (expr
&& strcmp (expr
->symbol
, cxx_sym
) == 0)
6973 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
6979 case BFD_ELF_VERSION_CXX_TYPE
:
6980 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
6982 e
.symbol
= java_sym
;
6983 expr
= htab_find (head
->htab
, &e
);
6984 while (expr
&& strcmp (expr
->symbol
, java_sym
) == 0)
6985 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
6996 /* Finally, try the wildcards. */
6997 if (prev
== NULL
|| prev
->symbol
)
6998 expr
= head
->remaining
;
7001 for (; expr
; expr
= expr
->next
)
7008 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
7011 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
7013 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
7017 if (fnmatch (expr
->pattern
, s
, 0) == 0)
7023 free ((char *) cxx_sym
);
7024 if (java_sym
!= sym
)
7025 free ((char *) java_sym
);
7029 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
7030 return a string pointing to the symbol name. */
7033 realsymbol (const char *pattern
)
7036 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
7037 char *s
, *symbol
= xmalloc (strlen (pattern
) + 1);
7039 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
7041 /* It is a glob pattern only if there is no preceding
7043 if (! backslash
&& (*p
== '?' || *p
== '*' || *p
== '['))
7051 /* Remove the preceding backslash. */
7058 backslash
= *p
== '\\';
7073 /* This is called for each variable name or match expression. NEW is
7074 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
7075 pattern to be matched against symbol names. */
7077 struct bfd_elf_version_expr
*
7078 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
7081 bfd_boolean literal_p
)
7083 struct bfd_elf_version_expr
*ret
;
7085 ret
= xmalloc (sizeof *ret
);
7087 ret
->pattern
= literal_p
? NULL
: new;
7090 ret
->symbol
= literal_p
? new : realsymbol (new);
7092 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
7093 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
7094 else if (strcasecmp (lang
, "C++") == 0)
7095 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
7096 else if (strcasecmp (lang
, "Java") == 0)
7097 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
7100 einfo (_("%X%P: unknown language `%s' in version information\n"),
7102 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
7105 return ldemul_new_vers_pattern (ret
);
7108 /* This is called for each set of variable names and match
7111 struct bfd_elf_version_tree
*
7112 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
7113 struct bfd_elf_version_expr
*locals
)
7115 struct bfd_elf_version_tree
*ret
;
7117 ret
= xcalloc (1, sizeof *ret
);
7118 ret
->globals
.list
= globals
;
7119 ret
->locals
.list
= locals
;
7120 ret
->match
= lang_vers_match
;
7121 ret
->name_indx
= (unsigned int) -1;
7125 /* This static variable keeps track of version indices. */
7127 static int version_index
;
7130 version_expr_head_hash (const void *p
)
7132 const struct bfd_elf_version_expr
*e
= p
;
7134 return htab_hash_string (e
->symbol
);
7138 version_expr_head_eq (const void *p1
, const void *p2
)
7140 const struct bfd_elf_version_expr
*e1
= p1
;
7141 const struct bfd_elf_version_expr
*e2
= p2
;
7143 return strcmp (e1
->symbol
, e2
->symbol
) == 0;
7147 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
7150 struct bfd_elf_version_expr
*e
, *next
;
7151 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
7153 for (e
= head
->list
; e
; e
= e
->next
)
7157 head
->mask
|= e
->mask
;
7162 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
7163 version_expr_head_eq
, NULL
);
7164 list_loc
= &head
->list
;
7165 remaining_loc
= &head
->remaining
;
7166 for (e
= head
->list
; e
; e
= next
)
7172 remaining_loc
= &e
->next
;
7176 void **loc
= htab_find_slot (head
->htab
, e
, INSERT
);
7180 struct bfd_elf_version_expr
*e1
, *last
;
7186 if (e1
->mask
== e
->mask
)
7194 while (e1
&& strcmp (e1
->symbol
, e
->symbol
) == 0);
7198 /* This is a duplicate. */
7199 /* FIXME: Memory leak. Sometimes pattern is not
7200 xmalloced alone, but in larger chunk of memory. */
7201 /* free (e->symbol); */
7206 e
->next
= last
->next
;
7214 list_loc
= &e
->next
;
7218 *remaining_loc
= NULL
;
7219 *list_loc
= head
->remaining
;
7222 head
->remaining
= head
->list
;
7225 /* This is called when we know the name and dependencies of the
7229 lang_register_vers_node (const char *name
,
7230 struct bfd_elf_version_tree
*version
,
7231 struct bfd_elf_version_deps
*deps
)
7233 struct bfd_elf_version_tree
*t
, **pp
;
7234 struct bfd_elf_version_expr
*e1
;
7239 if ((name
[0] == '\0' && lang_elf_version_info
!= NULL
)
7240 || (lang_elf_version_info
&& lang_elf_version_info
->name
[0] == '\0'))
7242 einfo (_("%X%P: anonymous version tag cannot be combined"
7243 " with other version tags\n"));
7248 /* Make sure this node has a unique name. */
7249 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
7250 if (strcmp (t
->name
, name
) == 0)
7251 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
7253 lang_finalize_version_expr_head (&version
->globals
);
7254 lang_finalize_version_expr_head (&version
->locals
);
7256 /* Check the global and local match names, and make sure there
7257 aren't any duplicates. */
7259 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
7261 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
7263 struct bfd_elf_version_expr
*e2
;
7265 if (t
->locals
.htab
&& e1
->symbol
)
7267 e2
= htab_find (t
->locals
.htab
, e1
);
7268 while (e2
&& strcmp (e1
->symbol
, e2
->symbol
) == 0)
7270 if (e1
->mask
== e2
->mask
)
7271 einfo (_("%X%P: duplicate expression `%s'"
7272 " in version information\n"), e1
->symbol
);
7276 else if (!e1
->symbol
)
7277 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
7278 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
7279 && e1
->mask
== e2
->mask
)
7280 einfo (_("%X%P: duplicate expression `%s'"
7281 " in version information\n"), e1
->pattern
);
7285 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
7287 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
7289 struct bfd_elf_version_expr
*e2
;
7291 if (t
->globals
.htab
&& e1
->symbol
)
7293 e2
= htab_find (t
->globals
.htab
, e1
);
7294 while (e2
&& strcmp (e1
->symbol
, e2
->symbol
) == 0)
7296 if (e1
->mask
== e2
->mask
)
7297 einfo (_("%X%P: duplicate expression `%s'"
7298 " in version information\n"),
7303 else if (!e1
->symbol
)
7304 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
7305 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
7306 && e1
->mask
== e2
->mask
)
7307 einfo (_("%X%P: duplicate expression `%s'"
7308 " in version information\n"), e1
->pattern
);
7312 version
->deps
= deps
;
7313 version
->name
= name
;
7314 if (name
[0] != '\0')
7317 version
->vernum
= version_index
;
7320 version
->vernum
= 0;
7322 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
7327 /* This is called when we see a version dependency. */
7329 struct bfd_elf_version_deps
*
7330 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
7332 struct bfd_elf_version_deps
*ret
;
7333 struct bfd_elf_version_tree
*t
;
7335 ret
= xmalloc (sizeof *ret
);
7338 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
7340 if (strcmp (t
->name
, name
) == 0)
7342 ret
->version_needed
= t
;
7347 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
7353 lang_do_version_exports_section (void)
7355 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
7357 LANG_FOR_EACH_INPUT_STATEMENT (is
)
7359 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
7367 contents
= xmalloc (len
);
7368 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
7369 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
7372 while (p
< contents
+ len
)
7374 greg
= lang_new_vers_pattern (greg
, p
, NULL
, FALSE
);
7375 p
= strchr (p
, '\0') + 1;
7378 /* Do not free the contents, as we used them creating the regex. */
7380 /* Do not include this section in the link. */
7381 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
7384 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, FALSE
);
7385 lang_register_vers_node (command_line
.version_exports_section
,
7386 lang_new_vers_node (greg
, lreg
), NULL
);
7390 lang_add_unique (const char *name
)
7392 struct unique_sections
*ent
;
7394 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
7395 if (strcmp (ent
->name
, name
) == 0)
7398 ent
= xmalloc (sizeof *ent
);
7399 ent
->name
= xstrdup (name
);
7400 ent
->next
= unique_section_list
;
7401 unique_section_list
= ent
;
7404 /* Append the list of dynamic symbols to the existing one. */
7407 lang_append_dynamic_list (struct bfd_elf_version_expr
*dynamic
)
7409 if (link_info
.dynamic_list
)
7411 struct bfd_elf_version_expr
*tail
;
7412 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
7414 tail
->next
= link_info
.dynamic_list
->head
.list
;
7415 link_info
.dynamic_list
->head
.list
= dynamic
;
7419 struct bfd_elf_dynamic_list
*d
;
7421 d
= xcalloc (1, sizeof *d
);
7422 d
->head
.list
= dynamic
;
7423 d
->match
= lang_vers_match
;
7424 link_info
.dynamic_list
= d
;
7428 /* Append the list of C++ typeinfo dynamic symbols to the existing
7432 lang_append_dynamic_list_cpp_typeinfo (void)
7434 const char * symbols
[] =
7436 "typeinfo name for*",
7439 struct bfd_elf_version_expr
*dynamic
= NULL
;
7442 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
7443 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
7446 lang_append_dynamic_list (dynamic
);
7449 /* Append the list of C++ operator new and delete dynamic symbols to the
7453 lang_append_dynamic_list_cpp_new (void)
7455 const char * symbols
[] =
7460 struct bfd_elf_version_expr
*dynamic
= NULL
;
7463 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
7464 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
7467 lang_append_dynamic_list (dynamic
);